Power Query W Excelu I Power Bi Zbieranie I Przeksztalcanie Danych Gil Raviv Ebookpoint - PL

Tytuł oryginału: Collect, Combine, and Transform Data Using Power Query in Excel
and Power BI (Business Skills)
Tłumaczenie: Andrzej Watrak
ISBN: 978-83-8322-472-5
Authorized translation from the English language edition, entitled COLLECT, COMBINE, AND
TRANSFORM DATA USING POWER QUERY IN EXCEL AND POWER BI, 1st Edition by RAVIV, GIL,
published by Pearson Education, Inc, publishing as Microsoft Press, Copyright © 2019 by Gil Raviv.
All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means,
electronic or mechanical, including photocopying, recording or by any information storage retrieval
system, without permission from Pearson Education, Inc.
Electronic POLISH language edition published by HELION S.A., Copyright © 2020, 2023.
Microsoft and the trademarks listed at http://www.microsoft.com on the “Trademarks” web page are
trademarks of the Microsoft group of companies. All other marks are the property of their respective owners.
Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej

publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną,
fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym
powoduje naruszenie praw autorskich niniejszej publikacji.
Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi

ich właścicieli.
Autor oraz wydawca dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne
i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym
ewentualne naruszenie praw patentowych lub autorskich. Autor oraz wydawca nie ponoszą również
żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce.
Helion S.A.
ul. Kościuszki 1c, 44-100 Gliwice
tel. 32 230 98 63
e-mail: helion@helion.pl
WWW: https://helion.pl (księgarnia internetowa, katalog książek)
Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
https://helion.pl/user/opinie/poquev_ebook
Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.
 Poleć książkę na Facebook.com  Księgarnia internetowa

 Kup w wersji papierowej  Lubię to! » Nasza społeczność
 Oceń książkę
4650570396d9eb2765da56c12eb840b5
4
Spis treści
Przedmowa ......................................................................................................11
O autorze ..........................................................................................................13
Podziękowania .................................................................................................14
Wprowadzenie .................................................................................................17
Rozdział 1. Wprowadzenie do Power Query .......................................................................27
Czym jest Power Query? ...............................................................................................................28
Historia Power Query w skrócie ...........................................................................................29
Gdzie znajduje się Power Query? .........................................................................................32
Główne komponenty Power Query ............................................................................................33
Pobieranie danych i tworzenie połączeń .............................................................................33
Najważniejsze elementy edytora Power Query ..................................................................34
Ćwiczenie 1.1. Pierwsze kroki z Power Query ..........................................................................39
Podsumowanie ...............................................................................................................................43
Rozdział 2. Podstawowe operacje przygotowywania danych ............................................45

Wyodrębnianie informacji z zakodowanych danych ...............................................................46
Fabryka Przygód .....................................................................................................................46
Ćwiczenie 2.1. Stary sposób: formuły Excela ......................................................................47
Ćwiczenie 2.2. Część I. Nowy sposób ..................................................................................48
Ćwiczenie 2.2. Część II. Scalanie tabel wyszukiwania .......................................................51
Ćwiczenie 2.2. Część III. Tabele faktów i wyszukiwania ..................................................55
Kolumna z przykładów .................................................................................................................57
Ćwiczenie 2.3. Część I. Kolumna z przykładów — wprowadzenie .................................57
Kolumna z przykładów w praktyce ......................................................................................59
Ćwiczenie 2.3. Część II. Zamiana wielkości na oznaczenie zakresu ...............................59
Wyodrębnianie informacji z kolumn tekstowych ....................................................................62
Ćwiczenie 2.4. Wyodrębnianie odnośników z komunikatów tekstowych .....................62
4650570396d9eb2765da56c12eb840b5
4
SPIS TREŚCI
Operacje na datach ........................................................................................................................69

Ćwiczenie 2.5. Operacje na różnych formatach dat ..........................................................69
Ćwiczenie 2.6. Operacje na datach z różnymi ustawieniami regionalnymi ..................71
Wyodrębnianie elementów daty i czasu ..............................................................................74
Przygotowanie modelu .................................................................................................................75
Ćwiczenie 2.7. Dzielenie danych na tabelę faktów i tabelę wyszukiwania .....................75
Ćwiczenie 2.8. Zamiana wartości oddzielonych ogranicznikami na wiersze ................78
Podsumowanie ...............................................................................................................................80
Rozdział 3. Łączenie danych z kilku źródeł .........................................................................81

Łączenie kliku tabel .......................................................................................................................81
Łączenie dwóch tabel .............................................................................................................82
Ćwiczenie 3.1. Rowery i akcesoria .......................................................................................82
Ćwiczenie 3.2. Część I. Przekształcenie „Dołącz zapytania jako nowe” .........................84
Ćwiczenie 3.2. Część II. Zależności między zapytaniami i odwołania ...........................84
Łączenie trzech lub więcej tabel ............................................................................................87
Ćwiczenie 3.2. Część III. Rowery + Akcesoria + Komponenty .......................................87
Ćwiczenie 3.2. Część IV. Rowery + Akcesoria + Komponenty + Ubrania ....................88
Łączenie tabel na szerszą skalę .....................................................................................................89
Łączenie tabel zapisanych w folderze ..................................................................................89
Ćwiczenie 3.3. Łączenie skoroszytów z produktami zapisanymi w folderze .................90
Uwagi do importowania plików z folderu ..........................................................................92
Łączenie arkuszy w skoroszycie ............................................................................................92
Ćwiczenie 3.4. Łączenie arkuszy — rozwiązanie ...............................................................93
Podsumowanie ...............................................................................................................................97
Rozdział 4. Łączenie niezgodnych tabel .............................................................................99

Problem z niezgodnymi tabelami ................................................................................................99
Co to jest niezgodność tabel? ............................................................................................. 100
Symptomy niezgodności tabel i związane z tym ryzyka ................................................ 100
Ćwiczenie 4.1. Uzgadnianie kolumn: podejście reaktywne ........................................... 101
Łączenie niezgodnych tabel zapisanych w folderze ............................................................... 102
Ćwiczenie 4.2. Część I. Symptom braku wartości ........................................................... 102
Ćwiczenie 4.2. Część II. Założenie takiej samej kolejności kolumn
i ujednolicenie nagłówków .............................................................................................. 104
Ćwiczenie 4.3. Proste ujednolicenie nagłówków za pomocą funkcji
Table.TransformColumnNames .................................................................................... 105
Tabela konwersji .................................................................................................................. 108
Ćwiczenie 4.4. Transpozycja z użyciem tabeli konwersji .............................................. 109
Ćwiczenie 4.5. Anulowanie przestawienia, scalenie i powtórne przestawienie .......... 113
Ćwiczenie 4.6. Transpozycja samych nazw kolumn ...................................................... 114
Ćwiczenie 4.7. Ujednolicenie nazw kolumn za pomocą języka M ............................... 119
Podsumowanie ............................................................................................................................ 122
4650570396d9eb2765da56c12eb840b5
4
SPIS TREŚCI
Rozdział 5. Pozyskiwanie kontekstu .................................................................................123

Pozyskiwanie kontekstu zawartego w nazwach plików i skoroszytów ............................... 124
Ćwiczenie 5.1. Część I. Kolumna niestandardowa ......................................................... 124
Ćwiczenie 5.1. Część II. Pozyskiwanie kontekstu z nazwy pliku lub arkusza ............ 125
Pozyskiwanie kontekstu z tytułów tabel przed ich połączeniem ......................................... 126
Ćwiczenie 5.2. Pozyskiwanie kontekstu z tytułów tabel
za pomocą przekształcenia Drill Down ......................................................................... 127
Ćwiczenie 5.3. Pozyskiwanie kontekstu z tytułów tabel podczas importowania
plików z folderu ................................................................................................................. 130
Pozyskiwanie kontekstu z tytułów tabel po ich połączeniu ................................................. 133
Ćwiczenie 5.4. Pozyskiwanie kontekstu z tytułów tabel zapisanych w arkuszach
jednego skoroszytu ........................................................................................................... 133
Wskazówki kontekstowe ........................................................................................................... 137
Ćwiczenie 5.5. Kolumna indeksu jako wskazówka ......................................................... 137
Ćwiczenie 5.6. Wyszukiwanie informacji kontekstowych
w pobliżu określonych komórek .................................................................................... 140
Podsumowanie ............................................................................................................................ 143
Rozdział 6. Dekomponowanie tabel .................................................................................145

Rozpoznawanie źle zaprojektowanych tabel .......................................................................... 146
Wprowadzenie do anulowania przestawienia ........................................................................ 148
Ćwiczenie 6.1. Przekształcenia Anuluj przestawienie kolumn
i Anuluj przestawienie innych kolumn ......................................................................... 149
Ćwiczenie 6.2. Anulowanie przestawienia tylko zaznaczonych kolumn .................... 151
Przetwarzanie sum całkowitych ............................................................................................... 152
Ćwiczenie 6.3. Dekompozycja tabeli zawierającej sumy całkowite .............................. 153
Dekompozycja tabeli z hierarchią agregacji danych 22 ...................................................... 155
Ćwiczenie 6.4. Dekompozycja tabeli z hierarchią agregacji danych 22 i datami ..... 155
Ćwiczenie 6.5. Dekompozycja tabeli z hierarchią agregacji danych 2×2 .................... 158
Przetwarzanie sum częściowych ............................................................................................... 160
Ćwiczenie 6.6. Przetwarzanie sum częściowych ............................................................. 160
Podsumowanie ............................................................................................................................ 162
Rozdział 7. Zaawansowane metody dekomponowania i agregowania tabel ...................163

Dekomponowanie tabeli z wielopoziomową hierarchią agregacji danych ........................ 164
Wirtualna tabela przestawna, pola wierszy i kolumn ..................................................... 164
Ćwiczenie 7.1. Dekompozycja tabeli z hierarchią agregacji danych N×M ................. 165
Uogólnienie sekwencji przekształceń dekomponujących tabelę ......................................... 167
Ćwiczenie 7.2. Zaczynając od końca ................................................................................. 168
Ćwiczenie 7.3. Tworzenie funkcji FnDekomponujTabelę ............................................ 169
Przekształcenie Kolumna przestawna ..................................................................................... 178
Ćwiczenie 7.4. Przywrócenie niewłaściwie zdekomponowanej tabeli ......................... 178
Ćwiczenie 7.5. Agregowanie tabel z wielowierszowymi rekordami ............................. 180
Podsumowanie ............................................................................................................................ 184
4650570396d9eb2765da56c12eb840b5
4
SPIS TREŚCI
Rozdział 8. Praca grupowa ...............................................................................................185

Pliki lokalne, parametry i szablony .......................................................................................... 186
Niewłaściwe korzystanie z lokalnych plików ................................................................... 186
Ćwiczenie 8.1. Zdefiniowanie parametru z nazwą ścieżki ............................................. 187
Ćwiczenie 8.2. Tworzenie szablonów w Power BI .......................................................... 189
Ćwiczenie 8.3. Definiowanie parametrów w Excelu ...................................................... 191
Praca nad współdzielonymi plikami i folderami ................................................................... 197
Importowanie danych z plików zapisanych w usługach OneDrive dla Firm
i SharePoint ........................................................................................................................ 197
Ćwiczenie 8.4. Tworzenie zapytań łączących się z usługami OneDrive dla Firm
i SharePoint ........................................................................................................................ 199
Ćwiczenie 8.5. Od lokalnych folderów do usługi SharePoint ....................................... 200
Zagadnienia bezpieczeństwa ..................................................................................................... 202
Usuwanie zapytań w drodze inspekcji skoroszytu Excela ............................................. 203
Podsumowanie ............................................................................................................................ 204
Rozdział 9. Wprowadzenie do języka M ...........................................................................205

Nauka języka M .......................................................................................................................... 206
Etapy opanowania języka M .............................................................................................. 206
Informacje online ................................................................................................................ 209
Informacje offline ................................................................................................................ 209
Ćwiczenie 9.1. Zmienna #shared i dokumentacja wbudowanych funkcji .................. 209
Bloki konstrukcyjne w języku M .............................................................................................. 211
Ćwiczenie 9.2. Witaj, świecie! ............................................................................................ 211
Wyrażenie let ........................................................................................................................ 213
Zakresy i scalanie wyrażeń z wielu zapytań ..................................................................... 215
Typy danych, operatory i wbudowane funkcje ............................................................... 217
Podstawowe typy danych w języku M ..................................................................................... 218
Typ number .......................................................................................................................... 219
Typ time ................................................................................................................................ 220
Typ date ................................................................................................................................. 220
Typ duration ......................................................................................................................... 221
Typ text ................................................................................................................................. 222
Typ null ................................................................................................................................. 222
Typ logical ............................................................................................................................. 223
Typy złożone ............................................................................................................................... 224
Typ list ................................................................................................................................... 224
Typ record ............................................................................................................................ 227
Typ table ................................................................................................................................ 230
Warunki i wyrażenia „if” ........................................................................................................... 232
Wyrażenie „if-then-else” .................................................................................................... 233
Wyrażenie if wewnątrz wyrażenia let ............................................................................... 233
4650570396d9eb2765da56c12eb840b5
4
SPIS TREŚCI
Funkcje niestandardowe ............................................................................................................ 235

Wywoływanie funkcji ......................................................................................................... 236
Wyrażenie each .................................................................................................................... 237
Zaawansowane tematy ............................................................................................................... 237
Obsługa błędów .................................................................................................................... 238
Leniwe i zachłanne przetwarzanie wyrażeń ..................................................................... 239
Pętle ....................................................................................................................................... 239
Rekurencja ............................................................................................................................ 240
Funkcja List.Generate ......................................................................................................... 240
Funkcja List.Accumulate .................................................................................................... 241
Podsumowanie ............................................................................................................................ 242
Rozdział 10. Od złych do dobrych zapytań .........................................................................245

Źródła pułapek i ich skutki ....................................................................................................... 246
Świadome działanie ............................................................................................................. 247
Dobre praktyki ..................................................................................................................... 248
Modyfikacje formuł M ........................................................................................................ 248
Pułapka 1. Ignorowanie paska formuły ................................................................................... 249
Ćwiczenie 10.1. Wyszukiwanie w pasku formuły statycznych odwołań
do nazw kolumn ................................................................................................................ 249
Pułapka 2. Zmiana typów danych ............................................................................................ 251
Pułapka 3. Niebezpieczne filtrowanie ...................................................................................... 253
Ćwiczenie 10.2. Część I. Filtrowanie czarnych produktów ........................................... 254
Działanie warunków w filtrach .......................................................................................... 255
Ćwiczenie 10.2. Część II. Wyszukiwanie wartości w panelu filtru ............................... 257
Pułapka 4. Zmiana kolejności kolumn .................................................................................... 257
Ćwiczenie 10.3. Część I. Zmiana kolejności wybranych kolumn ................................. 258
Ćwiczenie 10.3. Część II. Niestandardowa funkcja FnZmianaKolejnościKolumn ... 260
Pułapka 5. Usuwanie i wybieranie kolumn ............................................................................ 260
Ćwiczenie 10.4. Usunięcie niepotrzebnych kolumn ...................................................... 261
Pułapka 6. Zmiana nazw kolumn ............................................................................................. 263
Ćwiczenie 10.5. Zmiana nazw losowych kolumn ........................................................... 263
Pułapka 7. Dzielenie kolumn .................................................................................................... 266
Ćwiczenie 10.6. Niewłaściwy podział kolumny .............................................................. 267
Pułapka 8. Scalanie kolumn ...................................................................................................... 269
Inne pułapki i techniki zapobiegawcze .................................................................................... 270
Podsumowanie ............................................................................................................................ 270
Rozdział 11. Podstawy analizy tekstu .................................................................................273

Wyszukiwanie słów kluczowych w kolumnach tekstowych ................................................ 274
Ćwiczenie 11.1. Proste wyszukiwanie słów kluczowych ...................................................... 274
Wyszukiwanie słów kluczowych z użyciem iloczynu kartezjańskiego ........................ 277
Ćwiczenie 11.2. Iloczyn kartezjański .............................................................................................279
Ćwiczenie 11.3. Wyszukiwanie słów kluczowych za pomocą niestandardowej funkcji ... 285
4650570396d9eb2765da56c12eb840b5
4
SPIS TREŚCI
Jakiej metody użyć: zwykłego wyszukiwania, iloczynu kartezjańskiego

czy niestandardowej funkcji? .......................................................................................... 288
Dzielenie wpisów na słowa ........................................................................................................ 288
Ćwiczenie 11.4. Trywialne dzielenie wpisów na słowa .................................................. 288
Ćwiczenie 11.5. Odrzucenie stop-słów ............................................................................. 293
Ćwiczenie 11.6. Wyszukiwanie słów kluczowych w wyodrębnionych słowach ......... 295
Ćwiczenie 11.7. Chmura słowna w Power BI Desktop .................................................. 302
Podsumowanie ............................................................................................................................ 304
Rozdział 12. Zaawansowana analiza tekstu: rozpoznawanie znaczenia .............................305

Usługa Microsoft Azure Cognitive Services ........................................................................... 306
Klucze API i zasoby Azure ................................................................................................. 307
Uwagi dotyczące korzystania z usługi Azure Cognitive Services
za pomocą edytora Power Query ................................................................................... 310
Tłumaczenie tekstu .................................................................................................................... 312
Opis interfejsu Translator Text API ................................................................................. 312
Ćwiczenie 12.1. Proste tłumaczenie .................................................................................. 313
Ćwiczenie 12.2. Tłumaczenie wielu komunikatów ........................................................ 317
Analiza nastroju tekstu .............................................................................................................. 321
Czym jest interfejs Sentiment Analytics API ................................................................... 322
Ćwiczenie 12.3. Implementacja niestandardowej funkcji FnOkreślenieNastroju ..... 324
Ćwiczenie 12.4. Przetwarzanie dużych ilości danych ..................................................... 333
Wyodrębnianie kluczowych fraz .............................................................................................. 335
Ćwiczenie 12.5. Przystosowanie kodu do wyodrębniania kluczowych fraz ............... 336
Obsługa wielu języków ............................................................................................................... 338
Zmiana oznaczenia języka .................................................................................................. 338
Dynamiczne wykrywanie języka ....................................................................................... 339
Ćwiczenie 12.6. Przystosowanie kodu do wykrywania języka ...................................... 339
Podsumowanie ............................................................................................................................ 340
Rozdział 13. Analiza sieci społecznościowych ....................................................................341

Pierwsze kroki z konektorem do Facebooka .......................................................................... 342
Ćwiczenie 13.1. Uzyskiwanie informacji o ulubionych stronach ................................. 342
Analiza sieci znajomych ............................................................................................................ 347
Ćwiczenie 13.2. Wyszukiwanie bezpośrednich i pośrednich znajomych
za pomocą Power BI ......................................................................................................... 347
Ćwiczenie 13.3. Wyszukiwanie stron, które polubili znajomi ...................................... 349
Analiza stron na Facebooku ...................................................................................................... 351
Ćwiczenie 13.4. Proste odczytywanie wpisów i komentarzy ze stron Facebooka ...... 352
Krótka dygresja: pobieranie danych za wybrany okres .................................................. 355
Ćwiczenie 13.5. Analiza aktywności użytkowników:
zliczanie komentarzy i udostępnień ............................................................................... 356
Ćwiczenie 13.6. Analiza porównawcza stron .................................................................. 358
Podsumowanie ............................................................................................................................ 361
4650570396d9eb2765da56c12eb840b5
4
SPIS TREŚCI
Rozdział 14. Końcowy projekt: wszystko razem .................................................................363

Ćwiczenie 14.1. Ratowanie sytuacji u Światowych Importerów ......................................... 363
Wskazówki ............................................................................................................................ 364
Część I. Przygotowanie danych ......................................................................................... 365
Część II. Dekompozycja tabel ............................................................................................ 367
Część III. Agregacja danych za 2018 r. ............................................................................. 368
Część IV. Scalenie przychodów za lata 2015 – 2017 i za rok 2018 ............................... 369
Ćwiczenie 14.2. Porównanie tabel i śledzenie hakera ........................................................... 369
Wskazówki ............................................................................................................................ 370
Rozwiązanie .......................................................................................................................... 370
Szukanie śladów hakera w zmienionej tabeli ................................................................... 371
Podsumowanie ............................................................................................................................ 372
4650570396d9eb2765da56c12eb840b5
4
O ilustracjach
Rozdział 1.: rysunki 1.1 – 1.9 zamieszczono dzięki uprzejmości firmy Microsoft.
Rozdział 11.: rysunki 11.1 – 11.14 oraz 11.16 – 11.17 zamieszczono dzięki uprzejmości firmy Microsoft.
Rozdział 12.: rysunki 12.3 – 12.8 oraz 12.10 – 12.14 zamieszczono dzięki uprzejmości firmy Microsoft.
4650570396d9eb2765da56c12eb840b5
4
Przedmowa
Decydując się na utworzenie dodatku Power Query do Excela, postawiliśmy sobie prosty, ale
ambitny cel: zrobić narzędzie do łączenia i przekształcania wszelkiego rodzaju danych. Po upływie
pięciu lat wyszliśmy daleko poza natywny dodatek do Excela, Power BI, Power Apps i wielu innych
programów do wyodrębniania i przekształcania danych, ale główny cel pozostał niemal niezmieniony.
Zważywszy na coraz większą różnorodność danych, nasza misja pod wieloma względami stała się
jeszcze bardziej ambitna i angażująca. Dzisiaj informatyka polega w dużej mierze na przetwarzaniu
danych, ale dane te nie zawsze są tam, gdzie byśmy chcieli, i często nie mają potrzebnej nam postaci.
Dlatego wciąż rozwijamy narzędzie Power Query, a naszym celem jest wypełnienie luki pomiędzy
danymi w surowej i żądanej postaci.
W naszej podróży z Power Query zawsze bardzo ważna była społeczność użytkowników, ich
sugestie i opinie. Nie tylko mieli oni wpływ na kształt produktu, ale również odgrywali główną rolę
w opracowywaniu wartościowych treści edukacyjnych. Autor tej książki był główną siłą napędową
w integracji Power Query z Excelem, służył wieloma cennymi opiniami oraz radami i nawet
po zakończeniu swojej kadencji w Microsoft wciąż jest aktywnym i wpływowym członkiem
społeczności użytkowników Power Query.
Udanego kwerendowania!
— Sid Jayadevan, kierownik inżynierii Power Query, Microsoft Corporation
Power Query jest potężnym i elastycznym programem stanowiącym rdzeń narzędzi Microsoft BI
(ang. Business Intelligence — analityka biznesowa). Wyposażony w intuicyjny i przemyślany interfejs
umożliwia pozyskiwanie, konsolidowanie i filtrowanie danych pochodzących z bardzo różnych źródeł.
W analityce biznesowej przygotowanie danych zajmuje nawet 80% czasu, dlatego pierwszym krokiem
do wszelkiego rodzaju projektów obejmujących przetwarzanie i raportowanie danych powinno być
dogłębne poznanie Power Query. W tej książce oprócz podstawowych funkcjonalności tego narzędzia
opisane są bardziej zaawansowane tematy, takie jak automatyczne przygotowywanie i oczyszczanie
danych, pozyskiwanie z serwisów społecznościowych opinii użytkowników o firmie, zastosowanie
uczenia maszynowego do analizy wydźwięku tekstu, pozyskiwanie za pomocą języka M wartościowych
informacji z praktycznie dowolnych źródeł surowych danych. Do książki dołączone są pliki zawierające
gotowe próbki i źródła danych wraz ze szczegółowymi instrukcjami.
4650570396d9eb2765da56c12eb840b5
4
PRZEDMOWA
Autor jest byłym członkiem zespołu rozwijającego program Excel i członkiem grupy Microsoft
Data Team. Ponieważ bezpośrednio angażował się w kształt funkcjonalności Power Query, zna
dogłębnie jego użytkowanie i potrafi pokazać, jak łatwo można rozwiązywać skomplikowane
problemy integracji danych. Choć Power Query jest niezwykle elastycznym i prostym w użyciu
dodatkiem, opanowanie go w stopniu umożliwiającym przetwarzanie danych biznesowych może
być trudnym zadaniem. Jednakże autor, jako aktywny członek społeczności użytkowników,
uczestnik forów dyskusyjnych, prezenter na konferencjach, mentor i certyfikowany ekspert Power
BI, potrafi po mistrzowsku dzielić skomplikowane problemy na bardzo proste kroki. Ta książka jest
kluczem do sukcesu i obowiązkową lekturą dla każdego analityka biznesowego, administratora
systemów danych i przedsiębiorcy, który chce czerpać korzyści z otaczających go danych.
— Charles Sterling, Starszy Kierownik Programu, Microsoft Corporation
12
4650570396d9eb2765da56c12eb840b5
4
O autorze
Gil Raviv jest certyfikowanym specjalistą Microsoft, prowadzi

blog o narzędziu Power BI na stronie https://DataChant.com.
W firmie Microsoft był starszym kierownikiem programu w zespole
rozwijającym Excela. Kierował tworzeniem i integracją dodatku
Power Query — technologii nowej generacji do pozyskiwania
i przetwarzania danych w Excelu 2016. Od tamtej pory jest
zapalonym użytkownikiem języka M.
Posiada dwudziestoletnie doświadczenie programistyczne i cztery
patenty w dziedzinie sieci społecznościowych, bezpieczeństwa
cyfrowego i analizy danych. Opracował wiele różnorodnych
programów, od zaawansowanych systemów wykrywania
zagrożeń w firmach do ochrony dzieci w serwisie Facebook.
Od czasu przeprowadzki do Chicago w 2016 r. na swoim blogu popularyzuje narzędzia Power BI
i Power Query. Obecnie jest menedżerem zespołu w firmie Avanade oferującej korporacjom z listy
Fortune 500 narzędzia analityczne i rozwiązania oparte na narzędziu Power BI i chmurze Azure.
Można się z nim kontaktować, pisząc na adres gilra@datachant.com.
4650570396d9eb2765da56c12eb840b5
4
PODZIĘKOWANIA
Podziękowania
Pisanie tej książki było jednym z najstraszniejszych doświadczeń, na które dobrowolnie się
zdecydowałem. Wiedziałem, że wyruszam w podróż do nieznanej krainy, w której przede mną byli
tylko nieliczni, krainy nieustannie rozwijającej się technologii, która choć jeszcze mało znana, może
radykalnie ułatwić życie wielu specjalistom. Jak mógłbym się z nimi bezboleśnie podzielić wiedzą,
aby mogli poznać istotę tej technologii i praktycznie wykorzystywać ją w biznesie?
Napisanie tej książki nie byłoby możliwe bez pomocy i inspiracji wielu osób.
Przede wszystkim chciałbym podziękować gościom mojej strony DataChant.com. Dzięki
waszym opiniom i wsparciu to przedsięwzięcie okazało się możliwe do zrealizowania. Daliście mi
moc dzielenia się wiedzą.
Dziękuję mojej żonie i dzieciom za pozostanie ze mną w domu i wsparcie w pracy pod koniec
roku 2017 i w chłodne dni roku 2018. Mam nadzieję, że winę za spędzenie wielu weekendów
w domu ponosi też zima w Chicago.
Proszę o przyjęcie specjalnych podziękowań Trinę MacDonald, starszą redaktor w wydawnictwie
Pearson, za kontakt, pomysł napisania książki i ciągłe wsparcie, dzięki któremu powstała zupełnie
inna książka. Życzę szczęścia na nowej drodze.
Na moją wdzięczność zasłużył również Justin DeVault, mój pierwszy klient z tytułem Six Sigma
Master Black Belt i korektor merytoryczny, który przejrzał 14 rozdziałów, 71 ćwiczeń i 211 plików,
a dzięki jego doświadczeniu biznesowemu i wiedzy technicznej książka jest tym, czym powinna być.
Nie poradziłbym sobie bez jego wiedzy. Jest to najwłaściwsza osoba do takich zadań.
Podziękowania otrzymuje też Loretta Yates oraz członkowie zespołu wydawnictwa Microsoft
Press i firmy Pearson biorący udział w tym projekcie. Wśród nich są Songlin Qiu, Ellie Bru i Kitty
Wilson, którzy zredagowali i sprawdzili tekst, oraz Tonya Simpson nadzorująca cały proces wydawniczy.
Wszyscy oni w magiczny sposób zamienili 14 plików Worda w książkę.
Podziękowania niech przyjmie mój drogi przyjaciel, Yohai Nir, za otuchę i wskazówki udzielane
na początku pracy nad książką.
Dziękuję Luisowi Cabrerze-Cordonowi za przejrzenie rozdziału 12. Mam nadzieję, że ułatwi on
analitykom korzystanie z usług Microsoft Cognitive Services i pozyskiwanie informacji bez pomocy
programistów i badaczy danych.
Podziękowania kieruję do niezwykłych menedżerów programu. Są to Guy Hunkin, Miguel
Llopis, Matt Masson i Chuck Sterling, którzy nieustannie mnie wspierali i udzielali technicznych
porad. Ich zaangażowanie było naprawdę inspirujące.
14
4650570396d9eb2765da56c12eb840b5
4
. PODZIĘKOWANIA
Sid Jayadevan, Eli Schwarz, Vladik Branevich i zespoły programistów w Redmond i Israeli to
niesamowici ludzie, z którymi praca nad dodatkiem Power Query do Excela 2016 była prawdziwą
przyjemnością.
Specjalne podziękowania kieruję do Yigal Edery za przyjęcie mnie w szeregi zespołu Microsoft
Excel i zagrzewanie do większego zaangażowania. Nigdy nie zapomnę tego wieczoru, kiedy
zatrzymał się na poboczu, aby podzielić się ze mną swoją opinią.
Tej książki nie byłoby, gdyby nie Rob Collie, który zaprosił mnie do grona blogerów
i konsultantów w serwisie PowerPivotPro.com i pomógł wejść do nowego, wspaniałego świata.
Marco Russo, Ken Puls, Chris Webb, Matt Allington i Reza Rad to specjaliści Microsoft MVP
i blogerzy Power BI, którzy są moimi wzorami do naśladowania. Dziękuję im za inspirację
i dzielenie się swoją ogromną wiedzą.
Ponieważ do zespołu Avanade Analytics dołączyłem na początku roku 2017, zdążyłem się już
wiele nauczyć. Na moją szczególną wdzięczność zasłużył mój mentor i szef Neelesh Raheja, który
otworzył przede mną szerokie horyzonty na oceanie analiz biznesowych.
Na koniec dziękuję moim rodzicom. Choć teraz dzieli mnie od nich odległość prawie 10 tysięcy
kilometrów, chcę podziękować Tacie za nauczenie mnie wiele lat temu żonglowania liczbami
i formułami w Excelu, a Mamie za artystyczny talent, który codziennie inspirował mnie w pracy
nad wyglądem Power BI.
— Gil Raviv
15
4650570396d9eb2765da56c12eb840b5
4
PODZIĘKOWANIA
16
4650570396d9eb2765da56c12eb840b5
4
Wprowadzenie
Czy wiesz, że Microsoft Excel zawiera narzędzie Power BI i inne dodatki, które pozwalają
dokonywać cudów z danymi, unikać powtarzalnej pracy i oszczędzać nawet 80% czasu?
 Zawsze, gdy kopiujesz i wklejasz do arkusza podobne dane, a potem ręcznie je oczyszczasz,
tracisz cenny czas; prawdopodobnie nawet nie wiesz, że to samo można zrobić inaczej,
lepiej i szybciej.
 Zawsze, zdając się na innych w doprowadzeniu danych do odpowiedniego kształtu i stanu,
pamiętaj, że są proste sposoby, z pomocą których dane możesz przetworzyć raz, a potem
cieszyć się automatyzacją procesu.
 Zawsze, gdy musisz podjąć racjonalną decyzję opartą na ogromnej ilości danych
wymagających oczyszczenia, wiedz, że możesz łatwo sprostać takim wyzwaniom, osiągnąć
niezwykłe rezultaty i skrócić czas ich analizy.
Jesteś gotowy na zmiany? Za chwilę zamienisz frustrujące, powtarzalne, ręczne oczyszczanie
danych w naprawdę ekscytującą zabawę, podczas której dodatkowo poprawisz jakość danych
i wydobędziesz z nich nowe informacje.
Excel, Power BI, Analysis Services i PowerApps wykorzystują narzędzie Power BI, która zmienia
zasady gry w łączeniu i przekształcaniu danych. Wykorzystując to narzędzie, każda osoba z podstawową
znajomością Excela może automatyzować importowanie, przetwarzanie i oczyszczanie danych.
Narzędzie jest wyposażone w prosty, uniwersalny interfejs graficzny dla szerokiego spektrum źródeł
i formatów danych, pozwalający rozwiązywać wszelkie problemy związane z przygotowaniem
danych i po mistrzowsku nimi żonglować.
W tej książce zmierzysz się z prawdziwymi wyzwaniami związanymi z przetwarzaniem danych
i dowiesz się, jak dzięki Power Query można im sprostać. Książka zawiera ponad 70 ćwiczeń i 200
plików, dzięki którym nauczysz się importować bezładne, rozdzielone tabele danych i automatycznie
przekształcać je w ustrukturyzowane zbiory gotowe do analizy. Większość opisanych tu technik
z łatwością zapamiętasz i wykorzystasz we własnym środowisku pracy.
4650570396d9eb2765da56c12eb840b5
4
WPROWADZENIE
Dla kogo jest ta książka?

Książka jest przeznaczona na użytkowników, którzy chcą poszerzyć swoją wiedzę o programach
Microsoft Excel i Power BI. Skorzystać mogą z niej również programiści SQL Server i Azure
Analysis Services, chcący sprawniej pisać kod ETL (ang. Extract, Transform, Load — wyodrębnij,
przekształć, załaduj). Twórcy aplikacji Microsoft PowerApps nauczą się opracowywać algorytmy
operujące na skomplikowanych zbiorach danych.
Jeżeli wykonujesz powtarzalne operacje w Excelu, przygotowując dane, albo tworzysz raporty
Power BI w swojej firmie, ta książka jest dla Ciebie. Dzięki niej analitycy biznesowi i programiści
ETL poznają nowe techniki umożliwiające bardziej efektywną pracę. Power Query stało się
podstawowym narzędziem do przetwarzania danych w Excelu, a Power BI gwałtownie się rozwija,
więc za sprawą tej książki znajdziesz własną drogę w swojej firmie i zaczniesz w niej więcej znaczyć.
Książka służy poszerzeniu wiedzy wszystkich użytkowników narzędzia Power Query.
Niezależnie od tego, czy jesteś początkującym, średnio zaawansowanym, czy profesjonalnym
użytkownikiem, znajdziesz tu przydatne techniki, które przeniosą Cię na wyższy stopień
wtajemniczenia.
Założenia
Podczas pracy z książką przydatna będzie znajomość Excela i Power BI. Wprawdzie z tej książki
skorzysta każdy użytkownik Excela, ale jeszcze więcej zyska ten, który spełnia jeden z poniższych
warunków (pamiętaj, że wystarczy tylko jeden).
 Często kopiuje i wkleja do Excela dane z tego samego źródła, a potem je oczyszcza.
 Tworzy i chce tworzyć coraz lepsze raporty w Excelu i Power BI połączone z zewnętrznymi
źródłami danych.
 Zna tabele przestawne w Excelu.
 Zna dodatek Power Pivot do Excela i chce upraszczać swoje modele danych.
 Zna dodatek Power Query i chce osiągnąć wyższy stopień wtajemniczenia.
 Tworzy aplikacje biznesowe PowerApps i chce wykorzystywać źródła
nieuporządkowanych danych.
 Korzysta z usług Analysis Services i chce efektywniej kodować w języku ETL.
Układ książki
Książka składa się z czternastu rozdziałów, stopniowo przechodzących od podstawowych, prostych
operacji przetwarzania danych do zaawansowanych, specyficznych scenariuszy. Każdy rozdział
zawiera wiele praktycznych ćwiczeń wraz z opisami, jak krok po kroku je wykonać. Z ich pomocą
poznasz techniki skutecznego przetwarzania danych. Książka jest podręcznikiem, który będzie Ci
towarzyszył przez długi czas, niezależnie od tego, ile nowych funkcjonalności pojawi się w Power
Query w przyszłości.
18
4650570396d9eb2765da56c12eb840b5
4
WPROWADZENIE
W rozdziale 1., „Wprowadzenie do Power Query”, poznasz podstawy tego narzędzia

i posiądziesz ogólną wiedzę niezbędną do wykonania ćwiczeń.
W rozdziale 2., „Podstawowe operacje przygotowywania danych”, nauczysz się wykonywać
proste, często spotykanie operacje na danych. Dowiesz się tutaj, jak oczyszczać dane i dlatego
rozdział ten będzie Ci wyjątkowo pomocny. Poznasz najprostsze techniki automatyzacji danych
wymagające kilku kliknięć myszą, bez konieczności tworzenia kodu. Jeżeli pierwszy raz masz do
czynienia z Power Query, po przeczytaniu tego rozdziału od razu będziesz mógł zacząć oszczędzać
swój czas.
Z rozdziału 3., „Łączenie danych z kilku źródeł”, dowiesz się, jak konsolidować osobne zbiory
danych i łączyć tabele w edytorze Power Query. Nauczysz się sprawnie integrować skoroszyty
zapisane w wybranym katalogu. Dzięki temu, gdy w katalogu pojawi się nowy skoroszyt, wystarczy,
że odświeżysz raport i od razu zostaną w nim uwzględnione nowe dane.
W rozdziale 4., „Łączenie niezgodnych tabel”, przejdziesz na wyższy stopień wtajemniczenia
i dowiesz się, jak łączyć niedopasowane tabele. W praktyce będziesz miał do czynienia
z poszatkowanymi, odizolowanymi danymi, o niespójnych strukturach i formatach. Korzystając
z umiejętności ujednolicania niezgodnych tabel, będziesz mógł w nowym świetle analizować
strategiczne scenariusze biznesowe.
W rozdziale 5., „Pozyskiwanie kontekstu”, nauczysz się wyodrębniać i zachowywać treści
zewnętrznych tabel, a także wzbogacać je w połączone tytuły i inne medatane, takie jak nazwy
plików i skoroszytów.
W rozdziale 6., „Dekomponowanie tabel”, nauczysz się ulepszać struktury tabel i wykorzystywać
reprezentowane przez nie obiekty danych. Przekonasz się, że polecenie Anuluj przestawienie kolumn
jest remedium na wszystkie źle zaprojektowane tabele. Przy jego użyciu będziesz mógł operować
na zagnieżdżonych tabelach. Dowiesz się, jak pomijać sumy pośrednie i całkowite zawarte
w źródle danych.
W rozdziale 7., „Zaawansowane metody dekomponowania i agregowania tabel”, będziesz
kontynuował swoją podróż po przekształceniach tabel i poznasz ogólne metody anulowania
przestawienia dowolnej tabeli podsumowującej dane, niezależnie od tego, na ilu poziomach
hierarchii zostały umieszczone jej wiersze i kolumny. Następnie dowiesz się, jak za pomocą tabeli
przestawnej przetwarzać wielowierszowe rekordy danych. Opisane w tym rozdziale techniki
będziesz mógł wykorzystywać do przekształcania na wiele różnych sposobów nadmiernie
ustrukturyzowanych zbiorów danych i doprowadzania ich do postaci umożliwiającej
wykonywanie zaawansowanych, cennych analiz.
Jeżeli tworzysz raporty, na pewno udostępniasz je innym członkom zespołu lub pracownikom
firmy. W rozdziale 8., „Praca grupowa”, poznasz najważniejsze problemy towarzyszące pracy
na współdzielonych danych oraz sposoby ich rozwiązywania za pomocą parametrów i szablonów.
W rozdziale 9., „Wprowadzenie do języka M”, zaczniesz opanowywać język M, który można
wykorzystywać do ulepszania zapytań i przekształcania danych na większą skalę. Poznasz podstawowe
elementy tego języka, takie jak składnia, operatory, typy danych i szerokie spektrum wbudowanych
funkcji. Jeżeli nie jesteś zaawansowanym użytkownikiem tego języka, możesz pominąć ten rozdział
i wrócić do niego później. Opanowanie języka M nie jest warunkiem niezbędnym do osiągnięcia
mistrzostwa w przetwarzaniu danych, ale umiejętność modyfikowania formuł może znacznie
zwiększyć Twoją skuteczność.
19
4650570396d9eb2765da56c12eb840b5
4
WPROWADZENIE
Umiejętność posługiwania się edytorem Power Query w Excelu i Power BI jest niezwykle cenna,
ponieważ można prozaiczne, ale ważne operacje przygotowywania danych zamienić w zautomatyzowany
proces. Jednak w miarę robienia postępów w przetwarzaniu danych możesz w edytorze Power Query
zacząć popełniać często spotykane błędy, skutkujące powstawaniem nieudanych zapytań, które nie
odświeżają danych lub dają niewłaściwe wyniki w przypadku zmiany danych. Dlatego w rozdziale
10., „Od złych do dobrych zapytań”, dowiesz się, jakie błędy są najczęściej popełniane, jak ich unikać
i tworzyć niezawodne zapytania prawidłowo odświeżające dane i dostarczające właściwych wyników.
W rozdziale 11., „Podstawy analizy tekstu”, wykorzystasz Power Query do pozyskiwania cennych
informacji ze źródeł danych tekstowych. Na pewno wiele tabel w Twoich raportach zawiera tekstowe
kolumny, które zazwyczaj pomija się w analizach. W tym rozdziale poznasz często stosowne
przekształcenia umożliwiające wyodrębnianie ważnych słów, wykrywanie słów kluczowych,
pomijanie powszechnie używanych słów (np. spójników) i wykorzystywanie iloczynu
kartezjańskiego do zaawansowanego przeszukiwania tekstu.
W rozdziale 12., „Zaawansowana analiza tekstu: rozpoznawanie znaczenia”, poczynisz postępy
w analizie tekstu, dowiesz się, jak za pomocą Microsoft Cognitive Services tłumaczyć tekst,
analizować jego wydźwięk i wyszukiwać kluczowe frazy. Za pomocą konektora Power Query Web
i kilku prostych funkcji języka M wykorzystasz sztuczną inteligencję do rozpoznawania treści tekstu
bez angażowania badaczy danych i programistów.
W rozdziale 13., „Analiza sieci społecznościowych”, nauczysz się pozyskiwać dane z portali
społecznościowych. Przekonasz się, jak łatwo można połączyć się z serwisem Facebook i uzyskiwać
z niego informacje o aktywności użytkowników, opinie społeczności o markach, firmach i produktach.
Dowiesz się też, jak pracować z danymi JSON bez określonej struktury i przetwarzać publicznie
dostępne dane za pomocą Power Query.
W rozdziale 14., „Końcowy projekt: wszystko razem”, zmierzysz się z ostatnim wyzwaniem w tej
książce. Wykorzystasz całą nabytą wiedzę do przetworzenia danych na szeroką skalę. Zastosujesz opisane
techniki do złączenia kilkunastu skoroszytów, przestawienia tabel, anulowania przestawienia i uchronienia
strony „Kupcy z szerokiego świata” przed zmasowanym cyberatakiem!
Pliki dołączone do książki

Pliki wykorzystane w opisanych ćwiczeniach są dostępne do pobrania pod adresem
https://ftp.helion.pl/przyklady/poquev.zip. Oto one.
 Skoroszyty Excela i pliki CSV pełniące rolę źródeł nieuporządkowanych i niewłaściwie
sformatowanych danych. Do wykonania ćwiczeń nie trzeba instalować żadnych
zewnętrznych baz danych.
 Skoroszyty z rozwiązaniami i raporty Power BI zawierające niezbędne zapytania
i rozwiązania ćwiczeń.
Poniższa tabela zawiera listę wszystkich plików niezbędnych do wykonania ćwiczeń opisanych
w tej książce.
20
4650570396d9eb2765da56c12eb840b5
4
WPROWADZENIE
Rozdział Pliki
1. „Wprowadzenie do Power Query” R01-01.xlsx
R01-01 - rozwiązanie.pbix
R01-01 - rozwiązanie.xlsx
2. „Podstawowe operacje R02-01.xlsx
przygotowywania danych” R02-01 - rozwiązanie.xlsx
R02-02.xlsx
R02-02 - rozwiązanie - część 1.pbix
R02-02 - rozwiązanie - część 1.xlsx
R02-04.xlsx
R02-05.xlsx
R02-06.xlsx
R02-07.xlsx
R02-08.xlsx
3. „Łączenie danych z kilku źródeł” R03-01 - akcesoria.xlsx
R03-01 - komponenty.xlsx
R03-01 - rowery.xlsx
R03-01 - ubrania.xlsx
21
4650570396d9eb2765da56c12eb840b5
4
WPROWADZENIE
Rozdział Pliki
3. „Łączenie danych z kilku źródeł” — ciąg dalszy R03-03 - rozwiązanie.pbix
R03-04 - lata w osobnych arkuszach.xlsx
R03-04 - rozwiązanie 1.pbix
R03-04 - rozwiązanie 1.xlsx
R03-04 - rozwiązanie 2.pbix
Produkty\R03-03 - 2015.xlsx
4. „Łączenie niezgodnych tabel” R04-01 - akcesoria.xlsx
R04-04 - tabela konwersji.xlsx
R04-04 - rozwiązanie - transpozycja.pbix
R04-04 - rozwiązanie - transpozycja.xlsx
R04-05 - rozwiązanie - anulowanie
przestawienia.pbix
R04-05 - rozwiązanie - anulowanie
przestawienia.xlsx
R04-06 - rozwiązanie - transpozycja
nagłówków.pbix
R04-06 - rozwiązanie - transpozycja
nagłówków.xlsx
R04-07 - rozwiązanie - język M.pbix
R04-07 - rozwiązanie - język M.xlsx
R04-02 - produkty\R04-02 - akcesoria.xlsx
R04-02 - produkty\R04-02 - komponenty.xlsx
R04-02 - produkty\R04-02 - rowery.xlsx
R04-02 - produkty\R04-02 - ubrania.xlsx
22
4650570396d9eb2765da56c12eb840b5
4
WPROWADZENIE
Rozdział Pliki
5. „Pozyskiwanie kontekstu” R05-01 - akcesoria.xlsx
R05-01 - rowery i akcesoria.xlsx
R05-04 - produkty.xlsx
R05-06 - szybki start.pbix
R05-06 - szybki start.xlsx
R05-03 - produkty\R05-03-01.xlsx
6. „Dekomponowanie tabel” R06-01.xlsx
R06-02.xlsx
R06-03 - złe rozwiązanie.pbix
R06-03.xlsx
R06-04.xlsx
R06-05.xlsx
R06-06.xlsx
23
4650570396d9eb2765da56c12eb840b5
4
WPROWADZENIE
Rozdział Pliki
7. „Zaawansowane metody dekomponowania R07-01.xlsx
i agregowania tabel” R07-01 - rozwiązanie.pbix
R07-02.pbix
R07-02.xlsx
R07-04.xlsx
8. „Praca grupowa” R08-01.xlsx
R08-01 - Alicja.pbix
R08-01 - Alicja.xlsx
R08-02 - rozwiązanie.pbit
R08-02 - rozwiązanie 2.pbit
R08-05.pbix
R08-05.xlsx
R08-05 - folder\R08-05 - 2015.xlsx
R08-05 - folder\R08-05 - 2016.xlsx
R08-05 - folder\R08-05 - 2017.xlsx
9. „Wprowadzenie do języka M” R09-01 - rozwiązanie.pbix
10. „Od złych do dobrych zapytań” R10-01.xlsx
R10-05.xlsx
R10-06.xlsx
R10-06-v2.xlsx
24
4650570396d9eb2765da56c12eb840b5
4
WPROWADZENIE
Rozdział Pliki
11. „Podstawy analizy tekstu” R11-01.xlsx
R11-02 - porównanie.xlsx
Stop-słowa.txt
Słowa kluczowe.txt
12. „Zaawansowana analiza tekstu: R12-02.xlsx
rozpoznawanie znaczenia” R12-01 - rozwiązanie.pbix
13. „Analiza sieci społecznościowych” R13-01 - rozwiązanie.pbit
14. „Końcowy projekt: wszystko razem” R14-01 - cel.xlsx
R14-02 - zhakowane dane.xlsx
Przychody\2015.xlsx
Przychody\2016.xlsx
Przychody\2017.xlsx
Przychody\2018.csv
25
4650570396d9eb2765da56c12eb840b5
4
WPROWADZENIE
Wymagania systemowe
Do wykonania ćwiczeń opisanych w tej książce będziesz potrzebował następującego
oprogramowania:
 system operacyjny Windows 10, Windows 8, Windows 7, Windows Server 2008 R2
lub Windows Server 2012,
 pakiet Office 365, program Excel 2016 lub nowszy, Power BI Desktop, Excel 2013 lub 2010
z dodatkiem Power Query.
26
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 1.
Wprowadzenie do Power Query
Rzecz jasna dzisiaj, w dobie ciągłych aktualizacji oprogramowania i technologii

always-on, klikanie przycisku Odśwież może wydawać się staroświeckie. Jeżeli jednak
danych wciąż przybywa, wtedy dobrze zaimplementowane odświeżanie może przynieść
znakomite rezultaty.
— Satya Nadella
W TYM ROZDZIALE:
 poznasz narzędzie Power Query i jego początki,
 poznasz podstawowe komponenty Power Query i edytora zapytań,
 nauczysz się posługiwać narzędziami i przygotujesz proste dane do analizy.
W tej książce poznasz funkcjonalności narzędzia Power Query do przetwarzania danych, z pomocą
których będziesz mógł skrócić czas przygotowania danych nawet o 80%. Rozdział rozpoczyna się
od formalnego wprowadzenia, ponieważ narzędzie Power Query na to zasługuje. Kiedy czytasz ten
tekst, prawdopodobnie pół miliona użytkowników na całym świecie z zaciśniętymi zębami wykonuje
ręczne, powtarzalne, ale niezwykle ważne operacje związane z przygotowaniem danych do analizy
w Excelu. Robią tak dzień w dzień, tydzień w tydzień, miesiąc w miesiąc.
Kiedy przeczytasz tę książkę, około pięćdziesięciu milionów osób zakończy żmudne ręczne
przygotowywanie danych, nie wiedząc nawet o tym, że w Excelu są ukryte narzędzia, które tylko
czekają, aby ich użyć i ułatwić sobie pracę. Część użytkowników nauczy się oczyszczać dane za
pomocą zaawansowanych narzędzi, takich jak Python lub R, inni zdadzą się na swoje działy IT,
czekając miesiącami na zrealizowanie wniosków. Większość z nich chce po prostu wykonać zadanie
bez spędzania setek czy nawet tysięcy godzin na przygotowywaniu danych do analizy. Jeżeli
znajdujesz się wśród tych pięćdziesięciu milionów użytkowników, czas najwyższy, abyś poznał
narzędzie Power Query i przekonał się, jak może zmienić Twoją pracę, gdyż analiza danych będzie
wyglądała tak, jak ją sobie wyobrażasz.
Niezależnie od tego, czy jesteś początkującym, czy zaawansowanym użytkownikiem
Power Query, ten rozdział pomoże Ci przygotować się do drogi. W trakcie podróży nauczysz się
po mistrzowsku przetwarzać dane i samodzielnie wyciągać na ich podstawie wnioski.
4650570396d9eb2765da56c12eb840b5
4
POWER QUERY W EXCELU I POWER BI
Czym jest Power Query?

Power Query to technologia zaimplementowana w programach Microsoft Excel, Power BI i innych,
która zmieniła zasady gry w pozyskiwanie i przekształcanie danych. Dzięki niej każdy, kto korzysta
z bogatych zewnętrznych źródeł danych, a nawet z lokalnych skoroszytów, może gromadzić, łączyć
i przetwarzać dane, korzystając z prostego interfejsu. Po właściwym przygotowaniu danych można je
załadować do raportu w Excelu, Power BI lub tabeli w innym programie do późniejszego wykorzystania.
Potem, za każdym razem gdy dane będą aktualizowane, wystarczy odświeżać raport i cieszyć się
automatycznym przetwarzaniem.
Zobacz też. Od chwili pojawienia się Power Query z tego narzędzia korzystają miliony
użytkowników. Ponieważ zaczęło ono odgrywać istotną rolę w pracy analityków
i administratorów danych, Microsoft postanowił zintegrować je ze swoimi innymi
produktami, m.in. z:
 Microsoft SQL Server Data Tools (SSDT) dla SQL Server 2017 Analysis Services oraz
Azure Analysis Services (patrz https://docs.microsoft.com/pl-pl/analysis-services/
what-s-new-in-analysis-services),
 Common Data Service for Apps, wykorzystywane w Microsoft PowerApps
(patrz https://docs.microsoft.com/en-us/powerapps/maker/common-data-service/
data-platform-cds-newentity-pq).
Podczas przygotowywania danych w edytorze Power Query, tj. głównym interfejsie tego
narzędzia, rejestrowane są wykonywane przez Ciebie operacje, zatem następnym razem będziesz
mógł je automatycznie odtworzyć. Jeżeli jesteś zaawansowanym użytkownikiem Excela, będzie to
operacja podobna do rejestrowania makra, ale znacznie prostsza. Po wykonaniu przekształceń dane
można załadować do raportu. Od tej chwili, za każdym razem gdy odświeżysz raport, zostanie wykonana
sekwencja operacji, dzięki czemu zaoszczędzisz wiele godzin, a nawet dni, które musiałbyś poświęcić
na powtarzalne, ręczne przygotowywanie danych.
Narzędzie Power Query jest naprawdę proste w użyciu. Zostało wyposażone w jednolity interfejs,
niezależnie od tego, z jakiego źródła importowane są dane i jaki mają format. Skomplikowane
scenariusze przygotowywania danych zapisywane są w postaci sekwencji prostych kroków, które
możesz edytować i śledzić. W bardziej złożonych przypadkach poszczególne kroki można
modyfikować za pomocą paska formuły lub zaawansowanego edytora (wykorzystując język M
opisany w rozdziale 9., „Wprowadzenie do języka M”). Każda sekwencja przekształceń jest
zapisywana w formie zapytania, które następnie możesz załadować do raportu lub wykorzystać
w innych kwerendach, tworząc w ten sposób kompletny proces przetwarzania danych.
Zanim zajmiemy się najważniejszymi komponentami narzędzia Power Query, cofnijmy się
kilka lat i poznajmy jego początki. Krótka historia pozwoli Ci dowiedzieć się, jak długo istnieje
ta technologia i jak wygląda dzisiaj.
28
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 1.  WPROWADZENIE DO POWER QUERY
Historia Power Query w skrócie

Narzędzie Power Query pojawiło się w 2011 r. jako część usługi Microsoft SQL Azure Labs.
W październiku 2011 r. zostało pokazane na konferencji PASS Summit pod roboczą nazwą
Data Explorer. Rysunek 1.1 przedstawia interfejs użytkownika w pierwszej wersji tego produktu.
RYSUNEK 1.1. Pod roboczą nazwą Data Explorer firma Microsoft udostępniła pierwszą wersję narzędzia
Power Query
W lutym 2013 r. Microsoft przekształcił narzędzie w dodatek do Excela i odłączył je od SQL

Azure Labs. Od tamtej chwili zaczęło nazywać się Data Explorer Preview for Excel i było oferowane
jako narzędzie do samodzielnego przeprowadzania analiz biznesowych w Excelu, ułatwiające
pozyskiwanie danych z bogatego spektrum źródeł i umożliwiające tworzenie obszernych raportów.
Już na samym początku Data Explorer jako dodatek do Excela oferował spójny, intuicyjny
interfejs umożliwiający pozyskiwanie, łączenie i filtrowanie danych pochodzących z różnych źródeł,
strukturalnych i niestrukturalnych, w tym relacyjnych baz danych, OData, Internetu, Hadoop,
Azure Marketplace i innych. Pozwalał również wyszukiwać dane w publicznie dostępnych źródłach,
np. Wikipedii (co zostało później usunięte).
Dodatek Data Explorer Preview for Excel po zainstalowaniu pojawiał się w karcie Data Explorer,
która wyglądała tak samo jak dzisiaj karta dodatku Power Query. Edytor nazywał się Nowe zapytanie,
ale nie miał karty Power Query. Jeśli chcesz zobaczyć ogłoszenie dodatku Data Explorer i jego interfejs
w Excelu, obejrzyj film dostępny pod adresem https://blogs.msdn.microsoft.com/dataexplorer/
2013/02/27/announcing-microsoft-data-explorer-preview-for-excel.
Rysunek 1.2 przedstawia dane statystyczne o rosnącym wykorzystaniu dodatku Data Explorer
i jego przejściu od SQL Azure Labs do Excela. Zgodnie z informacjami dostępnymi na profilu zespołu
rozwijającego ten dodatek (https://social.msdn.microsoft.com/Profile/Data%2bExplorer%2bTeam),
zespół ten rozpoczął swoją aktywność w społeczności użytkowników w październiku 2011 r.,
w momencie udostępnienia dodatku w usłudze SQL Azure Labs. W lutym 2013 r., kiedy Data
Explorer został udostępniony jako dodatek do Excela, społeczność użytkowników znacznie
zwiększyła swoją aktywność, co potwierdziło, że przeniesienie dodatku było dobrym ruchem.
Jak pokazuje linia trendu na rysunku 1.2, od lipca 2013 r. aktywność zespołu Data Explorer
zaczęła tracić swój impet. Nie był to jednak zły znak w historii dodatku, tylko moment udostępnienia
narzędzia pod nową nazwą. Microsoft ogłosił, że od tej pory będzie to dodatek Power Query
do Excela. Jego interfejs był niemal taki sam jak w ówczesnej wersji narzędzia Power Query.
29
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 1.2. Historia punktów zespołu rozwijającego dodatek Data Explorer dowodzi, że po przeniesieniu
dodatku z SQL Azure Labs do Excela zaczęło z niego korzystać coraz więcej użytkowników
Zespół rozwijający Power Query rozpoczął wydawanie comiesięcznych aktualizacji dodatku, co

skutkowało jego szybkim rozwojem i stałym wzrostem liczby użytkowników. Produkt kształtowała
rzesza fanów za pośrednictwem forów, blogów i bezpośrednio nadsyłanych opinii. Dodatek ten jest
wciąż aktualizowany, można go pobierać i instalować w programach Excel 2010 i Excel 2013.
Po zainstalowaniu pojawia się nowa karta o nazwie Power Query, umożliwiająca nawiązywanie
połączeń z nowymi źródłami danych.
W grudniu 2014 r. Microsoft udostępnił wstępną wersję narzędzia Power BI Designer
(https://powerbi.microsoft.com/en-us/blog/new-power-bi-features-available-for-preview). Było to
nowe narzędzie do tworzenia interaktywnych raportów i publikowania ich w usłudze Power BI,
znajdujące się wciąż we wstępnej fazie rozwoju. Power BI Designer połączył trzy dodatki: Power
Query, Power Pivot i Power View, co zadecydowało o sukcesie Power BI. Zawierał wszystkie
funkcjonalności dodatku Power Query. Choć interfejs użytkownika pozostał mniej więcej taki sam,
termin „Power Query” już nie pojawił się w Power BI Designer. Siedem miesięcy później, w lipcu
2015 r. Microsoft zmienił nazwę programu z Power BI Designer na Power BI Desktop i ogłosił jego
dostępność (https://powerbi.microsoft.com/en-us/blog/what-s-new-in-the-power-bi-desktop-ga-update).
Od tamtej chwili zespół rozwijający narzędzie Power Query udostępnia comiesięczne aktualizacje
dodatków Power Query dla Excela i Power BI Desktop, a jednocześnie współpracuje z zespołem
rozwijającym Excel nad implementacją całkowicie nowej opcji Pobierz dane.
Początkowo dodatek Power Query był całkowicie oddzielony od Excela, ale Microsoft
zadecydował, aby go zintegrować w postaci natywnego komponentu, a Power Query uczynić
podstawowym mechanizmem przetwarzania danych. We wrześniu 2016 r. pojawił się program
Excel 2016 ze zintegrowanym, pełnoprawnym narzędziem Power Query, a nie osobnym dodatkiem.
Wszystkie funkcjonalności zostały umieszczone w karcie Dane w grupie Pobieranie i przekształcanie,
która później została przemianowana na Pobieranie i przekształcanie danych.
W ten sposób technologia Power Query została udostępniona szerokiej rzeszy użytkowników wraz
z typowymi funkcjonalnościami Excela, takimi jak Cofnij i Powtórz, kopiowanie i wklejanie tabel, rejestrowanie
makr i kodowanie w języku VBA. Aby dowiedzieć się więcej o integracji Power Query z Excelem 2016, odwiedź
stronę https://blogs.office.com/en-us/2015/09/10/integrating-power-query-technology-in-excel-2016.
30
4650570396d9eb2765da56c12eb840b5
4
W marcu 2017 r. Microsoft udostępnił aktualizację pakietu Office 365 zawierającą kolejne
udoskonalenia narzędzia do przetwarzania danych. Technologia Power Query stała się
podstawową funkcjonalnością Excela służącą do tego celu (https://support.office.com/en-us/
article/unified-get-transform-experience-ad78befd-eb1c-4ea7-a55d-79d1d67cf9b3). Aktualizacja
ujednolicała interfejs zapytań i połączeń ze skoroszytami, jak również lepiej obsługiwała pliki ODC.
Ponadto zawierała rozwijane menu Pobierz dane, zlokalizowane w karcie Dane w grupie Pobieranie
i przekształcanie danych, będące głównym punktem wejścia do Power Query.
W kwietniu 2017 r. Microsoft udostępnił narzędzia SQL Server Data Tools (SSDT) i nowy interfejs
Pobierz dane w modelach danych Tabular 1400 usługi Analysis Services (https://blogs.msdn.microsoft.com/
ssdt/2017/04/19/announcing-the-general-availability-ga-release-of-ssdt-17-0-april-2017). W wersji SSDT 17.0
można było za pomocą Power Query importować i przygotowywać dane w tabelarycznych modelach
dla usług SQL Server 2017 Analysis Services i Azure Analysis Services. Jeżeli znasz usługi Analysis
Services, na stronie https://docs.microsoft.com/en-us/sql/analysis-services/tutorial-tabular-1400/
as-lesson-2-get-data?view=sql-analysis-services-2017 znajdziesz informacje, jak zacząć używać Power Query.
Uwaga. Książka skupia się głównie na programach Excel i Power BI Desktop, ale większość
rozdziałów i ćwiczeń, szczególnie dotyczących początkowych etapów projektów, gdy trzeba
porządkować dane, odnosi się również do usługi Analysis Services.
W marcu 2018 r. Microsoft udostępnił usługę Common Data Service (CDS) for Apps
(https://powerapps.microsoft.com/en-us/blog/cds-for-apps-march), w której głównymi narzędziami
do importowania danych były Power Query oraz Microsoft Flow (patrz rysunek 1.3). Narzędzie
Power Query zostało rozbudowane o funkcjonalności wykraczające poza analizę biznesową i od
teraz można go używać w charakterze prostego narzędzia ETL do tworzenia aplikacji dla pakietu
Microsoft Office 365 i Dynamics 365. Nie są przy tym wymagane umiejętności programistyczne.
RYSUNEK 1.3. Narzędzie Power Query w usłudze CDS for Apps udostępnionej w marcu 2018 r.
31
4650570396d9eb2765da56c12eb840b5
4
Również w marcu 2018 r. Microsoft przywrócił termin „Power Query” w programach Power BI
Desktop i Excel, zmieniając tytuł okna edytora z Edytor zapytań na Edytor Power Query. Aby uruchomić
edytor, należy w rozwijanym menu Pobierz dane wybrać opcję Uruchom edytora dodatku Power Query.
W lipcu 2018 r. Microsoft ogłosił, że internetowa wersja Power Query będzie częścią nowego
rozwiązania ETL o nazwie dataflows, przy użyciu którego będzie można samodzielnie i łatwo
przygotowywać dane, zapisywać wyniki w chmurze i wykorzystywać je w Power BI i innych
aplikacjach (https://www.microsoft.com/en-us/businessapplicationssummit/video/BAS2018-2117).
Gdzie znajduje się Power Query?

Znalezienie narzędzia Power Query w Excelu lub Power BI Desktop może nie być łatwe, jeżeli
nie wiadomo, gdzie go szukać. Gdy pisałem tę książkę, nie było jednego punktu wejścia o nazwie
„Power Query” do edytora. Rysunek 1.4 przedstawia kilka głównych opcji uruchamiania
Power Query w Excelu i Power BI Desktop.
RYSUNEK 1.4. Narzędzie Power Query można w Excelu i Power BI uruchamiać na kilka sposobów
Aby importować i przekształcać dane w Excelu 2010 lub 2013, pobierz dodatek Power Query
ze strony https://www.microsoft.com/pl-pl/download/details.aspx?id=39379. Dodatek jest dostępny
w programie Excel Standalone oraz pakietach Office 2010 i 2013. Po zainstalowaniu pojawi się karta
Power Query. Aby zaimportować dane, wybierz jedno z połączeń dostępnych w grupie Pobierz dane
zewnętrzne. Aby edytować istniejące zapytanie, wybierz Pokaż okienko, a następnie odpowiednie
zapytanie. Ewentualnie możesz wybrać polecenie Uruchom edytor, a następnie odpowiednie
zapytanie w panelu Zapytania.
Uwaga. W Excelu 2010 lub 2013 po kliknięciu ikony w grupie Pobieranie danych zewnętrznych
w karcie Dane pojawi się stary interfejs, a nie Power Query.
Zanim zaczniesz importować i przekształcać dane w Excelu 2016 przy użyciu technologii Power
Query, sprawdź zawartość karty Dane. Jeżeli znajduje się w niej grupa Pobieranie i przekształcanie,
kliknij ikonę Nowe zapytanie, a następnie wybierz żądane źródło danych. Jeżeli używasz nowszej
wersji Excela, w karcie Dane znajdziesz grupę Pobieranie i przekształcanie danych, w której jest ikona
32
4650570396d9eb2765da56c12eb840b5
4
Pobierz dane umożliwiająca importowanie danych. Aby edytować istniejące zapytania, kliknij
polecenie Pokaż zapytania (w wersji Excel 2016 lub starszej) albo w karcie Dane w grupie
Zapytania i połączenia polecenie Zapytania i połączenia.
Uwaga. Jeżeli używasz Excela 2016 i w karcie Dane znajduje się zarówno grupa Pobieranie
danych zewnętrznych, jak i Pobieranie i przekształcanie, pamiętaj, że pierwsza zawiera stare
opcje do importu danych. Aby korzystać z technologii Power Query, kliknij rozwijane menu
Nowe zapytanie w grupie Pobieranie i przekształcanie. W najnowszych wersjach Excela 2016,
2019 i Office 365 powyższe funkcjonalności znajdują się w rozwijanym menu Pobierz dane.
W programie Power BI Desktop kliknij w karcie Strona główna ikonę Pobierz dane. W oknie,
które się pojawi, będziesz mógł wybrać źródło danych. W rozwijanym menu Pobierz dane znajdują
się najczęściej stosowane źródła, takie jak Excel, Power BI Service, SQL Server czy Analysis Services.
Aby edytować istniejące zapytanie w raporcie, kliknij w karcie Strona główna ikonę Edytuj zapytania.
W ten sposób uruchomisz edytor zapytań Power Query. Następnie w panelu Zapytania po lewej
stronie wybierz żądane zapytanie.
Teraz znasz już główne punkty wejścia do Power Query. W następnym podrozdziale poznasz
podstawowe komponenty tego narzędzia.
Główne komponenty Power Query

Ten podrozdział stanowi wprowadzenie do głównych komponentów Power Query i najważniejszych
interfejsów użytkownika służących do pobierania danych, tworzenia połączeń, edytowania zapytań
i ustawiania ich opcji.
Pobieranie danych i tworzenie połączeń

Nawiązanie połączenia ze źródłem danych jest pierwszym krokiem w procesie tworzenia raportów.
Power Query pozwala łączyć się z szerokim spektrum różnych źródeł danych, które często nazywane
są połączeniami. Gdy np. klikniesz polecenie Pobierz dane, następnie Z bazy danych i Z bazy SQL Server,
utworzysz połączenie z bazą SQL Server. Lista obsługiwanych połączeń jest co miesiąc rozszerzana
za pomocą aktualizacji Power BI Desktop, Office 365 i dodatku Power Query do Excela 2010 i 2013.
Aby przejrzeć obsługiwane połączenia, kliknij kartę Dane, a następnie ikonę Pobierz dane. Pojawią się
opcje Z pliku, Z bazy danych, Z platformy Azure, Z usług online, Z innych źródeł, tak jak na rysunku 1.5.
Wiele połączeń udostępnianych jest najpierw w programie Power BI Desktop, a dopiero później
w Excelu. Zależy to od dojrzałości połączenia, jego popularności i porozumień biznesowych pomiędzy
firmą Microsoft a dostawcą danych. W programach Excel Standalone, Office Pro Plus i Office
Professional dostępne są następujące połączenia:
 bazy danych: Oracle, DB2, MySQL, PostgreSQL, Sybase, Teradata i SAP HANA,
 chmura Azure: Azure SQL Server, Azure SQL Data Warehouse, Azure HDInsight
(HDFS), Azure Blob Storage, Azure Table i Azure Data Lake Store,
 inne źródła: SharePoint, Active Directory, Hadoop, Exchange, Dynamics CRM i Salesforce,
 katalog danych: Data Catalog Search i My Data Catalog Queries.
33
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 1.5. Dane można importować z wielu różnych źródeł
Więcej szczegółowych informacji na temat dostępności źródeł danych w różnych

programach znajdziesz na stronie https://support.office.com/pl-pl/article/
where-is-get-transform-power-query-e9332067-8e49-46fc-97ff-f2e1bfa0cb16.
W programie Power BI Desktop kliknij ikonę Pobierz dane, a następnie opcję Więcej.
Pojawi się okno o tej samej nazwie, w którym będziesz mógł wybrać z listy żądane połączenie
lub przeglądać je wg kategorii Wszystkie, Plik, Baza danych, Azure, Usługi online i Inne.
Pełna lista połączeń dostępnych w programie Power BI Desktop znajduje się na stronie
https://docs.microsoft.com/pl-pl/power-bi/desktop-data-sources.
Jeżeli chcesz użyć istniejącego źródła danych, nie musisz korzystać z ikony Pobierz dane.
Zamiast tego kliknij w Excelu w karcie Dane w grupie Pobieranie i przekształcanie danych ikonę
Ostatnie źródła. W programie Power BI Desktop kliknij kartę Strona główna, następnie ikonę
Ostatnio używane źródła i polecenie Więcej. Pojawi się okno, w którym znajdziesz ostatnio
używane źródła danych. Możesz nawet przypiąć swoje ulubione źródło, a wtedy będzie zawsze
widoczne w górnej części okna.
Wiele źródeł, z których będziesz korzystał, np. bazy danych lub pliki SharePoint, zawiera
wbudowane mechanizmy uwierzytelniania użytkownika. Wprowadzane poświadczenia nie są
zapisywane w raporcie, tylko w systemie. Aby zmienić poświadczenia lub metodę uwierzytelniania,
kliknij w edytorze Power Query kartę Strona główna, a następnie ikonę Ustawienia źródła danych,
lub w karcie Plik opcję Opcje i ustawienia, a następnie Ustawienia źródła danych. W oknie ustawień
wybierz żądane źródło i kliknij przycisk resetujący poświadczenia. Aby dowiedzieć się więcej
na temat ustawień źródeł danych odwiedź stronę https://support.office.com/pl-pl/article/
data-source-settings-power-query-9f24a631-f7eb-4729-88dd-6a4921380ca9.
Najważniejsze elementy edytora Power Query

Po nawiązaniu połączenia ze źródłem danych pojawia się okno nawigatora, w którym można wybrać
tabele do załadowania i podejrzeć dane (wycieczkę po nawigatorze odbędziesz w ćwiczeniu 1.1).
Z nawigatora, po kliknięciu przycisku Przekształć dane, można od razu przejść do sedna sprawy,
czyli edytora Power Query. W tym miejscu można przeglądać dane w głównym panelu, badać je
i przekształcać. Jak pokazuje rysunek 1.6, okno edytora składa się z następujących części: panelu
podglądu, wstążki, panelu zapytania, panelu ustawień zapytania, panelu zastosowanych kroków
i paska formuły. Opiszę krótko każdą część.
34
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 1.6. Okno edytora Power Query składa się z kilku części
Panel podglądu
Panel podglądu, znajdujący się w centralnej części rysunku 1.6, umożliwia przeglądanie danych,
ich badanie i przekształcanie przed umieszczeniem w raporcie. Dane są zazwyczaj prezentowane
w formie tabelarycznej. Nagłówki wykorzystuje się do wykonywania różnych przekształceń, takich
jak zmiany nazw lub usuwanie kolumn. Za pomocą rozwijanego menu można dodatkowo
filtrować dane.
Panel podglądu jest kontekstowy. Oznacza to, że w zależności od tego, jaki element tabeli kliknie
się prawym przyciskiem myszy, pojawi się podręczne menu zawierające przekształcenia właściwe
dla tego elementu. I tak po kliknięciu lewego górnego rogu tabeli dostępne będzie np. przekształcenie
Użyj pierwszego wiersza jako nagłówków.
Wskazówka. Z kontekstowego menu w panelu podglądu możesz dowiadywać się o nowych

przekształceniach i korzystać z funkcjonalności narzędzia Power Query.
Pamiętaj, że panel podglądu nie zawsze zawiera pełny zestaw danych. Pokazuje jedynie ich część,
abyś mógł pracować na dużych zbiorach. Długie i szerokie tabele danych możesz przeglądać za pomocą
pasków przewijania lub otworzyć panel filtru i przeglądać unikatowe wartości w poszczególnych
kolumnach.
Inną często wykonywaną operacją, obok przeglądania danych, jest wybieranie kolumn. Możesz
wybrać jedną lub kilka kolumn, a następnie zastosować przekształcenie. Gdy klikniesz nagłówek
prawym przyciskiem myszy, pojawi się kontekstowe menu z przekształceniami właściwymi dla
kolumny. Zwróć uwagę, że dane w kolumnach mają określony typ, od którego zależą przekształcenia
dostępne w podręcznym menu i we wstążce.
35
4650570396d9eb2765da56c12eb840b5
4
Wstążka
Wygląd interfejsu edytora Power Query jest spójny z interfejsem całego pakietu Microsoft Office.
Jak pokazuje rysunek 1.7, składa się on ze wstążki złożonej z kart. Każda karta zawiera przekształcenia
i inne operacje, które można wykorzystywać w zapytaniach. Oto opis poszczególnych kart.
RYSUNEK 1.7. Wstążka edytora Power Query składa się z wielu przydatnych kart
 Plik: w tej karcie można zapisać raport, zamknąć edytor, otworzyć okno Opcje zapytania
oraz Ustawienia źródła danych.
 Strona główna: ta karta zawiera większość przekształceń, m.in. Wybieranie kolumn,
Usuń kolumny, Zachowaj wiersze, Usuń wiersze. Można tutaj również odświeżyć dane
prezentowane w panelu podglądu i zamknąć edytor. Polecenie Nowe źródło służy
do tworzenia zapytań importujących nowe dane.
Uwaga. W edytorze Power Query można pracować z wieloma zapytaniami jednocześnie. Każde
z nich można załadować jako osobną tabelę lub wykorzystać w innym zapytaniu. Łączenie zapytań
jest niezwykle przydatną funkcjonalnością, opisaną w rozdziale 3., „Łączenie danych z kilku źródeł”.
 Przekształć: w tej karcie można przekształcać wybrane kolumny. W zależności od typu

danych niektóre polecenia mogą być dostępne, inne nie. Przykładowo po wybraniu
kolumny typu Data dostępne będą polecenia właściwe dla dat. W tej karcie znajdują się
również inne przydatne polecenia, takie jak Grupowanie według, Użyj pierwszego wiersza
jako nagłówków, Użyj nagłówków jako pierwszego rzędu oraz Transponuj.
 Dodaj kolumnę: za pomocą tej karty można tworzyć nowe kolumny poprzez przekształcanie
istniejących kolumn. Polecenia Kolumna z przykładów i Kolumna warunkowa umożliwiają
wykonywanie skomplikowanych przekształceń przy użyciu bardzo prostego interfejsu.
Polecenia te są szczegółowo opisane i zaprezentowane na przykładach dalej w tej książce.
Zaawansowani użytkownicy znajdą tu polecenia Kolumna niestandardowa i Wywołaj
funkcję niestandardową, również opisane w następnych rozdziałach.
 Widok: w tej karcie można zmienić wygląd edytora Power Query, np. wyświetlić pasek
formuły, przejść do wybranej kolumny (bardzo przydatna funkcjonalność w przypadku
tabel składających się z dziesiątek kolumn) i wyświetlić zależności między zapytaniami.
36
4650570396d9eb2765da56c12eb840b5
4
W tej książce poznasz na praktycznych, z życia wziętych przykładach najczęściej stosowane i

najbardziej przydatne polecenia edytora.
Panel zapytań
W panelu zapytań, znajdującym się po lewej stronie okna edytora (patrz rysunek 1.6), można wybrać
zapytanie do edycji lub utworzyć nowe zapytanie poprzez zduplikowanie istniejącego zapytania lub
odwołanie się do niego. Po kliknięciu panelu prawym przyciskiem myszy pojawią się polecenia
właściwe dla zapytań.
Zapytania można łączyć w grupy. Grupowane nie wpływa na przetwarzane dane ani zawartość
raportu. Grupy pełnią rolę folderów w tym panelu. Kolejność zapytań można zmieniać, przeciągając
je za pomocą myszy.
Uwaga. Czasami po otwarciu edytora za pomocą menu Excela panel zapytań jest zwinięty.
Można go w każdej chwili rozwinąć. Po zamknięciu edytora zapytaniami można zarządzać
w Excelu za pomocą polecenia menu Zapytania i połączenia.
Ustawienia zapytań i zastosowane kroki

W panelu ustawień zapytań w prawej części okna edytora można zmieniać nazwy zapytań i otwierać
okno Właściwości zapytania umożliwiające dodawanie opisów. W części Zastosowane kroki można
przeglądać przekształcenia zawarte w zapytaniu.
Edytor pozwala odtwarzać sekwencje kroków przekształcających dane przed zaimportowaniem
ich do raportu. Wykonywane operacje są dopisywane do listy widocznej w panelu Zastosowane kroki.
Można je zmieniać, jak również dodawać nowe w środku lub na końcu listy.
Pasek formuły, zaawansowany edytor i język M

Domyślnie pasek formuły w edytorze Power Query jest wyłączony. Można go włączyć, zaznaczając
w karcie Widok opcję Pasek formuły. W większości przypadków nie trzeba korzystać z paska,
ale podczas pracy z tą książką przekonasz się, że zdarzają się sytuacje, w których jest przydatny.
W pasku formuły wpisuje się wyrażenia w języku M. Każdy wykonywany w edytorze krok,
począwszy od zaimportowania danych, jest rejestrowany w pasku w postaci formuły. Formuły są
kodowane w specjalnym, opracowanym przez Microsoft języku M rozszerzającym możliwości
przekształcania danych.
W kartach Strona główna i Widok znajduje się ikona otwierająca zaawansowany edytor, w którym
widoczne są wszystkie formuły utworzone w wyniku wykonania kroków w edytorze Power Query.
Zaawansowani użytkownicy mogą tu dostosowywać formuły i wykonywać skomplikowane przekształcenia.
W większości ćwiczeń opisanych w tej książce nie będziesz musiał korzystać z zaawansowanego edytora.
Jeżeli jednak ciekawi Cię język M, otwórz zaawansowany edytor i przyjrzyj się składni utworzonych
formuł. W ćwiczeniach będziesz korzystał z tego języka wtedy, gdy konieczne będzie dostosowanie
kodu lub skomplikowane przekształcenie danych. W rozdziale 9., „Wprowadzenie do języka M”,
głębiej poznasz język M, podstawy jego składni i wbudowane funkcje.
Uwaga. Jeżeli programowanie nie jest Twoją mocną stroną, nie przejmuj się. W większości
ćwiczeń nie będziesz musiał używać języka M.
37
4650570396d9eb2765da56c12eb840b5
4
Opcje zapytania w Excelu i Power BI Desktop

W oknie Opcje zapytania w Excelu i Power BI Desktop można ustawiać różne parametry narzędzia
Power Query. W Excelu opcje podzielone są na sekcje Globalne i Bieżący skoroszyt, natomiast
w programie Power BI Desktop na Globalne i Bieżący plik. Niektóre opcje są dostępne tylko w Excelu,
inne tylko w Power BI Desktop (np. dotyczące samego programu, tj. niezwiązane z Power Query).
Ustawienia w sekcji Ogólne są zapisywane w systemie i dotyczą wszystkich tworzonych raportów,
natomiast opcje w sekcjach Bieżący skoroszyt i Bieżący plik są zapisywane w pliku i nie dotyczą innych
plików. Jak pokazuje rysunek 1.8, każda sekcja dzieli się na kilka podsekcji. Podsekcje Ładowanie
danych i Prywatność znajdują się w obu sekcjach, czyli w Globalne i Bieżący skoroszyt/plik.
RYSUNEK 1.8. Okno Opcje zapytania w Excelu zawiera ogólne ustawienia zapisywane w systemie
oraz bieżące zapisywane w raporcie
Aby otworzyć okno Opcje zapytania w Excelu, kliknij kartę Dane, następnie ikonę Pobierz dane
i Opcje dodatku Query. Okno to możesz również otworzyć w edytorze, klikając kartę Plik, następnie
Opcje i ustawienia i Opcje zapytania. W programie Power BI Desktop kliknij kartę Plik, następnie
Opcje i ustawienia i Opcje.
Opcje będziesz zmieniał dość rzadko, ponieważ większość domyślnych ustawień będzie
odpowiednia do Twoich potrzeb. Jeżeli jesteś zaawansowanym użytkownikiem Excela i pracujesz
z modelami danych, możesz w sekcji Ładowanie danych wybrać opcję Określ niestandardowe
domyślne ustawienia ładowania, a następnie Załaduj do modelu danych.
38
4650570396d9eb2765da56c12eb840b5
4
Ćwiczenie 1.1. Pierwsze kroki z Power Query

Teraz, gdy znasz już najważniejsze komponenty edytora Power Query, czas wykonać proste
ćwiczenie, z wykorzystaniem którego zaznajomisz się z różnymi funkcjonalnościami.
Ćwiczenie możesz wykonać przy użyciu Excela lub Power BI Desktop.
Najpierw ze strony https://ftp.helion.pl/przyklady/poquev.zip pobierz archiwum plików i
rozpakuj je do folderu C:\Dane. Przyjęta jest jednolita konwencja nazw plików Rxx-yy.xlsx i Rxx-
yy.pbix, gdzie R oznacza rozdział, xx numer rozdziału, a yy numer ćwiczenia.
Uwaga. Podczas wykonywania ćwiczeń będzie pojawiało się pytanie o zapisanie plików
w podfolderze folderu C:\Dane. Pliki są zapisane w podfolderach o nazwach od R01 dla
rozdziału 1. do R14 dla rozdziału 14. Większość ćwiczeń zawiera rozwiązania, w których
przyjęte jest założenie, że dane źródłowe znajdują się w folderze C:\Dane\Rxx, gdzie xx
oznacza numer rozdziału.
Po rozpakowaniu archiwum otwórz skoroszyt R01-01.xlsx i przejrzyj zawartą w nim tabelę

danych. Jest to katalog produktów zawierający ich identyfikatory, nazwy, kody, koszty i ceny.
W następnym rozdziale z kodu produktu będziesz wyodrębniał informacje o jego kolorze, wielkości
i kategorii. W tym ćwiczeniu dane te wykorzystasz jedynie do zapoznania się z interfejsem edytora
Power Query.
1. Utwórz pusty skoroszyt w Excelu lub raport w Power BI Desktop.
2. W wersji Excel 2016 lub nowszej kliknij kartę Dane, a następnie w grupie Pobieranie
i przekształcanie danych kliknij ikonę Pobierz dane. Przejrzyj opcje menu. Jak pokazuje
rysunek 1.5, możesz wybierać wśród wielu źródeł danych. W tym ćwiczeniu kliknij opcję
Z pliku, a następnie Ze skoroszytu.
W wersji Excel 2010 lub 2013 z zainstalowanym dodatkiem Power Query kliknij kartę
Power Query, następnie ikonę Z pliku i opcję Ze skoroszytu.
W programie Power BI Desktop kliknij kartę Strona główna, następnie rozwiń ikonę
Pobierz dane i wybierz opcję Excel. Ewentualnie kliknij ikonę Pobierz dane i w oknie, które
się pojawi, przejrzyj dostępne źródła danych (zwanych połączeniami). W polu wyszukiwania
możesz wpisywać nazwy źródeł danych. Gdy skończysz, kliknij źródło Program Excel.
3. W oknie Importowanie danych przejdź do folderu C:\Dane\R01 i wybierz plik R01-01.xlsx.
Naciśnij klawisz Enter lub kliknij przycisk Importuj, aby zamknąć okno.
4. W oknie Nawigator, które się pojawi (patrz rysunek 1.9), wybierz tabelę do zaimportowania.
Okno to pojawia się zawsze po połączeniu się ze źródłem danych zawierającym wiele tabel.
Gdy połączysz się z relacyjną bazą danych, np. SQL Server lub Access, opcji będzie więcej,
jednak w większości przypadków okno wygląda tak samo.
39
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 1.9. W oknie Nawigator można wybierać tabele do załadowania
Jak pokazuje rysunek 1.9, domyślnym przyciskiem jest Załaduj, a nie Przekształć dane. Wielu
użytkowników, korzystając z domyślnych ustawień, nie dowiaduje się o funkcjonalnościach
edytora Power Query. Klikając przycisk Załaduj, pomijają etap przygotowania danych i ładują
tabelę do raportu w takiej postaci, w jakiej się ona znajduje.
Uwaga. Jeżeli w oknie nawigatora obok przycisku Załaduj nie ma przycisku o nazwie Przekształć
dane (patrz rysunek 1.9), oznacza to, że nazwa jest inna, np. Edytuj. Microsoft zmienia nazwy
przycisków, aby jak najlepiej odpowiadały oczekiwaniom użytkowników. W tej książce używana
jest nazwa Przekształć dane. Jeżeli jej nie znajdziesz, kliknij przycisk znajdujący się po prawej
stronie przycisku Załaduj.
Wskazówka. Jeśli nawet dane mają uporządkowaną strukturę, warto w oknie nawigatora
kliknąć przycisk Przekształć dane, a nie Załaduj. Otworzy się wtedy edytor Power Query,
w którym można przejrzeć dane i upewnić się, że mają żądany format.
5. Zaznacz Arkusz1, a następnie kliknij Przekształć dane. Otworzy się edytor Power Query.
Teraz jest dobry moment, abyś wrócił do rysunku 1.6 i sprawdził, gdzie w edytorze znajdują
się poszczególne komponenty. Zwróć uwagę, że edytor w Excelu i Power BI Desktop wygląda
niemal tak samo. Pomiędzy obydwoma produktami jest tylko kilka niewielkich różnic.
Jeżeli nie jest widoczny pasek formuły, możesz go wyświetlić, zaznaczając w karcie Widok
opcję Pasek formuły. Od tej chwili pasek będzie zawsze widoczny.
40
4650570396d9eb2765da56c12eb840b5
4
6. W panelu Zapytania lub Ustawienia zapytania zmień nazwę z Arkusz1 na Produkty. W tym
celu w panelu Zapytania kliknij dwukrotnie nazwę i wpisz nową. Natomiast w panelu
Ustawienia zapytania w sekcji Właściwości wpisz nową nazwę w polu Nazwa.
7. W panelu podglądu widoczne są dwie kolumny o nazwach Koszt i Cena. Załóżmy, że chcesz
dodać nową kolumnę zawierającą zysk, czyli różnicę pomiędzy ceną a kosztem. Aby utworzyć
nową kolumnę zawierającą wyniki operacji wykonanych na dwóch innych kolumnach,
musisz najpierw te kolumny zaznaczyć. Aby zaznaczyć jedną kolumnę, kliknij jej nagłówek,
ewentualnie użyj klawiszy kursora. Aby zaznaczyć kilka kolumn, naciśnij dodatkowo klawisz
Shift (zaznaczysz przylegające kolumny) lub Ctrl (zaznaczysz oddzielne kolumny).
Zaznacz kolumnę Cena, a następnie trzymając klawisz Shift lub Ctrl, zaznacz kolumnę Koszt.
8. Aby utworzyć nową kolumnę, przejrzyj przekształcenia dostępne w karcie Dodaj kolumnę.
Kliknij ikonę Standardowy. Pojawi się menu operacji arytmetycznych, jakie można wykonać
na zaznaczonych kolumnach. Aby od ceny odjąć koszt, wybierz z menu opcję Odejmij.
9. W panelu podglądu pojawi się nowa kolumna o nazwie Odejmowanie. Zmień ją na Zysk.
W tym celu kliknij dwukrotnie nagłówek kolumny i wpisz nową nazwę. Ewentualnie kliknij
nagłówek prawym przyciskiem myszy. Pojawi się długie podręczne menu zawierające różne
przekształcenia, które można wykonać na wybranej kolumnie. Wśród nich znajduje się
przekształcenie Zmień nazwę.
10. Przyjrzyj się wartościom w kolumnie Zysk. Czy widzisz liczby ujemne? Nie powinno ich być.
Pojawiły się w wyniku operacji wykonanej w kroku 7., ponieważ najpierw zaznaczyłeś
kolumnę Zysk, a następnie Cena, a nie odwrotnie. Aby poprawić błąd (albo sprawdzić,
czy formuła jest poprawna), wykonaj poniższe kroki.
a. Spójrz na panel Zastosowane kroki po prawej stronie okna edytora. Widoczne są w nim
wszystkie kroki, które do tej pory wykonałeś. Kliknij dowolny krok i sprawdź zawartość
panelu podglądu. Dane, które się tam pojawiają, są jedynie zapamiętanymi podglądami
rzeczywistych danych. Żadna z pośrednich tabel nie jest zapisywana w raporcie.
b. W panelu Zastosowane kroki kliknij krok Wstawiono odejmowanie.
c. W pasku formuły pojawi się długi kod. Odszukaj w nim następujący fragment:
[Koszt] - [Cena]
i zmień go na:
[Cena] - [Koszt]
Formuła powinna wyglądać tak:
= Table.AddColumn(#"Zmieniono typ", "Odejmowanie", each [Koszt] - [Cena], type number)
Uwaga. Jeżeli jesteś początkującym użytkownikiem edytora Power Query, nie zgłębiaj zanadto
składni tej formuły. Jest ona napisana w języku M. W tej książce nauczysz się, kiedy i jak zmieniać
formuły bez znajomości ich składni. Gdy dojdziesz do rozdziału 9., który zawiera wprowadzenie
do języka M, będziesz gotowy do zagłębienia się w ten język i poznania jego tajemnic.
11. Usuń kolumnę Kod produktu. W tym celu zaznacz kolumnę i naciśnij klawisz Delete.
Ewentualnie w karcie Strona główna kliknij ikonę Usuń kolumny.
41
4650570396d9eb2765da56c12eb840b5
4
12. Wypróbuj filtrowanie danych. Załóżmy, że chcesz zachować jedynie wiersze zawierające słowo
„górski”. Kliknij ikonę trójkąta w nagłówku kolumny Produkt i przejrzyj dostępne opcje.
Kliknij opcję Filtry tekstu, a następnie Zawiera. W oknie Filtrowanie wierszy, które się
pojawi, w polu obok listy zawiera wpisz słowo „górski” i kliknij OK.
Uwaga. Domyślnie narzędzie Power Query przetwarza testy z rozróżnieniem wielkości liter.
Gdybyś wpisał słowo „Górski”, uzyskałbyś pustą listę, ponieważ nie ma produktów, które w nazwie
mają takie słowo zaczynające się z wielkiej litery. Aby filtr nie rozróżniał wielkości liter, musisz
zmienić formułę. Oryginalna formuła wygląda tak:
= Table.SelectRows(#"Usunięto kolumny", each Text.Contains([Produkt], "górski"))
Jeżeli w trzecim argumencie funkcji Text.Contains podasz Comparer.OrdinalIgnoreCase,

wtedy filtr nie będzie rozróżniał wielkości liter. Poniżej przedstawiona jest zmodyfikowana
formuła:
= Table.SelectRows(#"Usunięto kolumny", each Text.Contains([Produkt], "górski",

Comparer.OrdinalIgnoreCase))
W tym momencie zapewne modyfikacja wydaje Ci się bardzo skomplikowana, ale nie
przejmuj się. W większości przypadków przekształcenia można wykonywać bez modyfikowania
formuł. Z tej książki dowiesz się, kiedy takie operacje należy wykonywać i w jaki sposób,
bez konieczności poznawania całej składni języka M. W rozdziale 10., „Od złych do dobrych
zapytań”, nabierzesz większego doświadczenia i będziesz mógł zagłębić się w zawiłości tego języka.
13. Na koniec załaduj dane do raportu. Jeżeli używasz programu Power BI Desktop, kliknij
w karcie Strona główna ikonę Zamknij i zastosuj. Teraz możesz przekształconą tabelę
wykorzystać do przygotowania elementów wizualnych. Jeżeli korzystasz z Excela, kliknij
w karcie Strona główna ikonę Zamknij i załaduj, aby umieścić tabelę w arkuszu.
Uwaga. W Excelu, inaczej niż w Power BI Desktop, udostępniono wiele opcji ładowania danych.
Można je załadować do skoroszytu lub do modelu danych albo zachować połączenie do późniejszego
wykorzystania. W wersji Excel 2016 lub nowszej dane można załadować bezpośrednio do tabeli
lub wykresu przestawnego.
14. Otwórz plik R01-01.xlsx i wprowadź w nim dowolne zmiany. Następnie zapisz plik i odśwież
raport. Zwróć uwagę, że zostaną w nim uwzględnione zmiany. Aby odświeżyć zapytanie
w Excelu, kliknij w karcie Dane ikonę Odśwież wszystko, natomiast w Power BI Desktop
w karcie Strona główna kliknij ikonę Odśwież.
Na tym polega istota automatyzacji w Power Query, z pomocą której można oszczędzić
mnóstwo czasu. Dane wystarczy przygotować raz, a potem w dowolnej chwili przetworzyć
dane, odświeżając raport.
Zobacz też. Jeżeli korzystasz z usługi Power BI, możesz zaplanować automatyczne odświeżanie
raportów, w tym opartych na lokalnych źródłach danych. Więcej informacji na ten temat
znajdziesz na stronie https://docs.microsoft.com/pl-pl/power-bi/refresh-scheduled-refresh.
42
4650570396d9eb2765da56c12eb840b5
4
15. Zmień zapytanie, wykonując następując kroki.

a. W Excelu kliknij w karcie Dane ikonę Zapytania i połączenia, a następnie dwukrotnie
kliknij zapytanie Produkty. Natomiast w Power BI Desktop w karcie Strona główna
kliknij ikonę Edytuj zapytania.
b. W panelu Zastosowane kroki kliknij dowolny krok, zmień go lub usuń albo wstaw nowy.
Aby wstawić nowy krok pomiędzy istniejącymi, użyj przekształcenia dostępnego
we wstążce lub podręcznym menu.
c. Aby zapisać zmiany i odświeżyć dane, kliknij w Excelu ikonę Zamknij i załaduj,
a w Power BI Desktop ikonę Zamknij i zastosuj.
W ten sposób zaimportowałeś i przekształciłeś oryginalną tabelę danych. Rozwiązanie jest
zapisane w plikach R01-01 - rozwiązanie.xlsx oraz R01-01 - rozwiązanie.pbix.
To ćwiczenie było rozgrzewką przed szerokim spektrum wyzwań, z którymi się zmierzysz
(i dowiesz się, jak im sprostać) dalej w tej książce.
Podsumowanie
Ten rozdział stanowił wprowadzenie do narzędzia Power Query i krótki przegląd jego funkcjonalności.
Poznałeś historię narzędzia i jego rozwój od prostego programu do badania danych do ważnej
technologii przetwarzania danych w Excelu, Power BI, Analysis Services, CDS i PowerApps.
Prawdopodobnie w czasie, gdy czytasz tę książkę, rola narzędzia Power Query wzrosła jeszcze
bardziej, a jego interfejs został zintegrowany z następnymi programami firmy Microsoft.
W pierwszym ćwiczeniu zaimportowałeś tabelę danych i wykonałeś kilka podstawowych
przekształceń. W następnym rozdziale nauczysz się wykonywać w edytorze Power Query
najważniejsze operacje przygotowywania danych, przy użyciu których zaoszczędzisz sporo
czasu i unikniesz wykonywania powtarzalnych czynności.
43
4650570396d9eb2765da56c12eb840b5
4
44
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 2.
Podstawowe operacje
przygotowywania danych
Kluczem do sukcesu jest przede wszystkim dobre przygotowanie.

— Alexander Graham Bell
W TYM ROZDZIALE NAUCZYSZ SIĘ:

 dzielić dane według ograniczników i wyodrębniać z nich potrzebne informacje,
 scalać kilka tabel wyszukiwania w jedną oraz wykorzystywać relacje pomiędzy tabelami
faktów a tabelami wyszukiwania,
 korzystać z funkcjonalności Kolumna z przykładów, wyodrębniać z kolumn potrzebne
dane, generować nowe i wykorzystywać je w przekształceniach,
 wyodrębniać z kolumn tekstowych ważne informacje, np. odnośniki,
 przetwarzać daty zapisane w różnych formatach regionalnych,
 wyodrębniać datę i godzinę z kolumny typu Data,
 dzielić dane na tabelę faktów i tabelę wyszukiwania za pomocą przekształceń Odwołanie
i Usuń duplikaty,
 rozwiązywać problemy z odświeżaniem raportów, gdy tabela wyszukiwania zawiera
powtarzające się dane nawet po usunięciu duplikatów,
 dzielić dane według ograniczników na wiersze i definiować skojarzenia pomiędzy grupami
a ich członkami.
Praca z nieuporządkowanymi danymi może pochłaniać mnóstwo czasu. W przeszłości analitycy

musieli wykonywać żmudną robotę, ręcznie poprawiając źle sformatowane dane. Zaawansowani
użytkownicy Excela oczyszczają i przygotowują dane, wykorzystując skomplikowane formuły i język VBA
(ang. Visual Basic for Applications, Visual Basic dla aplikacji). Programiści znający języki Python lub R
mogą zaprząc ich siłę do porządkowania danych. Jednak większość analityków rezygnuje z oczyszczania
danych, ponieważ związany z tym nakład pracy jest niewspółmierny do uzyskiwanych efektów.
4650570396d9eb2765da56c12eb840b5
4
W tym rozdziale poznasz kilka technik dostępnych w edytorze Power Query w Excelu i Power BI
Desktop, umożliwiających uporządkowanie źle sformatowanych danych w kilka minut. Jeżeli nie
masz doświadczenia z edytorem Power Query, ten rozdział będzie dla Ciebie bardzo ważny. Kiedy
zastosujesz proste techniki, które tu poznasz, zaoszczędzisz mnóstwo czasu, przygotowując dane,
i szybciej będziesz wykonywał na nich skomplikowane operacje.
Dane mogą Ci być potrzebne do doraźnej analizy lub regularnego tworzenia raportów dla
szerokiej rzeszy odbiorców. W tym rozdziale opisane zostały najbardziej podstawowe i najczęściej
stosowane techniki, które pozwolą Ci oszczędzić czas, jak również zautomatyzować i usprawnić
proces tworzenia raportów.
Wyodrębnianie informacji z zakodowanych danych

Jednym z największych wyzwań towarzyszących pracy z nieuporządkowanymi danymi jest
wyodrębnianie potrzebnych informacji ze źle sformatowanych kolumn. Jeżeli wartości są
rozdzielone ogranicznikami, można je umieszczać w osobnych kolumnach.
W Excelu dostępne są formuły do wyodrębniania wartości z tekstu. Do tego celu stosuje się
kombinacje funkcji LEWY, FRAGMENT.TEKSTU, PRAWY, ZNAJDŹ i DŁ. Czasami jednak proces wyodrębniania
wymaga zastosowania skomplikowanych formuł, które w miarę upływu czasu coraz trudniej
utrzymywać szczególnie wtedy, gdy zmieniają się dane źródłowe.
W Excelu za pomocą polecenia Tekst jako kolumny w karcie Dane można łatwo dzielić kolumnę
na kilka innych. Jeśli jednak trzeba tę samą operację zastosować dla całej tabeli, wtedy konieczne jest
ręczne wykonywanie tych samych kroków lub zakodowanie ich w postaci makra w języku VBA.
W tym rozdziale dowiesz się, jak sprostać temu wyzwaniu za pomocą Power Query. Przekonasz się,
że dzielenie kolumn jest wyjątkowo przydatną funkcjonalnością zarówno w Excelu, jak i w Power BI
Desktop; jest tak zwłaszcza wtedy, kiedy trzeba często wykonywać powtarzalne czynności, danych
jest dużo lub raporty muszą być regularnie generowane przez dłuższy okres czasu.
Fabryka Przygód
W tym rozdziale będziesz pracował na bazie danych zawierającej katalog produktów fikcyjnej firmy
Fabryka Przygód produkującej rowery.
Zobacz też. Fabryka Przygód (AdventureWorks) została wymyślona przez Microsoft na potrzeby
demonstrowania zastosowania różnych aplikacji w sytuacjach zbliżonych do rzeczywistych. Bazę
danych można uruchomić w usłudze Azure SQL Database. W tym celu należy wykonać kroki
opisane na stronie https://docs.microsoft.com/en-us/azure/sql-database/sql-database-get-started-portal.
Nie jest to konieczne do wykonania ćwiczeń opisanych w tej książce, ale można nauczyć się
posługiwania narzędziem Power Query na większej próbce danych.
Wyobraź sobie, że zacząłeś pracę jako analityk w Fabryce Przygód. Twoim pierwszym zadaniem
jest przeanalizowanie katalogu produktów i policzenie ich według kategorii, wielkości i kolorów.
Lista produktów została wyeksportowana ze starej bazy danych i zapisana w skoroszycie Excela
R02-01.xlsx.
46
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 2.  PODSTAWOWE OPERACJE PRZYGOTOWYWANIA DANYCH
Niestety, katalog nie zawiera kolumn Kategoria, Wielkość i Kolor. Jest natomiast kolumna
Kod produktu zawierająca potrzebne wartości oddzielone myślnikami. Rysunek 2.1 przedstawia
powiązania pomiędzy kolumną Kod produktu a potrzebnymi kolumnami.
RYSUNEK 2.1. W katalogu produktów Fabryki Przygód informacje o kategorii,

wielkości i kolorze są zapisane w kodzie produktu
Twój poprzednik, który ostatnio awansował i obecnie szefuje działowi analiz biznesowych, poradził
sobie z tym zadaniem, wykorzystując formuły Excela. W poniższym ćwiczeniu poznasz jego sposób.
Ćwiczenie 2.1. Stary sposób: formuły Excela

Otwórz plik R02-01 - rozwiązanie.xlsx, w którym Twój poprzednik użył formuł Excela do
wyodrębnienia informacji o kategoriach, wielkościach i kolorach produktów. W tym ćwiczeniu
wykorzystasz jego notatki i dowiesz się, jak osiągnął swój cel bez użycia Power Query.
Uwaga. Celem ćwiczenia 2.1 jest zilustrowanie typowego rozwiązania problemu za pomocą
Excela, bez użycia Power Query. Nie musisz wykonywać opisanych operacji ani nawet starać się
ich zrozumieć. Przekonasz się wkrótce, że sposób z wykorzystaniem Power Query jest znacznie
prostszy.
1. Otwórz plik R02-01 - rozwiązanie.xlsx.

2. Przejrzyj trzy pierwsze arkusze: Produkty, Kategorie i Kolory. Arkusz Produkty zawiera
główną tabelę katalogu. Arkusz Kategorie zawiera kody kategorii i odpowiadające im nazwy.
Przykładowo VE oznacza kamizelki, SH szorty, WB butelki, a BC uchwyty. Arkusz Kolory
zawiera kody kolorów i odpowiadające im nazwy, np. BE oznacza kolor niebieski, a BL czarny.
Czwarty arkusz zawiera trzy tabele przestawne z wynikami kilku analiz, które musisz
wykonać. Dane do wszystkich tabel znajdują się w arkuszu Produkty.
3. W arkuszu Produkty kliknij komórkę F2. W pasku formuły pojawi się następująca formuła:
=LEWY(C2;2)
Formuła ta zwraca dwa pierwsze znaki tekstu zawartego w kolumnie C (kod produktu).
Stanowią one kod kategorii.
4. Kliknij komórkę G2. W pasku formuły pojawi formuła:
=PRAWY(C2;2)
Formuła zwraca dwa ostatnie znaki tekstu zawartego w kolumnie C stanowiące kod koloru.
47
4650570396d9eb2765da56c12eb840b5
4
5. Kliknij komórkę H2. W pasku formuły pojawi się formuła:
=PODSTAW(FRAGMENT.TEKSTU(C2;SZUKAJ.TEKST("-";C2; 8); 3); "-"; "")

Formuła zwraca kod wielkości produktu. W tym miejscu zaczynają się trudności. Formuła ta
wyszukuje w kodzie produktu myślnik, poczynając od ósmego znaku, a następnie zwraca
jego pozycję. Potem za pomocą funkcji FRAGMENT.TEKSTU wyodrębnia trzy znaki. Ponieważ
na początku lub na końcu uzyskanego ciągu mogą znajdować się myślniki, są one usuwane
za pomocą funkcji PODSTAW.
6. Kliknij komórkę I2. W pasku formuły pojawi się następująca formuła:
=WYSZUKAJ.PIONOWO(F2;Kategorie!A:B; 2;FAŁSZ)
Formuła wyszukuje w arkuszu Kategorie nazwę kategorii odpowiadającą kodowi zapisanemu
w komórce F2.
7. Kliknij komórkę J2. W pasku formuły pojawi się następująca formuła:
=WYSZUKAJ.PIONOWO(G2;Kolory!A:B; 2;FAŁSZ)
Formuła ta wyszukuje w arkuszu Kolory nazwę koloru odpowiadającą kodowi zapisanemu
w komórce G2.
Jeżeli jesteś zaawansowanym użytkownikiem Excela, bez problemu zaimplementujesz te same
formuły w nowym arkuszu, np. R02-01.xlsx. Ewentualnie możesz skopiować do niego niezbędne
arkusze i formuły z kolumn od F do J.
Co jednak robić, kiedy dane są aktualizowane co tydzień? Jeżeli dane zmieniają się regularnie,
trzeba wykonywać powtarzające się operacje ich kopiowania i wklejania, co może skutkować
pomyłkami i błędnymi wynikami. W następnych dwóch ćwiczeniach poznasz lepszy sposób
osiągnięcia celu przy użyciu Power Query.
Ćwiczenie 2.2. Część I. Nowy sposób

W tym ćwiczeniu wykorzystasz edytor Power Query do utworzenia jednej tabeli o nazwie Produkty.
Będzie to znacznie lepsze rozwiązanie od opisanego wcześniej, ponieważ po aktualizacji danych
wystarczy po prostu odświeżyć arkusz, który nie będzie zawierał formuł wymagających kontroli
i ochrony.
Ćwiczenie możesz wykonać w Excelu, Power BI Desktop lub innym programie wyposażonym
w edytor Power Query.
Otwórz plik R02-02.xlsx. Znajdziesz w nim arkusze Produkty, Kategorie i Kolory.
Ćwiczenie zaczniesz od zaimportowania trzech tabel do edytora Power Query.
1. Utwórz w Excelu nowy skoroszyt lub w Power BI Desktop nowy raport.
2. Wykonaj poniższe kroki, aby zaimportować dane z pliku R02-02.xlsx do edytora.
a. W Excelu kliknij kartę Dane, następnie polecenie Pobierz dane/Z pliku/Ze skoroszytu.
W Power BI Desktop rozwiń menu Pobierz dane i wybierz Excel.
48
4650570396d9eb2765da56c12eb840b5
4
Uwaga. Ponieważ wstążki w różnych wersjach Excela różnią się, w tej książce przyjęte jest założenie,
że korzystasz z Excela z pakietu Office 365, w którym wejście do wszystkich funkcjonalności
znajduje się w rozwijanym menu Pobierz dane. Ćwiczenie możesz również wykonać w wersji
Excela 2010 lub 2013 z dodatkiem Power Query. Różnice w wykonywanych operacjach są
minimalne i dotyczą tylko początkowych kroków wykonywanych przy użyciu karty Dane
lub Power Query. Szczegóły zawarte są w rozdziale 1., „Wprowadzenie do Power Query”,
w podrozdziale „Gdzie znajduje się Power Query?”.
b. Wskaż plik R02-02.xlsx i kliknij Importuj.

c. W oknie Nawigator, które się pojawi, jeżeli używasz Excela, zaznacz opcję Wybierz wiele
elementów. Następnie niezależnie od używanego programu zaznacz arkusze Produkty,
Kategorie oraz Kolory i kliknij przycisk Przekształć dane. (Jak pisałem w rozdziale 1.,
jeżeli nie widzisz tego przycisku, kliknij Edytuj lub przycisk znajdujący się po prawej
stronie przycisku Załaduj).
3. Otworzy się edytor Power Query zawierający po lewej stronie panel Zapytania, w którym
będą znajdować się trzy zapytania (po jednym dla każdego arkusza wybranego w oknie
nawigatora w kroku 2.). Po kliknięciu dowolnego zapytania w panelu podglądu pojawią się
dane. Po prawej stronie okna znajdują się panele Ustawienia zapytania i Zastosowane kroki.
Ten drugi zawiera sekwencję zmian wprowadzanych w zapytaniu. Aby przygotować
zapytania Kategorie i Kolory, wykonaj następujące kroki.
a. W panelu Zapytania kliknij Kategorie. Zwróć uwagę, że w pliku podglądu pojawią się
kolumny o nazwach Column1 i Column2. W pierwszym wierszu znajdują się właściwe
nazwy kolumn, tj. Kod kategorii i Kategoria. Aby przenieść ten wiersz do nagłówków,
kliknij w karcie Przekształć ikonę Użyj pierwszego wiersza jako nagłówków.
Wskazówka. Jeżeli wolisz używać podręcznego menu, kliknij ikonę w lewym górnym rogu
panelu podglądu i wybierz polecenie Użyj pierwszego wiersza jako nagłówków.
b. W panelu Zapytania zaznacz Kolory i wykonaj te same kroki, co poprzednio. Kolumny

mają robocze nazwy Column1 i Column2, a właściwe nazwy Kod koloru i Kolor znajdują
się w pierwszym wierszu. Aby przenieść pierwszy wiersz do nagłówków, kliknij w karcie
Przekształć ikonę Użyj pierwszego wiersza jako nagłówków.
4. W panelu Zapytania zaznacz Produkty.
5. Zaznacz kolumnę Kod produktu. W tym celu kliknij jej nagłówek lub w karcie Strona główna
rozwiń menu Wybieranie kolumn i wybierz polecenie Przejdź do kolumny. W oknie, które się
pojawi, zaznacz pozycję Kod produktu i kliknij OK.
6. W karcie Przekształć rozwiń menu Podziel kolumny i wybierz polecenie Według
ogranicznika. Ewentualnie kliknij prawym przyciskiem myszy nagłówek kolumny Kod
produktu i z podręcznego menu wybierz polecenia Podziel kolumny i Według ogranicznika.
7. W oknie, które się pojawi, będą wybrane domyślne ustawienia (patrz rysunek 2.2).
Zanim klikniesz OK, przejrzyj widoczne elementy.
49
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 2.2. Okno „Dzielenie kolumny według ogranicznika” domyślnie wykorzystuje myślnik; dodatkowe
opcje znajdują się w sekcji Opcje zaawansowane, warto je przejrzeć i sprawdzić, czy są odpowiednie
 Wybrana jest opcja Niestandardowe i myślnik jako ogranicznik. Te ustawienia zostały

wybrane przez Power Query, ponieważ wszystkie wartości w kolumnach są oddzielone
myślnikami.
 Zaznaczona jest opcja Każde wystąpienie ogranicznika, ponieważ myślnik pojawia się
wielokrotnie.
 Po rozwinięciu sekcji Opcje zaawansowane pojawi się informacja, że kolumna Kod produktu
zostanie podzielona na cztery kolumny.
Wskazówka. Jeżeli każda wartość zawiera taką samą liczbę ograniczników, wtedy funkcjonalność
dzielenia kolumn jest bardzo pomocna. Jeżeli liczba ograniczników nie jest znana, wtedy należy
rozważyć podział kolumny na wiersze. Dalej w tym rozdziale dowiesz się, kiedy taki podział
się przydaje.
 Jak widać, wybrany jest również znak cudzysłowu. Do czego jest potrzebny? Jak zostałyby
podzielone wartości, gdyby jedna z nich zawierała myślnik, który nie powinien być
potraktowany jako ogranicznik? W takim przypadku autor danych może ująć tekst
zawierający myślnik w cudzysłowy, a Power Query nie podzieli takiego tekstu. Jedyny
problem może pojawić się wtedy, gdy nie ma cudzysłowu zamykającego. Wtedy cały tekst,
począwszy od cudzysłowu, jest pozostawiany w oryginalnej formie.
50
4650570396d9eb2765da56c12eb840b5
4
8. Po zamknięciu okna Dzielenie kolumny według ogranicznika w panelu podglądu pojawią się
kolumny Kod produktu.1, Kod produktu.2, Kod produktu.3 i Kod produktu.4. Zmień ich
nazwy odpowiednio na Kod kategorii, Krótki kod produktu, Wielkość i Kod koloru. W tym
celu kliknij dwukrotnie nagłówek odpowiedniej kolumny i wpisz nową nazwę. Ewentualnie
zaznacz kolumnę, a następnie w karcie Przekształć kliknij ikonę Zmień nazwę. Zostanie
zaznaczona nazwa kolumny, którą będziesz mógł zmienić.
W ten sposób utworzyłeś kolumnę Wielkość oraz kolumny zawierające kody kategorii
i kolorów produktów. Teraz poznasz dwie metody dodawania kolumny z rzeczywistymi
kategoriami i kolorami zamiast ich kodów. W części II ćwiczenia 2.2 dowiesz się, jak scalić
tabele Kategorie i Kolory z tabelą Produkty, a w części III ćwiczenia 2.2 — jak przekształcić
trzy tabele w tabelę faktów i tabele wyszukiwania.
9. Aby zapisać skoroszyt Excela lub raport Power BI Desktop, wykonaj następne kroki.
Excel
a. W karcie Strona główna rozwiń menu Zamknij i załaduj, a następnie wybierz
polecenie Zamknij i załaduj do. Pojawi się okno Importowanie danych.
b. Zaznacz opcję Utwórz tylko połączenie i sprawdź, czy nie jest zaznaczona opcja
Dodaj te dane do modelu danych (tej opcji użyjesz w III części ćwiczenia).
c. Zapisz skoroszyt pod nazwą R02-02 - rozwiązanie - część 1.xlsx.
Power BI Desktop: kliknij ikonę Zamknij i zastosuj, a następnie zapisz raport pod nazwą
R02-02 - rozwiązanie - część 1.pbix.
Ćwiczenie 2.2. Część II. Scalanie tabel wyszukiwania

W tej części ćwiczenia scalisz tabele Kategorie i Kolory z tabelą Produkty, wykorzystując kody kategorii
i kolorów. Jak pamiętasz, w ćwiczeniu 2.1 tego rodzaju scalenie było w Excelu realizowane za pomocą
funkcji WYSZUKAJ.PIONOWO. W tym ćwiczeniu poznasz odpowiednik tej funkcji w Power Query.
1. Excel: otwórz plik R02-02 - rozwiązanie - część 1.xlsx. W karcie Dane kliknij ikonę
Pobierz dane, a następnie wybierz polecenie Uruchom edytora dodatku Power Query.
Power BI Desktop: otwórz plik R02-02 - rozwiązanie - część 1.pbix i w karcie Strona główna
kliknij ikonę Edytuj zapytania.
2. Gdy otworzy się okno edytora Power Query, kliknij w panelu Zapytania element Produkty.
W karcie Strona główna kliknij ikonę Scal zapytania.
3. Okno Scalanie, które się pojawi, służy do scalania dwóch tabel przy użyciu zgodnych
wartości w określonych kolumnach. W tym przypadku scalisz tabele Kategorie i Produkty
przy użyciu kodu kategorii. Rysunek 2.3 ilustruje kroki, jakie musisz w tym celu wykonać.
a. W tabeli Produkty wybierz kolumnę Kod kategorii, a w rozwijanej liście pod tabelą
pozycję Kategorie. Następnie w nowej tabeli zaznacz kolumnę Kod kategorii
(patrz rysunek 2.3).
b. W rozwijanej liście Rodzaj sprzężenia wybierz pozycję Lewe zewnętrzne
(wszystkie z pierwszej, pasujące z drugiej) i kliknij OK.
W edytorze Power Query pojawi się nowa kolumna Kategorie z wartościami Table.
51
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 2.3. W oknie Scalanie można połączyć tabele Kategorie i Produkty przy użyciu kodów kategorii
4. Rozwiń kolumnę Kategorie (w tym celu kliknij ikonę z prawej strony nagłówka lub w karcie
Przekształć, rozwiń menu Kolumna strukturalna i wybierz polecenie Rozwiń).
5. W oknie, które się pojawi, usuń zaznaczenie Kod kategorii i zaznaczenie opcji Użyj
oryginalnej nazwy kolumny jako prefiksu. Na koniec kliknij OK. Kolumna Kategorie
zostanie zamieniona na nową kolumnę o nazwie Kategoria zawierającą nazwy kategorii.
6. Ponieważ masz kolumnę z nazwami kategorii, usuń kolumnę Kod kategorii poprzez jej
zaznaczenie i naciśnięcie klawisza Delete.
Uwaga. Użytkownikom przyzwyczajonym do Excela krok 6. może wydawać się dość uciążliwy.
Możesz się dziwić, dlaczego kolumna Kategorie nie zmieniła się po usunięciu kolumny Kod kategorii.
Pamiętaj jednak, że edytor Power Query nie działa tak jak Excel. W kroku 3. wykorzystałeś
kolumnę Kod kategorii do scalenia dwóch tabel za pomocą kodu kategorii. Natomiast w kroku
6. usunąłeś tę kolumnę. W Excelu arkusz można traktować jak jedną płaszczyznę, natomiast
w edytorze Power Query tworzone są wielowarstwowe przekształcenia, czyli stany. Każdy stan
można traktować jak pośrednią płaszczyznę lub tabelę, która stanowi jedynie podstawę dla
następnej płaszczyzny.
52
4650570396d9eb2765da56c12eb840b5
4
7. Aby scalić tabelę Kolory z tabelą Produkty, kliknij ponownie w karcie Strona główna ikonę
Scal zapytania. W oknie Scalanie wykonaj poniższe kroki (patrz rysunek 2.4).
RYSUNEK 2.4. W oknie Scalanie można połączyć tabele Kolory i Produkty przy użyciu kodów kolorów
a. W tabeli Produkty zaznacz kolumnę Kod koloru, a w rozwijanej liście pod tabelą
wybierz pozycję Kolory. Następnie w nowej tabeli zaznacz kolumnę Kod koloru.
b. W rozwijanej liście Rodzaj sprzężenia wybierz pozycję Lewe zewnętrzne
(wszystkie z pierwszej, pasujące z drugiej) i kliknij OK.
W edytorze Power Query pojawi się nowa kolumna Kolory z wartościami Table.
Zatrzymaj się teraz na chwilę, aby dowiedzieć się, czym jest obiekt Table i jak się go używa.
Oprócz rozwijania można na nim wykonywać trzy popularne operacje.
 Zagłębiać się w tabelę, klikając odnośniki zawarte w komórkach. W panelu Zastosowane
kroki będą się wtedy pojawiać nowe kroki. Od tego momentu można dalej przygotowywać
dane zawarte w obiekcie Table. Wypróbuj teraz tę funkcjonalność. Kliknij dowolną
komórkę w kolumnie Kolory. W panelu podglądu pojawi się tabela zawierająca jeden
wiersz z kodem koloru i jego nazwą. Aby wrócić do tabeli Produkty, usuń ostatni krok
z panelu Zastosowane kroki.
53
4650570396d9eb2765da56c12eb840b5
4
 Zagłębiać się w tabelę i tworzyć nowe zapytania. W ten sposób można badać dane,
zachowując nienaruszoną oryginalną tabelę. Aby to zrobić, kliknij prawym przyciskiem
myszy dowolny obiekt Table i wybierz polecenie Dodaj jako nowe zapytanie. Utworzysz
nowe zapytanie i nowy krok odpowiadający zagłębieniu się w tabelę w poprzednim
punkcie. Na koniec usuń ostatni krok.
 Doraźnie sprawdzać zawartość wybranego obiektu Table. W tym celu kliknij puste
miejsce w komórce. W dolnej części panelu pojawi się podgląd obiektu.
Teraz, gdy poznałeś dokładniej obiekt Table, rozwiń kolumnę Kolory.
Uwaga. Jak się przekonasz, praca z innymi strukturalnymi obiektami — rekordami, listami
i obiektami binarnymi — wygląda podobnie. W obiekt można się zagłębiać, tworzyć z niego
nowe zapytania i podglądać zawartość, klikając puste miejsce w komórce.
8. Rozwiń kolumnę Kolory (w tym celu kliknij ikonę z prawej strony nagłówka lub w karcie
Przekształć rozwiń menu Kolumna strukturalna i wybierz polecenie Rozwiń).
9. W oknie, które się pojawi, usuń zaznaczenie Kod koloru i zaznaczenie opcji Użyj oryginalnej
nazwy kolumny jako prefiksu. Na koniec kliknij OK. Kolumna Kolory zostanie zamieniona
na nową kolumnę o nazwie Kolor zawierającą nazwy kolorów.
10. Ponieważ masz kolumnę z nazwami kolorów, usuń kolumnę Kod koloru. Zapytanie Produkty
jest gotowe, czas je załadować do raportu.
11. Aby załadować zapytanie Produkty do modelu danych w Excelu, wykonaj następujące kroki.
a. W karcie Strona główna kliknij ikonę Zamknij i załaduj.
b. W karcie Dane kliknij ikonę Zapytania i połączenia, aby otworzyć panel zapytań.
Kliknij prawym przyciskiem myszy zapytanie Produkty i wybierz polecenie Załaduj do.
c. W oknie Importowanie danych, które się pojawi, zaznacz opcję Dodaj te dane do modelu
danych i kliknij OK.
d. Teraz utworzysz tabelę przestawną opartą na modelu danych i przeanalizujesz liczby
kolorów i kategorii produktów. W karcie Wstawianie kliknij ikonę Tabela przestawna.
Pojawi się okno Tworzenie tabeli przestawnej. Sprawdź, czy jest zaznaczona opcja
Użyj modelu danych tego skoroszytu i kliknij OK, aby zamknąć okno.
W Power BI Desktop wykonaj następujące kroki.
a. W panelu Zapytania kliknij prawym przyciskiem myszy zapytanie Kategorie i usuń
zaznaczenie polecenia Włącz ładowanie.
b. Kliknij prawym przyciskiem myszy zapytanie Kolory i usuń zaznaczenie polecenia
Włącz ładowanie.
Powyższe dwa kroki powodują, że wybrane zapytania będą stanowiły podstawę dla
innych zapytań. Ponieważ z tabel Kategorie i Kolory wyodrębniłeś nazwy kategorii
i kolorów, możesz w raporcie umieścić jedną tabelę Produkty. Usunięcie zaznaczenia
polecenia Włącz ładowanie spowoduje, że dane zapytanie nie zostanie załadowane do
raportu Power BI. Jest to równoważne wykonaniu w Excelu kroku 9b w części I ćwiczenia 2.2,
w którym w oknie Importowanie danych zaznaczyłeś opcję Utwórz tylko połączenie.
c. W karcie Strona główna kliknij ikonę Zamknij i zastosuj.
54
4650570396d9eb2765da56c12eb840b5
4
Tabela Produkty z kategoriami, wielkościami i kolorami produktów została załadowana.

Aby przejrzeć rozwiązanie zawierające gotowe tabele przestawne, otwórz w Excelu plik
R02-02 - rozwiązanie - część 2.xlsx lub w Power BI Desktop plik R02-02 - rozwiązanie - część 2.pbix.
Ćwiczenie 2.2. Część III. Tabele faktów i wyszukiwania

W części II ćwiczenia 2.2 scaliłeś tabele Kategorie i Kolory z tabelą Produkty. Opisana metoda
pozwala wprawdzie tworzyć jedną tabelę zawierającą informacje potrzebne do utworzenia raportu,
ale jest lepszy sposób, polegający na użyciu relacji.
Uwaga. Podczas importowania kilku tabeli do dokładnego wyliczenia wyników i umieszczenia

w pakiecie poprawnych informacji mogą być niezbędne relacje. W Excelu za pomocą modelu
danych oraz w programie Power BI Desktop tworzy się je bardzo łatwo. Aby dowiedzieć się
więcej o relacjach w Power BI, odwiedź stronę https://docs.microsoft.com/en-us/power-bi/
desktop-create-and-manage-relationships.
Część III ćwiczenia 2.2 zaczniesz od miejsca, w którym skończyłeś część I. Załaduj do modelu
danych trzy zapytania jako osobne tabele.
1. W Excelu otwórz skoroszyt R02-02 - rozwiązanie - część 1.xlsx. W kolejnych krokach załadujesz
wszystkie zapytania do modelu danych; wtedy będziesz mógł tworzyć tabele i wykresy przestawne
oparte na kilku tabelach. W tym celu kliknij w karcie Dane ikonę Zapytania i połączenia.
a. W panelu Zapytania i połączenia, który się pojawi, kliknij prawym przyciskiem myszy
zapytanie Kategorie i wybierz polecenie Załaduj do.
b. W oknie Importowanie danych zaznacz opcję Dodaj te dane do modelu danych i kliknij OK.
c. Kliknij prawym przyciskiem myszy zapytanie Kolory i wybierz polecenie Załaduj do.
d. W oknie Importowanie danych zaznacz opcję Dodaj te dane do modelu danych i kliknij OK.
e. Kliknij prawym przyciskiem myszy zapytanie Produkty i wybierz polecenie Załaduj do.
f. W oknie Importowanie danych zaznacz opcję Dodaj te dane do modelu danych i kliknij OK.
Załadowałeś do modelu danych wszystkie trzy tabele. Teraz pora na utworzenie relacji
pomiędzy nimi.
g. W karcie Dane kliknij ikonę Zarządzaj modelem danych. Pojawi się okno Power Pivot dla
programu Excel.
h. W karcie Narzędzia główne kliknij ikonę Widok diagramu.
W programie Power BI Desktop otwórz plik R02-02 - rozwiązanie - część 1.pbix i w pasku
po lewej stronie kliknij ikonę Model.
2. Przeciągnij kolumnę Kod kategorii z tabeli Kategorie do kolumny Kod kategorii w tabeli Produkty.
3. Przeciągnij kolumnę Kod koloru z tabeli Kolory do kolumny Kod koloru w tabeli Produkty.
Twój model danych składa się teraz z tabeli faktów zawierającej listę produktów oraz dwóch
tabel wyszukiwania z dodatkowymi informacjami o kategoriach i kolorach. Jak pokazuje
rysunek 2.5, relacje typu „jeden do wielu” istnieją pomiędzy kolumną Kod kategorii w tabeli
Kategorie a kolumną Kod kategorii w tabeli Produkty oraz kolumną Kod koloru w tabeli
Kolory a kolumną Kod koloru w tabeli Produkty.
55
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 2.5. Widok diagramu prezentuje relacje w modelu danych pomiędzy tabelami Kategorie i Produkty
oraz Kolory i Produkty
Zobacz też. Modelowanie danych nie jest przedmiotem tej książki. Aby dowiedzieć się więcej
na temat Power Pivot, modelu danych i relacji w Excelu i Power BI Desktop, sięgnij po książkę
Analyzing Data with Power BI and Power Pivot for Excel (Analiza danych za pomocą Power BI
i Power Pivot w Excelu, Alberto Ferrari, Marco Russo, wyd. Microsoft Press).
4. Po zdefiniowaniu relacji pomiędzy tabelami ukryj kolumny Kod kategorii i Kod koloru,
aby nie pojawiały się w tabelach i wykresach przestawnych ani w wizualizacjach Power BI.
Raporty będą wtedy bardziej czytelne. W innych sytuacjach, gdy jest wiele tabel faktów
połączonych z tabelą wyszukiwania za pomocą tej samej kolumny, ukrywając kolumny,
można tworzyć bardziej elastyczne raporty, w których jedna kolumna z tabeli wyszukiwania
może pełnić rolę fragmentatora lub filtru danych pochodzących z kilku tabel faktów.
W Excelu kliknij prawym przyciskiem myszy kolumnę Kod koloru w tabeli Kolory i wybierz
polecenie Ukryj przed narzędziami klienta. Tę samą operację wykonaj na kolumnie Kod
koloru w tabeli Produkty oraz kolumnach Kod kategorii w tabelach Kategorie i Produkty.
W Power BI Desktop kliknij prawym przyciskiem myszy kolumnę Kod koloru w tabeli
Kolory i wybierz polecenie Ukryj w widoku raportu. Tę samą operację wykonaj na kolumnie
Kod koloru w tabeli Produkty oraz kolumnach Kod kategorii w tabelach Kategorie i Produkty.
Teraz możesz tworzyć tabele i wykresy przestawne i wizualizacje, tak jak w załączonych
do książki plikach R02-02 - rozwiązanie - część 3.xlsx i R02-02 - rozwiązanie - część 3.pbix.
56
4650570396d9eb2765da56c12eb840b5
4
Wskazówka. Rozwiązanie opisane w części II ćwiczenia 2.2 upraszcza wprawdzie tworzenie

raportów, ponieważ wykorzystywana jest wtedy tylko jedna tabela, jednak w praktyce,
gdy trzeba tworzyć raporty oparte na wielu tabelach i kiedy model danych jest bardziej
skomplikowany, rozwiązanie z części III ćwiczenia 2.2 daje większe możliwości. Kiedy np.
mamy jedną tabelę wyszukiwania Kategorie połączoną z kilkoma tabelami faktów za pomocą
kolumny Kody kategorii, można porównywać wartości w kolumnach liczbowych kilku tabel
faktów, wykorzystując współdzielone kategorie.
Kolumna z przykładów
Zazwyczaj pierwsze polecenie w karcie, licząc od lewej strony, oferuje najważniejszą funkcjonalność.
Dlatego w Excelu w karcie Wstaw pierwszym poleceniem jest Tabela przypisania. W edytorze Power
Query pierwszą ikoną w karcie Dodaj kolumnę jest Kolumna z przykładów. Oferuje ona niezwykle
przydatną funkcjonalność umożliwiającą wyodrębnianie potrzebnych informacji z istniejących
kolumn i umieszczanie ich w nowych kolumnach. Nie jest przy tym wymagana znajomość różnych
przekształceń dostępnych w edytorze.
Za pomocą funkcjonalności Kolumna z przykładów można tworzyć nowe kolumny, wpisując po
prostu jedną lub kilka przykładowych wartości. Na tej podstawie edytor określi operacje niezbędne
do utworzenia kolumny z nowymi wartościami. Tę funkcjonalność można wykorzystywać do
szybkiego wyodrębniania potrzebnych danych. Jest ona szczególnie przydatna dla początkujących
użytkowników, ponieważ nie wymaga opanowania niezbędnych przekształceń dostępnych we
wstążce ani kodowania formuł w języku M. Wystarczy podać kilka przykładowych wartości dla
nowej kolumny, a resztę wykona edytor Power Query.
Ćwiczenie 2.3 stanowi prostą demonstrację funkcjonalności Kolumna z przykładów opartą
na danych wykorzystanych w ćwiczeniu 2.2.
Ćwiczenie 2.3. Część I. Kolumna z przykładów — wprowadzenie

W ćwiczeniu 2.2 podzieliłeś kod produktu na cztery elementy. Załóżmy jednak, że potrzebujesz
wyodrębnić tylko wielkość produktu. W tym ćwiczeniu dowiesz się, jak można to zrobić,
wykorzystując funkcjonalność Kolumna z przykładów.
1. Utwórz pusty skoroszyt w Excelu lub nowy raport w Power BI Desktop.
2. Wykonaj poniższe kroki, aby do edytora Power Query zaimportować dane ze skoroszytu
R02-02.xlsx.
a. W Excelu: w karcie Dane kliknij Pobierz dane, następnie Z pliku i Ze skoroszytu.
b. W Power BI Desktop: w karcie Dane rozwiń menu Pobierz dane i wybierz Excel.
c. Wybierz plik R02-02.xlsx i kliknij przycisk Importuj.
d. W oknie Nawigator zaznacz tabelę Produkty i kliknij przycisk Przekształć dane.
3. W edytorze Power Query w panelu podglądu będzie widoczna m.in. kolumna Kod produktu
zawierająca kody oddzielone myślnikami (np. VE-C304-S-BE). Zadanie polega na wyodrębnieniu
trzeciego kodu oznaczającego wielkość produktu.
57
4650570396d9eb2765da56c12eb840b5
4
Zaznacz kolumnę Kod produktu, a następnie w karcie Dodaj kolumnę rozwiń menu
Kolumna z przykładów. Pojawią się dwa polecenia:
 Ze wszystkich kolumn,
 Z zaznaczenia.
W tym ćwiczeniu musisz wyodrębnić z kolumny Kod produktu tylko jego wielkość,
więc wybierz polecenie Z zaznaczenia.
Wskazówka. Jeżeli wiesz, jakie kolumny mają być użyte do utworzenia nowej kolumny, wtedy
wybierając je i używając polecenia Kolumna z przykładów/Z zaznaczenia, zwiększysz szansę,
że edytor Power Query przedstawi Ci poprawne propozycje.
Edytor Power Query przejdzie w nowy tryb. Panel podglądu przesunie się w dół, a w jego
górnej części pojawi się komunikat Wprowadź przykładowe wartości, aby utworzyć nową
kolumnę. Po prawej stronie tej sekcji znajdują się przyciski OK i Anuluj umożliwiające
wyjście ze specjalnego trybu edytora.
Po prawej stronie panelu podglądu znajduje się pusta kolumna, w której możesz wpisywać przykłady.
Zanim zaczniesz, kliknij dwukrotnie nagłówek tej kolumny i zmień jej nazwę na Wielkość.
4. Kliknij dwukrotnie pierwszą pustą komórkę w kolumnie Wielkość. Pojawi się rozwijane menu
zawierające proponowane przykłady, które można wykorzystać do utworzenia nowej kolumny.
Wartości te można traktować jako sugestie przekształceń do wykorzystania przy wypełnianiu kolumny.
5. W pierwszej pustej komórce wpisz literę S oznaczającą wielkość produktu w kodzie VE-C304-S-BE
i naciśnij Enter. Jak pokazuje rysunek 2.6, edytor Power Query wypełni wszystkie wiersze
w kolumnie Wielkość proponowanymi wartościami. Naciśnij klawisze Ctrl+Enter lub kliknij
przycisk OK, aby utworzyć nową kolumnę.
RYSUNEK 2.6. Po przełączeniu edytora Power Query w tryb „Kolumna z przykładów”

można z kodów produktów łatwo wyodrębniać oznaczenia ich wielkości
58
4650570396d9eb2765da56c12eb840b5
4
6. Pojawi się nowa kolumna z żądanymi wartościami. Załaduj dane do skoroszytu

lub raportu i zapisz.
Gotowe rozwiązanie zawarte jest w plikach R02-03 - rozwiązanie - część 1.xlsx
i R02-03 - rozwiązanie - część 1.pbix.
Kolumna z przykładów w praktyce

Kolumna z przykładów jest bardzo przydatną funkcjonalnością, za pomocą której można odkrywać
przekształcenia oferowane przez edytor i język M. Sprawdźmy teraz, jak to się robi. W części I
ćwiczenia 2.3, w kroku 6. został w panelu Zastosowane kroki umieszczony krok Wstawiony tekst
między ogranicznikami. Po jego prawej stronie znajduje się symbol koła zębatego, po którego kliknięciu
otwiera się okno Tekst między ogranicznikami zawierające różne ustawienia wyodrębniania tekstu
spomiędzy ograniczników. Teraz, gdy wiesz już, że takie okno istnieje, sprawdź, za pomocą jakiego
polecenia we wstążce edytora można je otworzyć. W karcie Przekształć znajduje się rozwijane menu
Wyodrębnij, a w nim polecenie Tekst między ogranicznikami.
Dla średnio zaawansowanych użytkowników Power Query doskonałym sposobem poszerzenia
wiedzy o języku M jest korzystanie z funkcjonalności Kolumna z przykładów i przeglądanie kodu
pojawiającego się w górnej części panelu podglądu, wyróżnionego na rysunku 2.6. Widoczne są tam
przydatne funkcje, m.in. funkcja Text.BetweenDelimiters użyta w części I ćwiczenia 2.3.
Funkcjonalność Kolumna z przykładów pozwala przekształcać na wiele różnych sposobów
teksty, daty, godziny i liczby. Można ją nawet wykorzystywać do definiowania zakresów wartości
i kolumn warunkowych, które poznasz w części II ćwiczenia 2.3.
Zobacz też. Aktualna lista funkcji wykorzystywanych w funkcjonalności Kolumna z przykładów jest
dostępna na stronie https://docs.microsoft.com/en-us/power-bi/desktop-add-column-from-example.
Ćwiczenie 2.3. Część II. Zamiana wielkości na oznaczenie zakresu

W tej części ćwiczenia 2.3 wykorzystasz funkcjonalność Kolumna z przykładów do podzielenia
liczbowych oznaczeń wielkości produktów na zakresy. Gotowe rozwiązanie zawierające opisane niżej
kroki zapisane jest w plikach R02-03 - rozwiązanie - część 2.xlsx i R02-03 - rozwiązanie - część 2.pbix.
1. Otwórz plik R02-03 - rozwiązanie - część 1.xlsx lub R02-03 - rozwiązanie - część 1.pbix,
a następnie uruchom edytor Power Query. W tym celu w Excelu w karcie Dane kliknij ikonę
Pobierz dane, a następnie polecenie Uruchom edytora dodatku Power Query. W Power BI
Desktop kliknij w karcie Strona główna ikonę Edytuj zapytania.
Jak widać, kolumna Wielkość zawiera oznaczenia wielkości produktów składające się z liter
i cyfr. W kolejnych dwóch krokach pominiesz wartości tekstowe i skupisz się tylko na
liczbach. Utworzysz nową kolumnę zawierającą wyłącznie liczbowe oznaczenia wielkości.
Możesz to zrobić na kilka sposobów. W kroku 2. wykorzystasz funkcje obsługi błędów,
a w kroku 3. funkcjonalność Kolumna z przykładów.
2. Aby z kolumny Wielkość wyodrębnić wartości liczbowe, wykorzystując funkcję obsługi
błędów, wykonaj poniższe kroki.
59
4650570396d9eb2765da56c12eb840b5
4
a. Zaznacz kolumnę Wielkość, a następnie w karcie Dodaj kolumnę kliknij ikonę

Duplikuj kolumnę.
b. Zmień nazwę kolumny na Wielkość liczbowa, a jej typ na Liczba całkowita. W tym celu
kliknij ikonę ABC znajdującą się po lewej stronie nagłówka i z rozwijanego menu wybierz
polecenie Liczba całkowita.
c. We wszystkich komórkach zawierających teksty (S, M, L, X i NA) pojawi się napis Error.
Ponieważ zamierzasz pracować wyłącznie na liczbach, zastąp błędy pustymi wartościami.
W tym celu zaznacz kolumnę Wielkość liczbowa, a następnie w karcie Przekształć rozwiń
menu Zamienianie wartości i wybierz polecenie Zamienianie błędów. Prostszym sposobem
jest kliknięcie prawym przyciskiem myszy nagłówka kolumny i wybranie z podręcznego
menu polecenia Zamień błędy.
d. W oknie Zamienianie błędów, które się pojawi, wpisz w polu Wartość słowo null i kliknij
OK, żeby zamknąć okno.
3. Aby wyodrębnić wartości liczbowe, wykorzystując funkcjonalność Kolumna z przykładów,
zamiast zastępować błędy słowami null, wykonaj poniższe kroki.
a. Jeżeli wykonałeś krok 2., usuń z panelu Zastosowane kroki cztery ostatnie kroki.
Ostatnim pozostawionym krokiem powinien być Wstawiony tekst między
ogranicznikami.
b. Zaznacz kolumnę Wielkość, a następnie w karcie Dodaj kolumnę rozwiń menu
Kolumna z przykładów i wybierz polecenie Z zaznaczenia.
c. Zmień nazwę nowej kolumny, która się pojawi, na Wielkość liczbowa.
d. Pierwsza komórka kolumny Wielkość zawiera oznaczenie S. Ponieważ nie interesują Cię
tekstowe oznaczenia wielkości, kliknij dwukrotnie pustą komórkę w kolumnie Wielkość
liczbowa i wpisz słowo null.
e. W drugiej i trzeciej komórce kolumny Wielkość znajdują się oznaczenia M i L. Wpisz
w drugiej i trzeciej komórce kolumny Wielkość liczbowa słowo null i naciśnij Enter.
f. Siódma komórka kolumny Wielkość zawiera oznaczenie NA (ang. not applicable — nie
dotyczy). Wpisz słowo null w siódmej komórce kolumny Wielkość liczbowa i naciśnij Enter.
g. Przejdź do wiersza 21. W kolumnie Wielkość znajduje się wartość X. Wpisz null
w kolumnie Wielkość liczbowa i naciśnij Enter.
h. W wierszu 22. w kolumnie Wielkość znajduje się wartość 60. W kolumnie Wielkość
liczbowa wpisz liczbę 60 i naciśnij Enter. Edytor Power Query wypełni wszystkie komórki
kolumny Wielkość liczbowa proponowanymi wartościami. Naciśnij klawisze Ctrl+Enter,
aby utworzyć nową kolumnę Wielkość liczbowa.
W panelu Zastosowane kroki pojawił się krok Dodano kolumnę warunkową. Kliknij ikonę
ustawień znajdującą się po jego prawej stronie. Pojawi się okno Dodawanie kolumny warunkowej,
w którym można tworzyć nowe kolumny na podstawie wartości zawartych w innych kolumnach.
Do tego miejsca można dojść, definiując kolumnę warunkową zamiast stosowania funkcjonalności
Kolumna z przykładów. Zamknij okno. Więcej dowiesz się o nim w ćwiczeniu 2.4.
4. Zmień typ kolumny Wielkość liczbowa. W tym celu kliknij ikonę ABC w nagłówku kolumny
i z rozwijanego menu wybierz polecenie Liczba całkowita.
60
4650570396d9eb2765da56c12eb840b5
4
Dalej w tym ćwiczeniu utworzysz osobną tabelę produktów zawierającą liczbowe oznaczenia
wielkości, które podzielisz na cztery zakresy (S, M, L i X oznaczające odpowiednio mały,
średni, duży i bardzo duży), wykorzystując funkcjonalność Kolumna z przykładów.
5. W panelu Zapytania kliknij prawym przyciskiem myszy Produkty i wybierz polecenie
Odwołanie. Zmień nazwę nowego zapytania. W tym celu kliknij je prawym przyciskiem
myszy i wybierz polecenie Zmień nazwę i wpisz Produkty, wielkości liczbowe. Ewentualnie
wpisz nową nazwę w panelu Ustawienia zapytania w polu Nazwa.
Wskazówka. Odwołanie jest bardzo przydatną funkcjonalnością umożliwiającą tworzenie kopii

istniejącego zapytania uzyskanego w wyniku wykonania dotychczasowych kroków.
6. Usuń z nowego zapytania wszystkie wiersze zawierające puste wielkości (null). W tym celu
w nagłówku kolumny Wielkość liczbowa kliknij ikonę filtru i wybierz polecenie Usuń puste.
7. Załóżmy, że chcesz zamienić wszystkie wielkości liczbowe na oznaczenia S, M, L i X według
następujących reguł: wielkość większa lub równa 70 ma być zamieniona na literę X, większa
lub równa 60 na literę L, większa lub równa 50 na literę M, a większa lub równa 40 na literę S.
Poniżej opisane są kroki osiągnięcia tego celu za pomocą funkcjonalności Kolumna z przykładów
(sprawdź, wykorzystując rysunek 2.7, czy wykonałeś je poprawnie).
RYSUNEK 2.7. Za pomocą funkcjonalności Kolumna z przykładów można wielkości liczbowe zamienić
na oznaczenia zakresów
61
4650570396d9eb2765da56c12eb840b5
4
a. Zaznacz kolumnę Wielkość liczbowa, a następnie w karcie Dodaj kolumnę rozwiń menu
Kolumna z przykładów i wybierz polecenie Z zaznaczenia.
b. Zmień nazwę nowej kolumny na Symbol wielkości.
c. W wierszu 1. wpisz X, ponieważ kolumna Wielkość liczbowa zawiera wartość 70.
d. W wierszach 2. i 3. wpisz L, ponieważ kolumna Wielkość liczbowa zawiera odpowiednio
wartości 60 i 62.
e. W wierszu 5. wpisz M, ponieważ kolumna Wielkość liczbowa zawiera wartość 50.
f. W wierszu 20. wpisz S, ponieważ kolumna Wielkość liczbowa zawiera wartość 40.
g. Naciśnij Ctrl+Enter, aby utworzyć kolumnę Symbol wielkości zawierającą oznaczenia
zakresów wielkości.
8. Dla praktyki kliknij dwukrotnie w panelu Zastosowane kroki krok Dodano kolumnę
warunkową. Pojawi się okno Dodawanie kolumny warunkowej. Przejrzyj zawarte w nim
warunki definiujące poszczególne zakresy wielkości. Na koniec zamknij okno.
9. Przyjrzyj się kodowi w pasku formuły. Jest to język M, który zostanie dokładniej opisany
w rozdziale 9., „Wprowadzenie do języka M”.
Wyodrębnianie informacji z kolumn tekstowych

W poprzednim ćwiczeniu wyodrębniłeś z kodu produktu potrzebne wartości, wykorzystując
przekształcenie Dzielenie kolumny według ogranicznika. W następnym ćwiczeniu zmierzysz się
z popularnym zadaniem, czyli wyodrębnieniem potrzebnych informacji z tekstu bez określonej
struktury. Jeżeli dane są w miarę uporządkowane, zadanie to jest proste, ale zazwyczaj do jego
wykonania potrzebny jest cały arsenał różnych technik.
Ćwiczenie 2.4. Wyodrębnianie odnośników

z komunikatów tekstowych
W tym ćwiczeniu będziesz pracował na arkuszu zawierającym komunikaty zaimportowane
z oficjalnej strony wydawnictwa Microsoft Press na Facebooku. Niektóre odnośniki, np.
rozpoczynające się od prefiksu „http://”, wyodrębnia się dość łatwo. Jednak jest mnóstwo
przypadków, dla których zadanie to nie jest takie proste.
Uwaga. Niektóre wykonywane w tym ćwiczeniu operacje są dość zaawansowane i wymagają

manipulowania formułami, które nie są opisane w tym rozdziale. Operacje te są jednak bardzo
przydatne i nawet jeżeli na razie nie zrozumiesz ich dokładnie, będziesz mógł je wykorzystywać
do przetwarzania własnych danych. Gdy przeczytasz rozdział 9., w którym jest dokładniej
opisany język M, poruszone tu tematy będą bardziej zrozumiałe.
1. Utwórz pusty skoroszyt w Excelu lub pusty raport w Power BI Desktop.

2. Wykonaj poniższe kroki, aby zaimportować do edytora Power Query dane z pliku R02-04.xlsx.
W Power BI Desktop: w karcie Dane rozwiń menu Pobierz dane i wybierz Excel.
62
4650570396d9eb2765da56c12eb840b5
4
b. Wybierz plik R02-04.xlsx i kliknij przycisk Importuj.

c. W oknie Nawigator zaznacz tabelę Arkusz1 i kliknij przycisk Przekształć dane.
Otworzy się edytor Power Query i pojawi kolumna Komunikat zawierająca tekst bez
określonej struktury. Zanim zaczniesz wyodrębniać odnośniki, tak jak na rysunku 2.8,
utwórz kopię tej kolumny, aby nie naruszyć oryginalnych danych. W tym celu zaznacz
kolumnę Komunikat i w karcie Dodaj kolumnę kliknij ikonę Duplikuj kolumnę.
RYSUNEK 2.8. Wyodrębnianie odnośników z wpisów ze strony Microsoft Press na Facebooku
3. Zmień nazwę nowej kolumny na Odnośnik.

4. Do wyodrębnienia odnośników z nowej kolumny wykorzystasz prefiks „http://”. Użyjesz go
jako ogranicznika przy dzieleniu kolumny. W tym celu zaznacz kolumnę Odnośnik, a następnie
w kolumnie Przekształć rozwiń menu Podziel kolumny i wybierz polecenie Według ogranicznika.
5. W oknie Dzielenie kolumny według ogranicznika, które się pojawi, wykonaj następne kroki.
a. W polu Niestandardowe wpisz http://.
b. Zaznacz opcję Ogranicznik najdalej z lewej strony i kliknij OK, aby zamknąć okno.
Kolumna Odnośnik zostanie podzielona na dwie nowe kolumny: Odnośnik.1 i Odnośnik.2.
Jednak w jaki sposób wyodrębnić odnośniki rozpoczynające się od „https://” lub po prostu
od „www.”?
6. W panelu Zastosowane kroki kliknij krok Podzielono kolumnę według ogranicznika.
7. Sprawdź, czy widoczny jest pasek formuły. Jeżeli nie, zaznacz w karcie Widok opcję
Pasek formuły. Poniżej przedstawiona jest formuła utworzona w kroku 5.:
= Table.SplitColumn(#"Zmieniono nazwy kolumn", "Odnośnik", Splitter.SplitTextBy
EachDelimiter({"http://"}, QuoteStyle.Csv, false), {"Odnośnik.1", "Odnośnik.2"})
63
4650570396d9eb2765da56c12eb840b5
4
8. Aby podzielić kolumnę według innych ograniczników, zmień nazwę funkcji

z Splitter.SplitTextByEachDelimiter na Splitter.SplitTextByAnyDelimiter. Teraz
możesz wskazać dodatkowe ograniczniki „https://” i „www.”. W powyższej formule ciąg
"http://" jest umieszczony wewnątrz nawiasów klamrowych, które w języku M definiują
listę. W tej liście możesz umieszczać ciągi znaków ujęte w cudzysłowy i rozdzielone
przecinkami, np. {"http://", "https://", "www."}.
Poniżej przedstawiona została poprawiona formuła:
= Table.SplitColumn(#"Zmieniono nazwy kolumn", "Odnośnik", Splitter.SplitTextByAny
Delimiter({"http://", "https://", "www."}, QuoteStyle.Csv, false), {"Odnośnik.1",
"Odnośnik.2"})
9. Po dodaniu ogranicznika „www.” w panelu podglądu w kolumnie Odnośnik.2 wierszu 8.
pojawi się nowy odnośnik microsoftpressstore.com/deals.
10. Kliknij ostatni krok w panelu Zastosowane kroki.
11. Zwróć uwagę, że w kolumnie Odnośnik.2 w wierszu 15. po odnośniku znajduje się
dodatkowy tekst. Aby usunąć takie teksty, przyjmij, że po odnośniku znajduje się spacja.
Użyj jej do podzielenia kolumny Odnośnik.2. W tym celu zaznacz kolumnę Odnośnik.2,
a następnie w karcie Przekształć rozwiń menu Podziel kolumny i wybierz polecenie
Według ogranicznika. Pojawi się okno Dzielenie kolumny według ogranicznika.
a. W rozwijanej liście Wybierz lub wprowadź ogranicznik wybierz pozycję Spacja.
b. Zaznacz opcję Ogranicznik najdalej z lewej strony i kliknij OK, aby zamknąć okno.
12. Usuń kolumnę Odnośnik.2.2.
Przewiń tabelę w dół do wiersza 29., w którym w kolumnie Odnośnik.2 znajduje się wartość
null oznaczająca, że komunikat nie zawiera odnośnika. Jeśli jednak przyjrzysz się dokładniej,
zauważysz, że jest inaczej. Poniżej przedstawiony jest komunikat z wyróżnionym odnośnikiem:
Discover Windows containers in this free ebook. Download here: aka.ms/containersebook.
Kolejnym zadaniem będzie wyodrębnienie odnośników zawierających nazwę domeny
aka.ms, a następnie umieszczenie ich w kolumnie Odnośnik. Operacja będzie dość
skomplikowana, ponieważ gdybyś podzielił kolumnę Komunikat, używając ogranicznika
„aka.ms”, nazwa domeny zostałaby usunięta z wynikowego tekstu. W kroku 8. użyłeś
ogranicznika „www.”, który został usunięty, ale nie miało to większego znaczenia, ponieważ
ryzyko, że odnośnik bez prefiksu „www.” nie będzie działał, jest niewielkie. W większości
przypadków pomija się ten prefiks, np. odnośniki www.microsoft.com i microsoft.com
wskazują tę samą stronę.
Musisz więc znaleźć taki sposób na podzielenie kolumny według ogranicznika „aka.ms”,
aby uzyskać odnośnik z nazwą domeny, ale tylko w wierszach, które zawierają tę domenę.
Za chwilę dowiesz się, jak można to zrobić za pomocą kolumny warunkowej. Wcześniej
jednak dodaj „aka.ms” do listy ograniczników.
13. W panelu Zastosowane kroki kliknij ponownie krok Podzielono kolumnę według ogranicznika,
który zmieniłeś w punkcie 8., i dodaj ogranicznik „aka.ms”. Poniżej przedstawiona jest
nowa formuła:
Delimiter({"http://", "https://", "www.", "aka.ms"}, QuoteStyle.Csv, false),
{"Odnośnik.1", "Odnośnik.2"})
64
4650570396d9eb2765da56c12eb840b5
4
W wierszu 29. pojawi się odnośnik /containersebook. W kolejnych krokach dodasz kolumnę
warunkową, w której umieścisz brakującą nazwę domeny „aka.ms”, jeżeli pierwszym
znakiem w kolumnie Odnośnik będzie ukośnik (/).
14. W panelu Zastosowane kroki kliknij ostatni krok. Usuń kolumnę Odnośnik.1, a następnie
zmień nazwę kolumny Odnośnik.2.1 na Odnośnik stary.
15. W karcie Dodaj kolumnę kliknij ikonę Kolumna warunkowa. W oknie Dodawanie kolumny
warunkowej, które się pojawi, wykonaj poniższe kroki (patrz rysunek 2.9).
RYSUNEK 2.9. Dodanie kolumny warunkowej ma na celu przywrócenie nazwy domeny „aka.ms”; pamiętaj,
że warunki zdefiniowane w tym oknie służą jedynie do przygotowania ostatecznego warunku
Uwaga. Za pomocą okna Dodawanie kolumny warunkowej przygotowuje się materiał do utworzenia
ostatecznego warunku. Funkcjonalności tego okna są ograniczone i należy je traktować jako
narzędzie do przygotowania żądanych fragmentów końcowego warunku. Na koniec, w kroku
16., niezbędna będzie nieznaczna modyfikacja w pasku formuły uzyskanego kodu.
a. W polu Nazwa nowej kolumny wpisz Odnośnik.

b. W rozwijanej liście Nazwa kolumny wybierz Odnośnik stary.
c. W rozwijanej liście Operator wybierz Równa się, a w polach Wartość i Wartość wyjściowa
wpisz null.
d. Kliknij przycisk Dodaj regułę, aby utworzyć nowy wiersz warunku.
e. W rozwijanej liście Nazwa kolumny wybierz Odnośnik stary.
f. W rozwijanej liście Operator wybierz zaczyna się od.
g. W rozwijanej liście ABC123 wybierz polecenie Wprowadź wartość, a następnie w polu
Wartość wpisz znak /.
h. W drugiej rozwijanej liście ABC123 wybierz polecenie Wprowadź kolumnę, a następnie
w rozwijanej liście Wartość wyjściowa wybierz Odnośnik stary.
65
4650570396d9eb2765da56c12eb840b5
4
i. W rozwijanej liście ABC123 w dolnej części okna wybierz polecenie Wprowadź kolumnę,
a następnie w rozwijanej liście obok wybierz Odnośnik stary.
j. Sprawdź, czy ustawienia są takie same jak na rysunku 2.9 i kliknij OK, aby zamknąć okno.
16. Zwróć uwagę na pasek formuły. Teraz pora zmienić kod formuły tak, aby dodawała prefiks
„aka.ms”, gdy pierwszym znakiem odnośnika jest ukośnik. Poniżej przedstawiona jest
formuła utworzona w kroku 15.:
= Table.AddColumn(#"Zmieniono nazwy kolumn1", "Odnośnik", each if [Odnośnik stary] =
null then null else if Text.StartsWith([Odnośnik stary], "/") then [Odnośnik stary]
else [Odnośnik stary])
Aby skorygować formułę, musisz złączyć tekst "aka.ms" z wyróżnionym fragmentem
[Odnośnik stary]. Podobnie jak w Excelu, użyj w tym celu operatora &. Poniżej
przedstawiona jest poprawiona formuła z wyróżnioną zmianą:
= Table.AddColumn(#"Zmieniono nazwy kolumn1", "Odnośnik", each if [Odnośnik stary] =
null then null else if Text.StartsWith([Odnośnik stary], "/") then "aka.ms" &
[Odnośnik stary] else [Odnośnik stary])
Uwaga. Pierwszy warunek zdefiniowany w kroku 15. zabezpiecza przed wywołaniem funkcji
Text.StartsWith w przypadku, gdy kolumna [Odnośnik stary] zawiera wartość null,
co spowodowałoby pojawienie się błędu.
17. Usuń kolumnę Odnośnik stary.

Zadanie jest prawie ukończone, ale czeka Cię jeszcze kilka niespodzianek. Przewiń tabelę
do wiersza 149. Komórka w kolumnie Odnośnik jest pusta, choć w kolumnie Komunikat
znajduje się następujący odnośnik: https://www.microsoftpressstore.com/Ignite.
Dlaczego ta komórka jest pusta? W kroku 8. komunikat został podzielony według
ograniczników „https://” i „www.” na trzy części, z których zostały wykorzystane tylko
dwie pierwsze. W kolejnym kroku rozwiążesz ten problem.
18. W panelu Zastosowane kroki kliknij pierwszy krok Podzielono kolumnę według ogranicznika,
a następnie w formule zmień wyróżniony niżej fragment {"Odnośnik.1", "Odnośnik.2"}
na liczbę 3. Poniżej przedstawiona jest oryginalna formuła:
Delimiter({"http://", "https://", "www.", "aka.ms"}, QuoteStyle.Csv, false),
{"Odnośnik.1", "Odnośnik.2"})
Natomiast poprawiona wygląda następująco:
Delimiter({"http://", "https://", "www.", "aka.ms"}, QuoteStyle.Csv, false), 3)
Zobacz też. W powyższej formule w argumencie funkcji zastąpiłeś listę {"Odnośnik.1",

"Odnośnik.2"} liczbą 3, ale formuła będzie zwracać ten sam wynik. Argumentem funkcji
Table.SplitColumn może być lista nazw kolumn lub liczba nowych kolumn, na które ma być
podzielona wskazana kolumna. Pamiętaj, że stosując domyślne wartości, możesz utracić ważne
dane. Ten temat jest szczegółowo opisany w rozdziale 10., „Od złych do dobrych zapytań”.
66
4650570396d9eb2765da56c12eb840b5
4
W tej chwili, jak pokazuje rysunek 2.10, żądany odnośnik znajduje się w kolumnie
Odnośnik.2 lub Odnośnik.3 (wiersz 149.). Jeżeli scalisz obie kolumny, wtedy odzyskasz
brakujące odnośniki i poprawisz zapytanie.
RYSUNEK 2.10. Aby wyodrębnić odnośniki rozpoczynające się od „https://www.”, musisz scalić kolumny
Odnośnik.2 i Odnośnik.3
19. Upewnij się, że zaznaczony jest krok Podzielono kolumnę według ogranicznika, a następnie
wstaw do sekwencji poniższe kroki.
a. Zaznacz kolumny Odnośnik.2 i Odnośnik.3.
b. W karcie Przekształć kliknij ikonę Scal kolumny.
c. Pojawi się okno Wstawianie kroku z ostrzeżeniem, że wstawienie nowego kroku może
zakłócić działanie pozostałych kroków. Kliknij przycisk Wstaw.
d. W oknie Scal kolumny, które się pojawi, pozostaw domyślne ustawienia i kliknij OK.
e. Zmień nazwę kolumny Scalone na Odnośnik.2.
f. Gdy pojawi się okno Wstawianie kroku, ponownie kliknij Wstaw.
20. Zaznacz ostatni krok w panelu Zastosowane kroki i upewnij się, że wszystkie operacje zostały
wykonane poprawnie.
Pozostały jeszcze dwa błędnie obsłużone przypadki. Po pierwsze, zwróć uwagę, że na końcu
odnośnika w wierszu 149. nie znajduje się spacja, tylko kropka. Z tego powodu w kroku 11.
nie został usunięty tekst znajdujący się po odnośniku. Aby to poprawić, usuń znaki
interpunkcyjne ze wszystkich odnośników.
67
4650570396d9eb2765da56c12eb840b5
4
21. Zaznacz kolumnę Odnośnik, a następnie w karcie Przekształć rozwiń menu Format i wybierz
polecenie Przycięcie. Ewentualnie kliknij prawym przyciskiem myszy nagłówek kolumny
Odnośnik i z podręcznego menu wybierz polecenie Przekształć i Przycięcie.
Domyślnie polecenie Przycięcie usuwa z początku i końca tekstu spacje. Możesz jednak
zmienić je tak, aby usuwało znaki interpunkcyjne. Wymagane jest w tym celu wprowadzenie
pewnych zmian w formule. Zwróć uwagę na wyróżniony fragment Text.Trim w poniższym
kodzie:
= Table.TransformColumns(#"Usunięto kolumny2",{{"Odnośnik", Text.Trim, type text}})
Drugim argumentem funkcji Text.Trim jest lista znaków, jakie mają być usunięte z początku
i końca tekstu. W języku M listę złożoną z kropki, przecinka i nawiasu zamykającego
definiuje się w następujący sposób: { ".", ",", ")" }.
Aby zdefiniować drugi argument funkcji, trzeba również zdefiniować jej pierwszy argument,
czyli wskazać zawartość komórki w kolumnie Odnośnik. W tym celu należy użyć słowa
kluczowego each oraz znaku podkreślenia (składnia ta jest dokładniej opisana w rozdziale 9.).
Wpisz poniższy kod w pasku formuły, aby usunąć z kolumny Odnośnik dodatkowe znaki:
= Table.TransformColumns(#"Usunięto kolumny2",{{"Odnośnik", each Text.Trim(_,
{".",",",")"}), type text}})
22. Ostatni problem ujawnia się w wierszu 174., w którym po odnośniku następuje znak nowego
wiersza i dodatkowy tekst. W drugim przekształceniu Podzielono kolumnę według ogranicznika
wykorzystującym spację ten odnośnik nie został poprawnie wyodrębniony. Aby to poprawić,
kliknij w panelu Zastosowane kroki powyższy krok.
23. W pasku formuły znajduje się następujący kod:
= Table.SplitColumn(#"Zmieniono typ1", "Odnośnik.2", Splitter.SplitTextByEach

Delimiter({" "}, QuoteStyle.Csv, false), {"Odnośnik.2.1", "Odnośnik.2.2"})
Wprowadź w nim wyróżnione niżej zmiany:
= Table.SplitColumn(#"Zmieniono typ1", "Odnośnik.2", Splitter.SplitTextByAnyDelimiter({"
", "#(lf)"}, QuoteStyle.Csv, false), {"Odnośnik.2.1", "Odnośnik.2.2"})
Ciąg "#(lf)" reprezentuje znak nowego wiersza. W powyższej formule wykorzystałeś
bardziej zaawansowaną funkcję Splitter.SplitTextByAnyDelimiter dzielącą tekst według
kilku ograniczników.
24. Na koniec poprzedź wszystkie odnośniki prefiksem „http://”. W tym celu w panelu
Zastosowane kroki kliknij ostatni krok, a następnie zaznacz kolumnę Odnośnik. W karcie
Przekształć rozwiń menu Format i wybierz polecenie Dodaj prefiks. W oknie Prefiks,
które się pojawi, wpisz w polu Wartość ciąg http:// i kliknij OK, aby zamknąć okno.
25. W powyższym kroku dodałeś prefiks „http://” do wszystkich wierszy, nawet tych, które nie
zawierają odnośnika. Jednak pusta komórka w kolumnie Odnośnik (np. w wierszu 113.)
może być poprawnym efektem wykonanych operacji. Aby usunąć prefiks z pustych
komórek, wykonaj poniższe kroki.
a. Zaznacz kolumnę Odnośnik, a następnie w karcie Strona główna kliknij ikonę
Zamienianie wartości.
b. W oknie, które się pojawi, wpisz w polu Wartość do znalezienia ciąg http://.
c. Pole Zamień na pozostaw puste.
68
4650570396d9eb2765da56c12eb840b5
4
d. Rozwiń sekcję Opcje zaawansowane i zaznacz opcję Dopasuj do całej zawartości kolumny.
Jest to bardzo ważne. Jeżeli tego nie zrobisz, prefiks „http://” zostanie usunięty ze
wszystkich komórek.
e. Kliknij OK, aby zamknąć okno. Następnie kliknij ikonę Zamknij i załaduj (jeżeli używasz
Excela) lub Zamknij i zastosuj (jeżeli używasz Power BI Desktop), aby załadować do
raportu komunikaty i wyodrębnione odnośniki.
Rozwiązałeś większość problemów dotyczących przetwarzania danych tekstowych
i wyodrębniłeś odnośniki. Gotowe rozwiązanie znajduje się w plikach R02-04 - rozwiązanie.xlsx
i R02-04 - rozwiązanie.pbix.
Zobacz też. W kolumnie Komunikaty wciąż znajdują się niewyodrębnione odnośniki, które nie
rozpoczynają się od „www.”, „http”, „https” ani „aka.ms”. Potrafisz je znaleźć? W rozdziale 11.,
„Podstawy analizy tekstu”, poznasz zaawansowane techniki wyszukiwania słów kluczowych w tekście;
przy ich użyciu będziesz mógł wykrywać więcej nazw domen i skuteczniej wyodrębniać odnośniki.
Operacje na datach
Podczas przygotowywania danych bardzo często trzeba wykonywać operacje na datach. Kolumny
tekstowe są dość proste w obsłudze, ale przekształcanie liczb i dat nawet w najprostszych zbiorach
danych może być bardzo frustrującym zajęciem. W tym podrozdziale dowiesz się, jak wykonuje się
operacje na datach. Zaczniesz od najczęściej spotykanego problemu, tj. zamiany tekstu na datę,
a następnie przejdziesz do bardziej ambitnych przypadków obejmujących sprawdzanie poprawności
daty. Na końcu tego podrozdziału nauczysz się wyodrębniać określone elementy daty i godziny.
Podczas ładowania tabeli danych Power Query przekształca kolumny zawierające datę i godzinę
na odpowiedni format. W ćwiczeniu 2.4 zaimportowałeś zbiór danych zawierający kolumnę Data
i edytor Power Query automatycznie nadał jej format Data/godzina. W ćwiczeniu 2.5 dowiesz się,
jak można przetwarzać daty zapisane w różnych formatach.
Ćwiczenie 2.5. Operacje na różnych formatach dat

Plik R02-05.xlsx zawiera katalog produktów firmy Fabryka Przygód. W ostatniej kolumnie znajdują
się daty produkcji artykułów. Załóżmy, że użytkownicy wpisywali daty w różnych formatach:
 1/7/2018
 2018-07-01
 7.1.2018
 lip 1, 2018
 1 lipiec, 2018
Jeżeli spróbujesz w Excelu wykonać jakieś operacje na datach, okaże się, że bardzo często ich
format nie zostanie rozpoznany i będą pojawiały się błędy #ARG!.
1. Otwórz plik R02-05.xlsx (na wszelki wypadek utwórz jego kopię).
2. W kolumnie H2 wpisz następującą formułę:
=G2+1
69
4650570396d9eb2765da56c12eb840b5
4
Formuła ta zwiększa datę o 1 dzień, ale jej wynikiem jest liczba 43283, ponieważ Excel zapisuje
daty w postaci liczb całkowitych, aby mógł na nich wykonywać operacje. Data 1 stycznia
1900 jest zapisywana jako liczba 1, a data 1 stycznia 2018 jako 43282 (jest to liczba dni,
jakie upłynęły od 1 stycznia 1900 r.).
3. Aby data była poprawnie wyświetlana, zmień format kolumny H2 na Data. Następnie skopiuj
kolumnę H2 do schowka i wklej ją do komórek H3, H4, H5 i H6. W komórkach H2, H4 i H5 pojawi
się błąd #ARG!, ponieważ Excel nie będzie w stanie przekształcić zawartości tych komórek
na datę, aby później przesunąć je o jeden dzień.
4. Pora dowiedzieć się, jak w takiej sytuacji może się przydać Power Query. Utwórz pusty
skoroszyt w Excelu lub pusty raport w Power BI Desktop. Ponieważ dane źródłowe zapisane
są w zgodnie z polską konwencją, musisz w tym ćwiczeniu stosować odpowiednie ustawienia
regionalne. Dopóki nie zamknąłeś edytora Power Query, wykonaj następujące operacje.
W Excelu: kliknij kartę Plik, następnie Opcje i ustawienia i Opcje zapytania. W sekcji Bieżący
skoroszyt kliknij Ustawienia regionalne i w rozwijanej liście wybierz Polski (Polska).
W Power BI Desktop: kliknij kartę Plik, następnie Opcje i ustawienia i Opcje. Później w sekcji
Bieżący plik kliknij Ustawienia regionalne i w rozwijanej liście wybierz Polski (Polska).
5. Kliknij OK, aby zamknąć okno opcji.
6. Zaimportuj plik R02-05.xlsx do edytora Power Query.
c. W oknie Nawigator zaznacz tabelę Arkusz1 i kliknij przycisk Przekształć dane.
7. Gdy pojawi się okno edytora, zwróć uwagę, że wszystkie daty w kolumnie Data produkcji
są zapisane poprawnie, co pokazuje rysunek 2.11.
RYSUNEK 2.11. Edytor Power Query automatycznie zmienia typ kolumny z Tekst na Data i przekształca
wartości zapisane w różnych formatach
8. Zamknij okno edytora i załaduj dane do raportu.
70
4650570396d9eb2765da56c12eb840b5
4
Wskazówka. Jeżeli importowane dane są zapisane w innym formacie regionalnym niż ustawiony
w Twoim systemie operacyjnym, wybierz odpowiednie ustawienia w opcjach zapytania (patrz
krok 4.). Po odświeżeniu panelu podglądu w edytorze dane powinny zostać poprawnie rozpoznane.
Ćwiczenie 2.6. Operacje na datach

z różnymi ustawieniami regionalnymi
W ćwiczeniu 2.5 daty były wprawdzie zapisane w różnych formatach, ale przyjąłeś założenie, że
zgodnie z takimi samymi ustawieniami regionalnymi. W tym ćwiczeniu nauczysz się wykonywać
operacje na datach zapisanych z różnymi ustawieniami regionalnymi. W niektórych wierszach
trzeba będzie zamieniać miejscami oznaczenia dni i miesięcy.
Otwórz plik R02-06.xlsx. Dla uproszczenia przykładu zawiera on tylko dwa wiersze z katalogu
produktów firmy Fabryka Przygód, w których daty produkcji zapisane są z różnymi ustawieniami
regionalnymi:
 ustawienia amerykańskie: 7/23/2018,
 ustawienia polskie: 23/7/2018.
Jak pokazuje rysunek 2.12, jeżeli w edytorze Power Query wybrane są ustawienia regionalne
Polski (Polska), wtedy po zmianie typu danych w kolumnie Data produkcji pojawi się błąd w wierszu
zawierającym kod kraju US. Jeżeli natomiast w edytorze wybrane są ustawienia Angielski
(Stany Zjednoczone), wtedy błąd pojawia się w wierszu zawierającym kod kraju PL.
RYSUNEK 2.12. Po zmianie formatu w kolumnie Data produkcji z Tekst na Data, w niektórych komórkach,
w zależności od bieżących ustawień regionalnych, pojawią się błędy
Aby rozwiązać ten problem, nie można zdawać się na ustawienia regionalne. Zamiast tego należy
w opisany niżej sposób użyć funkcjonalności Dzielenie kolumny według ogranicznika i zastosować
kolumnę warunkową.
1. Utwórz nowy skoroszyt w Excelu lub nowy raport w Power BI Desktop.
2. Zaimportuj plik R02-06.xlsx do edytora Power Query.
71
4650570396d9eb2765da56c12eb840b5
4

c. W oknie Nawigator zaznacz tabelę Produkty i kliknij przycisk Przekształć dane.
3. Zaznacz kolumnę Data produkcji, a następnie w karcie Przekształć rozwiń menu Podziel
kolumny i wybierz polecenie Według ogranicznika. W oknie Dzielenie kolumny według
ogranicznika, które się pojawi, będzie wybrany ukośnik jako ogranicznik. Kliknij OK,
aby zamknąć okno.
Kolumna Data produkcji zostanie podzielona na trzy kolumny: Data produkcji.1, Data
produkcji.2 i Data produkcji.3. W wierszu z kodem kraju PL kolumna Data produkcji.1
zawiera numer dnia, a kolumna Data produkcji.2 numer miesiąca. Natomiast w wierszu
z kodem kraju US numer miesiąca jest w kolumnie Data produkcji.1, a numer dnia w Data
produkcji.2. W kolejnym kroku dowiesz się, jak utworzyć kolumnę zawierającą poprawną
datę, wykorzystując język M i kolumnę warunkową. Następnie w krokach od 6. do 10.
poznasz inny sposób osiągnięcia tego celu, w którym nie jest wykorzystywany język M,
ale trzeba wykonać dodatkowe operacje.
4. W karcie Dodaj kolumnę kliknij ikonę Kolumna niestandardowa. Pojawi się okno o tej
samej nazwie.
a. W polu Nazwa nowej kolumny wpisz Data.
b. W polu Formuła kolumny niestandardowej wpisz następujący kod:
if [Kraj] = "US" then

#date([Data produkcji.3], [Data produkcji.1], [Data produkcji.2])
else
#date([Data produkcji.3], [Data produkcji.2], [Data produkcji.1])
Kliknij OK, aby zamknąć okno.
c. Zmień typ danych w kolumnie Data na Data.
d. Usuń kolumny Data produkcji.1, Data produkcji.2 i Data produkcji.3.
Uwaga. W krokach od 6. do 10. poznasz inny sposób tworzenia dat. Wcześniej jednak utwórz
duplikat bieżącego zapytania, aby zachować obie wersje.
5. Aby utworzyć duplikat zapytania, kliknij w panelu zapytania prawym przyciskiem myszy
Produkty i z podręcznego menu wybierz polecenie Duplikuj. Pojawi się nowe zapytanie
Produkty (2). Zaznacz je, a następnie w panelu Zastosowane kroki usuń trzy ostatnie kroki
(włącznie z Dodano kolumnę niestandardową).
6. Naciśnij klawisz Ctrl i zaznacz trzy kolumny w następującej kolejności: Data produkcji.2,
Data produkcji.1 i Data produkcji.3. Następnie w karcie Dodaj kolumnę kliknij ikonę Scal
kolumny. Pojawi się okno o tej samej nazwie.
a. W rozwijanej liście Separator wybierz --Niestandardowe--, a w polu poniżej wpisz
ukośnik (/).
b. W polu Nowa nazwa kolumny (opcjonalnie) wpisz Data (US). Kliknij OK, aby zamknąć
okno.
72
4650570396d9eb2765da56c12eb840b5
4
7. Utwórz kolumnę zawierającą datę z polskimi ustawieniami regionalnymi. W tym celu

naciśnij klawisz Ctrl i zaznacz trzy kolumny w następującej kolejności: Data produkcji.1,
Data produkcji.2 i Data produkcji.3. Następnie w karcie Dodaj kolumnę kliknij ikonę
Scal kolumny. Pojawi się okno o tej samej nazwie.
a. W rozwijanej liście Separator wybierz --Niestandardowe--, a w polu poniżej wpisz
ukośnik (/).
b. W polu Nowa nazwa kolumny (opcjonalnie) wpisz Data (PL). Kliknij OK, aby zamknąć
okno.
Utworzyłeś kolumny Data (US) i Data (PL) zawierające daty zapisane w różnych formatach.
Teraz określ, która z nich ma być wybrana.
8. W kolumnie Dodaj kolumnę kliknij ikonę Kolumna warunkowa. Pojawi się okno Dodawanie
kolumny warunkowej. Wykonaj poniższe kroki, aby wybrać ustawienia, takie jak na rysunku 2.13.
RYSUNEK 2.13. Aby wybrać poprawną datę w zależności od ustawień regionalnych, można wykorzystać
kolumnę warunkową
a. W polu Nowa nazwa kolumny wpisz Data.

b. W rozwijanej liście Nazwa kolumny wybierz Kraj.
c. W rozwijanej liście Operator wybierz równa się, a w polu Wartość wpisz US.
d. W rozwijanej liście ABC123 poniżej Wartość wyjściowa wskaż Wybierz kolumnę,
a w liście obok wybierz Data (US).
e. W rozwijanej liście ABC123 poniżej W przeciwnym razie wskaż Wybierz kolumnę,
a w liście obok wybierz Data (PL).
f. Sprawdź, czy ustawienia są takie jak na rysunku 2.13 i kliknij OK, aby zamknąć okno.
9. Zmień typ kolumny Data na Data.
10. Usuń kolumny Data produkcji.1, Data produkcji.2, Data produkcji.3, Data (US) i Data (PL).
11. Załaduj zapytanie do skoroszytu Excela lub raportu Power BI Desktop. Data będzie pokazywana
zgodnie z ustawieniami regionalnymi w systemie Windows i nie będą pojawiały się błędy.
Gotowe rozwiązanie zapisane jest w plikach R02-06 - rozwiązanie.xlsx i R02-06 - rozwiązanie.pbix.
73
4650570396d9eb2765da56c12eb840b5
4
Wyodrębnianie elementów daty i czasu

Teraz potrafisz już definiować kolumny typu Data oraz Data/godzina o spójnym formacie. W jaki
sposób można wyodrębniać z nich potrzebne fragmenty? Edytor Power Query oferuje w kartach
Przekształć i Dodaj kolumnę szerokie spektrum funkcji i przekształceń umożliwiających
wyodrębnianie roku, kwartału, miesiąca, dnia i wielu innych elementów oraz pozwalających
na wzbogacanie raportów o dane czasowe.
Poniżej opisanych zostało kilka przydatnych przekształceń dostępnych w kartach Przekształć
i Dodaj kolumnę w rozwijanym menu Data.
 Wiek: wylicza czas, jaki upłynął od określonej daty. Przekształcenie polega na wyliczeniu
różnicy pomiędzy bieżącą a wskazaną datą i godziną.
 Tylko data: wyodrębnia datę z kolumny typu Data/godzina. Przekształcenie to w połączeniu
z Tylko godzina umożliwia podzielenie kolumny na dwie nowe typu Data i Godzina,
dzięki czemu model danych jest prostszy, a raport mniejszy i zajmuje mniej pamięci.
 Rok: wyodrębnia rok z kolumny typu Data lub Data/godzina.
 Początek roku/Koniec roku: wyodrębnia odpowiednio pierwszy lub ostatni dzień roku jako
wartość typu Data.
 Miesiąc: wyodrębnia miesiąc z kolumny typu Data lub Data/godzina.
 Początek miesiąca/Koniec miesiąca: wyodrębnia odpowiednio pierwszy lub ostatni dzień
miesiąca jako wartość typu Data.
 Dni w miesiącu: zwraca liczbę dni miesiąca w kolumnie typu Data.
 Nazwa miesiąca: zwraca nazwę miesiąca.
 Kwartał roku: zwraca numer kwartału bieżącego roku.
 Początek kwartału/Koniec kwartału: wyodrębnia odpowiednio pierwszy lub ostatni dzień
kwartału jako wartość typu Data.
 Tydzień roku/Tydzień miesiąca: zwraca odpowiednio numer tygodnia roku lub miesiąca.
 Początek tygodnia/Koniec tygodnia: wyodrębnia odpowiednio pierwszy lub ostatni dzień
tygodnia jako wartość typu Data.
 Dzień: wyodrębnia dzień z kolumny typu Data lub Data/godzina.
 Dzień tygodnia/Dzień roku: zwraca odpowiednio numer dnia tygodnia lub roku.
 Początek dnia/Koniec dnia: wyodrębnia odpowiednio pierwszą lub ostatnią datę i godzinę
z kolumny typu Data lub Data/godzina.
 Nazwa dnia: zwraca nazwę dnia tygodnia (poniedziałek, wtorek itd.).
Jeżeli zaznaczysz kilka kolumn typu Data lub Data/godzina, możesz zastosować przekształcenie
Odejmij dni wyliczające różnicę pomiędzy dwiema datami albo przekształcenie zwracające
najwcześniejszą lub najpóźniejszą datę.
74
4650570396d9eb2765da56c12eb840b5
4
Przygotowanie modelu
Kluczem do sukcesu są dobrze przygotowane dane. Przygotowując materiał do efektywnej analizy,
często trzeba dzielić dane na tabelę faktów lub transakcji (np. Zamówienia) oraz kilka tabel
dodatkowych (np. Produkty, Klienci itp.).
W części III ćwiczenia 2.2 dowiedziałeś się, jak utworzyć relacje pomiędzy tabelą faktów a tabelami
wyszukiwania. Modelowanie danych za pomocą Power Pivot i Power BI nie jest wprawdzie treścią
tej książki, ale za to jest nią przygotowywanie tabel spełniających potrzeby analityka. W kolejnych
trzech rozdziałach nauczysz się łączyć tabele, aby upraszczać model danych. W rozdziale 6.,
„Rozdzielanie tabel”, dowiesz się, jak dzielić tabele o skomplikowanych strukturach na kilka
prostszych, łatwiejszych do analizy.
W tym podrozdziale poznasz kilka fundamentalnych operacji umożliwiających dzielenie
zagregowanej tabeli na kilka mniejszych, tworzenie struktur gwiaździstych oraz kontrolowanie
rozmieszczania danych.
Ćwiczenie 2.7. Dzielenie danych na tabelę faktów

i tabelę wyszukiwania
W tym ćwiczeniu zaimportujesz dane z bazy innej fikcyjnej firmy o nazwie Światowi Importerzy
(Wide World Importers). Baza ta, bogatsza i nowsza od bazy Fabryki Przygód, również jest
oferowana przez Microsoft do celów szkoleniowych. Aby dowiedzieć się więcej na ten temat,
odwiedź stronę https://blogs.technet.microsoft.com/dataplatforminsider/2016/06/09/
wideworldimporters-the-new-sql-server-sample-database.
Plik R02-07.xlsx zawiera informacje o zamówieniach firmy. Celem tego ćwiczenia jest pokazanie,
jak łatwo za pomocą funkcjonalności Odwołanie i Usuń duplikaty można dzielić dane na tabelę
faktów i tabelę wyszukiwania.
1. Utwórz nowy skoroszyt w Excelu lub nowy raport w Power BI Desktop, a następnie
zaimportuj do edytora plik R02-07.xlsx.
2. W oknie Nawigator kliknij tabelę Zamówienia, a następnie przycisk Przekształć dane.
3. Zmień nazwę zapytania Zamówienia na Zamówienia - baza.
Celem ćwiczenia jest podzielenie oryginalnej tabeli na dwie nowe tabele zawierające
odpowiednio szczegółowe dane (patrz rysunek 2.14). Pierwsza tabela (po lewej stronie
rysunku) będzie zawierać dane zamówień (tabela faktów), a druga (po prawej stronie
rysunku) dane produktów (tabela wyszukiwania).
4. Kliknij prawym przyciskiem myszy zapytanie Zamówienia - baza i wybierz polecenie
Odwołanie. Zmień nazwę nowego zapytania na Produkty (w tym celu kliknij je prawym
przyciskiem myszy i z podręcznego menu wybierz polecenie Zmień nazwę albo w panelu
Ustawienia zapytania wpisz nową nazwę w polu Nazwa).
5. Kliknij zapytanie Produkty, a następnie w karcie Strona główna kliknij Wybieranie kolumn.
6. W oknie, które się pojawi, usuń wszystkie zaznaczenia, a następnie zaznacz kolumny
Kod produktu, Nazwa produktu i Czas dostawy. Kliknij OK, aby zamknąć okno.
75
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 2.14. Tabelę Zamówienia możesz podzielić na tabelę faktów i tabelę wyszukiwania
7. Kliknij kolumnę Kod produktu, a następnie w karcie Strona główna kliknij ikonę
Usuń wiersze i Usuń duplikaty.
Utworzyłeś w ten sposób tabelę wyszukiwania zawierającą unikatowe wiersze z danymi
produktów.
Uwaga. Jeżeli w kolumnie Kod produktu będą powtarzały się kody, nie będziesz mógł utworzyć
relacji w kroku 12. W tym przypadku celowo zostały pominięte dwa ważne kroki. Są one opisane
na końcu ćwiczenia. Jeżeli ich nie wykonasz, wtedy polecenie Usuń duplikaty nie da pewności,
że kolumna Kod produktu będzie zawierała unikatowe wartości, przez co mogą pojawić się
problemy z odświeżaniem danych.
8. Aby utworzyć tabelę faktów, kliknij w panelu zapytania prawym przyciskiem myszy
zapytanie Zamówienia - baza i wybierz polecenie Odwołanie.
9. Zmień nazwę nowego zapytania na Zamówienia (w tym celu kliknij je prawym przyciskiem
myszy i z podręcznego menu wybierz polecenie Zmień nazwę albo w panelu Ustawienia
zapytania wpisz nową nazwę w polu Nazwa).
10. Kliknij zapytanie Zamówienia, a następnie w karcie Strona główna kliknij Wybieranie
kolumn. W oknie, które się pojawi, usuń zaznaczenia Nazwa produktu i Czas dostawy.
11. W Excelu: w karcie Strona główna kliknij ikonę Zamknij i załaduj, aby zapobiec załadowaniu
głównego zapytania do modelu danych. Następnie w panelu Zapytania i połączenia załaduj
zapytania Produkty i Zamówienia w sposób opisany w części II ćwiczenia 2.2, w kroku 11.
W Power BI Desktop: zablokuj ładowanie zapytania Zamówienia - baza w sposób opisany
w części II ćwiczenia 2.2, w kroku 11.
12. Utwórz relację pomiędzy obiema tabelami, wykorzystując kolumnę Kod produktu.
76
4650570396d9eb2765da56c12eb840b5
4
Jeżeli nie uda się utworzyć relacji

Podczas tworzenia tabeli wyszukiwania, tak jak w ćwiczeniu 2.7, i relacji opartych na polach
tekstowych trzeba przed usunięciem duplikatów wykonać dwa dodatkowe kroki, aby można było
poprawnie odświeżać raport.
W ćwiczeniu 2.7, w kroku 8. usunąłeś duplikaty z kolumny Kod produktu z tabeli wyszukiwania.
Niestety, edytor Power Query jest zaprojektowany inaczej niż model danych w Excelu i Power BI.
Power Query rozróżnia wielkość liter, w przeciwieństwie do modelu danych. Zatem gdyby w kolumnie
Kod produktu oprócz kodu np. „Prod_1” znajdował się kod zapisany małymi lub wielkimi literami
(np. „PROD_1”) albo na końcu znajdowała się spacja (np. „Prod_1 ”), wtedy Power Query potraktowałby
oba kody jak różne kody. Natomiast dla modelu danych byłyby to takie same kody i pojawiłby się
następujący komunikat:
Kolumna „Kod produktu” w tabeli „Produkty” zawiera zduplikowaną wartość „PROD_1”, co nie jest
dozwolone w przypadku kolumn po jednej stronie relacji „jeden do jednego” lub kolumn używanych
jako klucz podstawowy tabeli.
Aby wyświetlić powyższy komunikat, otwórz plik R02-07.xlsx i zmień dwie wartości w kolumnie
Kod produktu. W pierwszej zamień wszystkie litery na wielkie, a w drugiej na końcu dodaj spację.
Zapisz skoroszyt, a następnie odśwież dane w skoroszycie R02-07 - rozwiązanie.xlsx lub w raporcie
R02-07 - rozwiązanie.pbix.
W celu rozwiązania tego problemu wykonaj na zapytaniu Zamówienia - baza następujące
operacje.
1. Otwórz edytor Power Query i zaznacz zapytanie Zamówienia - baza.
2. Zaznacz kolumnę Kod produktu, a następnie w karcie Przekształć kliknij ikonę Format
i jedno z poleceń: Małe litery, Wielkie litery lub Zamień pierwszą literę każdego wyrazu
na wielką. Każde z nich spowoduje, że wartości zostaną ujednolicone i edytor Power Query
usunie powstałe w ten sposób duplikaty.
3. Zaznacz kolumnę Kod produktu, a następnie w karcie Przekształć kliknij ikonę Format
i polecenie Przycięcie.
4. Odśwież skoroszyt lub raport. Komunikat nie powinien się już pojawić.
Tworzenie odwołań i usuwanie duplikatów to operacje często wykonywane w czasie tworzenia
tabel wyszukiwania. Podczas usuwania duplikatów często się zapomina, że w przypadku wartości
zapisanych małymi i wielkimi literami lub zawierających końcowe spacje odświeżanie raportu może
zakończyć się błędem. Błędy mogą ujawniać się już wcześniej, podczas tworzenia relacji. Remedium
na tego rodzaju problemy jest zmiana przed usunięciem duplikatów wielkości liter i przycięcie
końcowych spacji.
Gotowe rozwiązanie tego ćwiczenia jest zapisane w plikach R02-07 - rozwiązanie.xlsx
i R02-07 - rozwiązanie.pbix.
Zobacz też. Problem z wykonaniem powyższych kroków, uniemożliwiający odświeżanie raportów,

opisałem na swoim blogu pod adresem https://datachant.com/2017/02/14/power-bi-pitfall-10.
W rozdziale 10., „Od złych do dobrych zapytań”, poznasz więcej często spotykanych pułapek
i błędów uniemożliwiających tworzenie raportów.
77
4650570396d9eb2765da56c12eb840b5
4
Ćwiczenie 2.8. Zamiana wartości oddzielonych ogranicznikami

na wiersze
W poprzednim ćwiczeniu dowiedziałeś się, jak dzielić dane na tabelę faktów i tabelę wyszukiwania.
Teraz poznasz szczególny przypadek tej operacji. Wyobraź sobie, że tabela faktów służy do
kojarzenia grup i ich członków za pomocą identyfikatorów. Tabela wyszukiwania w takiej sytuacji
zawiera dane grup.
W tym ćwiczeniu ponownie wykorzystasz katalog produktów Fabryki Przygód. Każdy produkt
jest dostępny w jednym lub kilku kolorach. Kolory są oddzielone przecinkami, tak jak w tabeli
po lewej stronie rysunku 2.15. Dowiesz się teraz, jak podzielić produkty na dwie tabele: jedną
zawierającą dane jednostek (w tym przypadku produktów bez informacji o kolorach) i drugą
zawierającą powiązania pomiędzy grupami i członkami grup (tutaj kodów kolorów i ich nazw).
RYSUNEK 2.15. Kolumnę Kolory możesz podzielić, aby określić, w ilu kolorach są oferowane poszczególne produkty
Plik R02-08.xlsx, wykorzystany w tym ćwiczeniu, zawiera takie informacje o produktach jak kod,
średni koszt, średnia cena i dostępne kolory. Aby utworzyć raport z liczbami produktów
w poszczególnych kolorach, wykonaj poniższe kroki.
1. Utwórz nowy skoroszyt w Excelu lub nowy raport w Power BI Desktop, a następnie
zaimportuj do edytora plik R02-08.xlsx.
2. W oknie Nawigator kliknij tabelę Produkty, a następnie przycisk Przekształć dane.
3. W oknie Nawigator kliknij zapytanie Produkty i wybierz polecenie Odwołanie. Celem jest
utworzenie tabeli wiążącej kody produktów z ich kolorami.
4. Zmień nazwę nowego zapytania na Produkty i kolory (w tym celu kliknij je prawym
przyciskiem myszy i z podręcznego menu wybierz polecenie Zmień nazwę albo w panelu
Ustawienia zapytania wpisz nową nazwę w polu Nazwa).
5. Kliknij nowe zapytanie, a następnie w karcie Strona główna kliknij Wybieranie kolumn.
6. W oknie, które się pojawi, usuń wszystkie zaznaczenia, a następnie zaznacz kolumny
Kod produktu i Kolory. Kliknij OK, aby zamknąć okno.
78
4650570396d9eb2765da56c12eb840b5
4
7. Zaznacz kolumnę Kolory, a następnie w karcie Przekształć kliknij ikonę Podziel kolumny
i wybierz polecenie Według ogranicznika.
8. Zwróć uwagę, że w oknie, które się pojawi, domyślnie wybrany jest przecinek jako
ogranicznik i zaznaczona opcja Każde wystąpienie ogranicznika (patrz rysunek 2.16).
Rozwiń sekcję Opcje zaawansowane i zaznacz opcję Wiersze. Kliknij OK, aby zamknąć okno.
RYSUNEK 2.16. Nie zapomnij w oknie „Dzielenie kolumny według ogranicznika” wybrać w sekcji
„Opcje zaawansowane” opcji Wiersze
9. W zapytaniu Produkty i kolory zaznacz kolumnę Kolory. Następnie w karcie Przekształć

kliknij ikonę Format i polecenie Przycięcie. W ten sposób usuniesz spacje przed nazwami
kolorów.
Teraz możesz załadować obie tabele do skoroszytu w Excelu lub raportu w Power BI Desktop
i utworzyć relację pomiędzy tabelami Produkty i Produkty i kolory opartą na kolumnie Kod produktu.
Gotowe rozwiązanie jest zapisane w plikach R02-08 - rozwiązanie.xlsx i R02-08 - rozwiązanie.pbix.
Wskazówka. Aby zmniejszyć plik z raportem, możesz z tabeli Produkty usunąć kolumnę Kolory.
W takim przypadku jednak, jeżeli odtworzysz wszystkie operacje, pojawi się błąd, ponieważ do
tabeli Produkty odwołuje się tabela Produkty i kolory. Musisz zatem utworzyć nowe odwołanie
do tabeli Produkty i usunąć z nowego zapytania kolumnę Kolory. Oryginalne zapytanie Produkty
będzie wtedy jedynie pełniło rolę bazy i nie trzeba go będzie ładować do modelu danych ani
do raportu. (W części II ćwiczenia 2.2 napisano, jak wyłączyć ładowanie danych).
79
4650570396d9eb2765da56c12eb840b5
4
Podsumowanie
Przygotowywanie danych może być czynnością wyjątkowo czasochłonną. Jednak bogate funkcjonalności
edytora Power Query sprawiają, że można dane łatwo oczyszczać i przygotowywać do analizy. W tym
rozdziale poznałeś najczęściej spotykane problemy i sposoby ich rozwiązania za pomocą edytora
Power Query.
W ćwiczeniu 2.2 dowiedziałeś się, jak można wyodrębniać kody kolorów i nadawać im
znaczenie bez konieczności stosowania skomplikowanych formuł użytych w ćwiczeniu 2.1.
W ćwiczeniu 2.3 poznałeś bardzo przydatną funkcjonalność wyodrębniania informacji
z kolumny na podstawie przykładów. Polecenie Kolumna z przykładów pozwala wyodrębniać
z danych teksty, daty, godziny i liczby, jak również oferuje wiele różnych przekształceń
wykorzystujących wprowadzane przykłady. Jak się przekonałeś, można w ten sposób wyodrębniać
teksty rozdzielone ogranicznikami, tworzyć kolumny warunkowe i definiować zakresy wartości.
W ćwiczeniu 2.4 nauczyłeś się wyodrębnić odnośniki z tekstu bez określonej struktury i stosować
różne przekształcenia. Z tego ćwiczenia płynie bardzo ważny wniosek, że trzeba jak najczęściej
sprawdzać wyniki zapytań i wyszukiwać przypadki szczególne.
Często wykonywaną i czasochłonną operacją jest przetwarzanie dat zapisanych w różnych
formatach. W ćwiczeniach 2.5 i 2.6 przekonałeś się, jak łatwo się to robi za pomocą Power Query.
Na koniec, w ćwiczeniach 2.7 i 2.8 dowiedziałeś się, jak z pomocą przekształceń Odwołanie
i Usuń duplikaty dzielić dane na tabele faktów i tabele wyszukiwania. Nauczyłeś się również, jak
przy użyciu przekształceń Małe litery i Przycinanie można zapobiegać problemom z odświeżaniem
raportów oraz jak zamieniać wartości oddzielone przecinkami na wiersze i tworzyć tabele grup
i członków.
Choć wciąż znajdujesz się na początku książki, to wykorzystując zdobytą do tej pory wiedzę, już
teraz możesz skrócisz czas oczyszczania danych o wiele godzin. W następnym rozdziale dowiesz się,
jak można łączyć kilka tabel i jeszcze szybciej przygotowywać raporty.
80
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 3.
Łączenie danych z kilku źródeł
Próba połączenia mądrości i potęgi rzadko się udaje i tylko na krótką chwilę.
— Albert Einstein

 łączyć tabele pochodzące z różnych źródeł,
 łączyć skoroszyty Excela zapisane w jednym folderze,
 łączyć arkusze zawarte w skoroszycie Excela.
Albert Einstein miał rację, mówiąc, że rzadko udaje się połączyć mądrość z potęgą, ale Power Query
oferuje potęgę pozwalającą zdobyć trwałą mądrość. W tym rozdziale dowiesz się, jak łączyć tabele
o odmiennych stopniach złożoności i tworzyć raporty wykorzystujące różne dane.
W rozdziale 2., „Podstawowe operacje przygotowywania danych”, opisane zostały przypadki
przetwarzania nieprzygotowanych, źle sformatowanych danych. Często jednak zdarza się, że dane są
właściwie sformatowane, ale znajdują się w różnych źródłach. Wtedy największym wyzwaniem jest
połączenie ich i utworzenie jednego źródła wiedzy. Treścią tego rozdziału jest łączenie wielu tabel.
Na początku opisane zostały podstawowe przypadki łączenia niewielkiej liczby tabel zapisanych
w jednym formacie. Dalej w rozdziale przedstawiono bardziej skomplikowane, z życia wzięte
sytuacje, w których źródła danych nieustannie się zmieniają.
Łączenie kliku tabel

Jedną z najczęściej wykorzystywanych funkcjonalności Power Query jest Dołącz zapytania dostępna
w karcie Strona główna. Z jej pomocą można łączyć określony zestaw tabel. Na początku tego
podrozdziału opisane jest łączenie dwóch tabel o takich samych formatach (tj. zawierających
kolumny o takich samych nazwach).
4650570396d9eb2765da56c12eb840b5
4
Łączenie dwóch tabel

Zanim zajmiemy się szczegółami łączenia dwóch tabel, przeanalizujmy powody, dla których dane
wykorzystywane do analizy łączy się w jedną tabelę zamiast trzymać je w dwóch osobnych. Dlaczego
nie wystarczy po prostu skopiować i wkleić obu tabel do osobnych arkuszy Excela, aby w trzecim
wykonać niezbędne wyliczenia? Takie podejście jest proste w przypadku tabel złożonych z kilku wierszy
i kolumn, ale jeżeli tabele są duże i często się zmieniają, wtedy sytuacja wygląda zupełnie inaczej.
Oto, jak można sprostać temu wyzwaniu za pomocą Excela bez użycia Power Query. Trzeba
ręcznie skopiować i wkleić tabele i w ten sposób połączyć w jedną. Za każdym razem, gdy dane się
zmienią, trzeba tę operację wykonywać ponownie. Ewentualnie można napisać skomplikowaną
formułę łączącą zakresy komórek z obu tabel. Jednak za każdym razem, gdy zmieni się wielkość
tabel, trzeba będzie modyfikować ich zakresy w formule. Na szczęście, jest narzędzie Power Query,
które pozwala zautomatyzować ten skomplikowany proces. Przy jego użyciu wystarczy jedynie
odświeżyć raport, gdy w tabelach pojawią się nowe dane.
Ćwiczenie 3.1. Rowery i akcesoria

W tym ćwiczeniu wykorzystane są dwie tabele danych fikcyjnej firmy Fabryka Przygód, opisanej
w rozdziale 2. Aby przykład ten odzwierciedlał realia biznesowe, wyobraźmy sobie, że firma ta, której
główną działalnością jest produkowanie rowerów, przejęła inną firmę produkującą akcesoria i w ten
sposób wzbogaciła asortyment oferowanych produktów. Ty jesteś szefem działu analiz i dostałeś
zadanie przygotowania jednolitego raportu obejmującego produkty obu firm (patrz rysunek 3.1).
RYSUNEK 3.1. Twoje zadanie polega na połączeniu tabel Rowery i Akcesoria w jedną o nazwie Produkty

W Excelu: kliknij kartę Dane, a następnie polecenia Pobierz dane/Z pliku/Ze skoroszytu.
W Power BI Desktop: rozwiń menu Pobierz dane i wybierz Excel.
2. Odszukaj plik R03-01 - rowery.xlsx i kliknij Importuj.
3. W oknie Nawigator zaznacz tabelę Rowery kliknij przycisk Przekształć dane.
4. Jeżeli używasz Excela, kliknij Zamknij i załaduj do, jeżeli Power BI Desktop
— Zamknij i zastosuj i pomiń krok 5.
5. W oknie Importowanie danych zaznacz opcję Tabela i kliknij OK. W ten sposób załadujesz
do arkusza lub raportu Power BI Desktop wszystkie dane o rowerach. Za każdym razem,
gdy dane się zmienią i pojawią się nowe rowery, wystarczy, że w Excelu na karcie Dane
klikniesz Odśwież wszystko lub naciśniesz klawisze Ctrl+Alt+F5. Jeżeli używasz Power BI
Desktop, kliknij po prostu w karcie Strona główna ikonę Odśwież.
82
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 3..  ŁĄCZENIE DANYCH Z KILKU ŹRÓDEŁ
Teraz pora zaimportować do skoroszytu lub raportu tabelę Akcesoria.

6. W Excelu: kliknij kartę Dane, a następnie polecenia Pobierz dane, Z pliku, Ze skoroszytu.
7. Zaznacz plik R03-01 - akcesoria.xlsx i kliknij Importuj.
8. W oknie Nawigator zaznacz tabelę Akcesoria i kliknij przycisk Przekształć dane.
9. Aby połączyć tabele Rowery i Akcesoria, zaznacz zapytanie Akcesoria, a następnie w karcie
Strona główna kliknij ikonę Dołącz zapytania. Zwróć uwagę, że ikonę tę można rozwinąć
i że w menu znajduje się polecenie Dołącz zapytania jako nowe, które zostanie opisane
w ćwiczeniu 3.2.
10. W oknie Dołączanie w liście Tabela do dołączenia wybierz Rowery, a następnie kliknij OK.
11. Zwróć uwagę, że w panelu Zapytania znajdują się zapytania Rowery i Akcesoria. Ponieważ
przed chwilą dołączyłeś zapytanie Rowery do Akcesoria, więc nazwa tego drugiego nie
opisuje dokładnie jego zawartości. Dlatego powinieneś zmienić nazwę i załadować je, a nie
Rowery, do skoroszytu w Excelu lub raportu w Power BI Desktop. Kliknij więc prawym
przyciskiem myszy zapytanie Akcesoria, wybierz polecenie Zmień nazwę i wpisz Produkty.
Nazwę możesz również zmienić w panelu Ustawienia zapytania w polu Nazwa.
12. Wykonaj poniższe kroki, aby wyładować tabelę Rowery.
Excel
a. Kliknij ikonę Zamknij i załaduj do.
b. W oknie Importowanie danych zaznacz opcję Tabela i kliknij OK.
c. Aby wyładować tabelę Rowery, w panelu Zapytania i połączenia kliknij prawym
przyciskiem myszy zapytanie Rowery i wybierz polecenie Załaduj do.
d. W oknie Importowanie danych zaznacz opcję Utwórz tylko połączenie i kliknij OK.
e. W oknie Możliwa utrata danych, które się pojawi, kliknij OK, aby wyładować zapytanie
i usunąć tabelę.
f. Na koniec usuń Arkusz2 zawierający załadowaną pierwotnie tabelę Rowery, a nazwę
ostatniego arkusza zmień na Produkty.
Power BI Desktop
W panelu Zapytania kliknij prawym przyciskiem myszy zapytanie Rowery, usuń zaznaczenie
opcji Włącz ładowanie i kliknij Zamknij i zastosuj.
W ten sposób utworzyłeś połączoną tabelę Produkty zawierającą dane z tabel Rowery i Akcesoria.
Jeżeli jednak przyjrzysz się bliżej panelowi Zapytania, zauważysz asymetrię w ostatnim kroku.
Widoczne są w nim zapytania Rowery i Produkty, ale gdzie jest zapytanie Akcesoria? Jak pamiętasz,
zaraz po zaimportowaniu tabeli Akcesoria dołączyłeś do niej Rowery i zmieniłeś nazwę na Produkty.
Jeżeli w przyszłości wprowadzisz zmiany w tabeli Akcesoria, trudno będzie zmodyfikować przekształcenie,
ponieważ w jednym kroku dołączyłeś tabelę i zmieniłeś nazwę zapytania. Lepszym rozwiązaniem
byłoby zapisanie akcesoriów w osobnym zapytaniu. Dlatego przekształcenie Dołącz zapytania ma
bliźniaczą odmianę Dołącz zapytania jako nowe.
83
4650570396d9eb2765da56c12eb840b5
4
Ćwiczenie 3.2. Część I. Przekształcenie „Dołącz zapytania jako nowe”

W karcie Strona główna edytora Power Query znajdują się dwa przekształcenia — Dołącz zapytania
i Dołącz zapytania jako nowe (patrz rysunek 3.2).
RYSUNEK 3.2. Przekształcenie „Dołącz zapytania jako nowe” pozwala tworzyć nowe zapytania zawierające
połączone tabele lub ich części
W poprzednim ćwiczeniu połączyłeś dwie tabele, wykorzystując przekształcenie Dołącz zapytania,

które dołącza nowe zapytanie do bieżącego. Natomiast przekształcenie Dołącz zapytania jako nowe
tworzy trzecie zapytanie i wtedy dwa pierwsze nie ulegają zmianom.
W tym ćwiczeniu nie zmienisz zawartości tabeli Akcesoria. Zamiast tego umieścisz ją w osobnym
zapytaniu i utworzysz nowe, zawierające wszystkie produkty.
1. Wykonaj kroki od 1. do 8. z ćwiczenia 3.1, aby załadować do edytora Power Query tabele
Rowery i Akcesoria.
2. Zaznacz zapytanie Akcesoria, a następnie w karcie Strona główna rozwiń ikonę Dołącz
zapytania i wybierz polecenie Dołącz zapytania jako nowe.
3. W oknie Dołączanie w liście Tabela do dołączenia do tabeli podstawowej wybierz Rowery
i kliknij OK. Utworzysz nowe zapytanie Append1 zawierające połączone dane z tabel
Rowery i Akcesoria.
4. Zmień nazwę nowego zapytania na Produkty i wykonaj krok 12. z ćwiczenia 3.1, aby
wyładować tabelę Rowery. W celu wyładowania tabeli Akcesoria wykonaj ponownie krok 12.,
ale w odniesieniu do zapytania Akcesoria, a nie Rowery.
5. Zapisz skoroszyt lub raport. Teraz poznasz inną metodę łączenia tabel Rowery i Akcesoria
w jedno zapytanie, wykorzystującą polecenie Odwołanie. Porównasz też utworzone w obu
przypadkach wyrażenia M.
Wskazówka. Jeżeli dołączane tabele są małe, zalecane jest stosowanie przekształcenia Dołącz
zapytania jako nowe zamiast Dołącz zapytania. Dzięki temu później można łatwo zmieniać
składniki wynikowego zapytania.
Ćwiczenie 3.2. Część II. Zależności między zapytaniami i odwołania

W części I ćwiczenia 3.2 zastosowałeś przekształcenie Dołącz zapytania jako nowe, które utworzyło
nowe zapytanie zawierające połączone zapytania Rowery i Akcesoria. Nowe zapytanie odwołuje się
do pozostałych dwóch. Ich wyjścia stanowią wejście do nowego zapytania. Gdy jedno zapytanie
odwołuje się do innego, powstaje pomiędzy nimi zależność. Zapytań powiązanych zależnościami
nie można usunąć. (Przykładowo przy próbie usunięcia zapytania Rowery pojawi się komunikat,
że odwołuje się do niego zapytanie Produkty i nie można go usunąć).
84
4650570396d9eb2765da56c12eb840b5
4
Aby zobaczyć zależności pomiędzy zapytaniami, otwórz utworzony w części I skoroszyt lub
raport i uruchom edytor Power Query. Następnie w kolumnie Widok kliknij ikonę Zależności
zapytań. Pojawi się okno o tej samej nazwie, pokazane na rysunku 3.3.
RYSUNEK 3.3. Okno przedstawiające odwołania i zależności pomiędzy zapytaniami w raporcie
W oknie widoczny jest diagram przepływów, które rozpoczynają się od plików zawierających
katalogi rowerów i akcesoriów, następnie przechodzą przez zapytania Rowery i Akcesoria i kończą się
na zapytaniu Produkty zawierającym połączone tabele. Diagram ten przydaje się w skomplikowanych
operacjach przygotowywania danych.
Teraz, gdy wiesz już, jak wyświetlać zależności pomiędzy zapytaniami, omówię odwołania
umożliwiające tworzenie zaawansowanych, uniwersalnych przekształceń; z ich pomocą będziesz
mógł się mierzyć z rzeczywistymi wyzwaniami. Odwołania można użyć do utworzenia nowego
zapytania, którego źródło, czyli dane wejściowe, jest wynikiem innego zapytania.
W części I ćwiczenia 3.2 załadowałeś tabele Rowery i Akcesoria jako zapytania i przy użyciu
przekształcenia Dołącz zapytania jako nowe utworzyłeś nowe zapytanie zawierające połączone
dane. Inną metodą uzyskania tego samego efektu jest zastosowanie kombinacji przekształceń
Dołącz zapytania i Odwołanie.
1. Wykonaj kroki od 1. do 8. z ćwiczenia 3.1, aby załadować do edytora Power Query tabele
Rowery i Akcesoria.
2. W panelu Zapytania kliknij prawym przyciskiem myszy zapytanie Akcesoria i wybierz
polecenie Odwołanie. Zwróć uwagę, że pojawiło się nowe zapytanie Akcesoria (2) oparte
na wyniku zapytania Akcesoria.
85
4650570396d9eb2765da56c12eb840b5
4
3. Zmień nazwę nowego zapytania na Produkty.

4. Zaznacz zapytanie Produkty, w karcie Strona główna kliknij ikonę Dołącz zapytania. W oknie
Dołączanie wybierz w liście Tabela do dołączenia zapytanie Rowery i kliknij OK.
Możesz sprawdzić, jak w języku M zapisywane są przekształcenia Odwołanie i Dołącz zapytania,
oraz porównać wynik tych przekształceń z wynikiem uzyskanym w części I ćwiczenia 3.2. Teraz
przyjrzyjmy się utworzonemu kodowi M.
Zobacz też. W rozdziale 1., „Wprowadzenie do Power Query”, dowiedziałeś się o kodzie
w języku M, który jest tworzony przez Power Query podczas wykonywania przekształceń.
Każdy krok jest zamieniany na jeden wiersz kodu, który można zobaczyć w pasku formuły.
W karcie Widok zaznacz opcję Pasek formuły, a następnie kliknij w panelu Zastosowane kroki
pozycję Źródło. W pasku formuły pojawi się następujący kod:
= Akcesoria
Kod ten reprezentuje wyjście zapytania Akcesoria, stanowiące wejście dla nowego zapytania.
Jak się domyślasz, kod ten został utworzony w wyniku użycia przekształcenia Odwołanie
z zapytaniem Akcesoria.
W karcie Strona główna kliknij ikonę Edytor zaawansowany. Pojawi się następujące wyrażenie w języku M:
let
Źródło = Akcesoria,
#"Dołączone zapytanie" = Table.Combine({Źródło, Rowery})
in
#"Dołączone zapytanie"
W rozdziale 9., „Wprowadzenie do języka M”, opisałem dokładnie składnię tego języka i wyjaśniłem
znaczenie słów kluczowych let oraz in. Na razie jednak skupmy się na dwóch wierszach znajdujących
się pomiędzy tymi słowami.
W pierwszym z tych dwóch wierszy wynik zapytania Akcesoria jest przypisywany do obiektu
Źródło. (Zauważ, że obiekt ten jest również pierwszym krokiem w panelu Zastosowane kroki).
W drugim wierszu znajduje się funkcja Table.Combine łącząca zapytania Akcesoria i Rowery.
(Zapewne zauważyłeś, że zapytania te są umieszczone w nawiasach klamrowych, których
znaczenie jest opisane w następnym punkcie. Za pomocą takich nawiasów definiuje się listy).
Natomiast kod wygenerowany w części I ćwiczenia 3.2, gdzie wykorzystane było przekształcenie
Dołącz zapytania jako nowe, wygląda tak:
let
Źródło = Table.Combine({Akcesoria, Rowery})
in
Źródło
Jeżeli dokładnie przyjrzysz się obu kodom, zauważysz, że zwracają one ten sam wynik, tj.
połączone zapytania Akcesoria i Rowery.
A zatem kombinacja przekształceń Odwołanie i Dołącz zapytania daje ten sam wynik, co
przekształcenie Dołącz zapytania jako nowe. To drugie powoduje utworzenie krótszego kodu
w tylko jednym kroku, a nie w dwóch, ale w rzeczywistości pomiędzy obydwoma sposobami nie
ma istotnej różnicy. Dlaczego więc zajmujemy się przekształceniem Odwołanie? Jak się przekonasz
w następnych rozdziałach, bardzo się ono przydaje podczas tworzenia ciągów przekształceń lub
odgałęzień tego samego przekształcenia bazowego.
86
4650570396d9eb2765da56c12eb840b5
4
Łączenie trzech lub więcej tabel

Do tej pory w tym rozdziale zajmowaliśmy się łączeniem dwóch tabel. Czas przejść do bardziej
ogólnego przypadku obejmującego łączenie trzech lub więcej tabel. Jednym ze sposobów osiągnięcia
tego celu jest połączenie dwóch tabel, a następnie dołączenie trzeciej do uzyskanego wyniku. Potem
można dołączyć czwartą tabelę itd. Jest to poprawny sposób, ale dość uciążliwy, ponieważ wymaga
tworzenia pośrednich zapytań. Jeżeli trzeba połączyć trzy lub cztery tabele, nakład pracy jest niewielki,
ale przy większej liczbie tabel trzeba zastosować inne podejście.
Ćwiczenie 3.2. Część III. Rowery + Akcesoria + Komponenty

Wróćmy do naszej fikcyjnej firmy. Fabryka Przygód, po pomyślnym przejęciu firmy produkującej
akcesoria rowerowe, postanowiła przejąć kolejną firmę i rozszerzyć swoją ofertę o komponenty.
Twoim zadaniem, jako szefa działu analiz, jest umieszczenie wszystkich produktów w jednej tabeli.
W tym ćwiczeniu wykorzystasz następujące pliki:
 R03-01 - rowery.xlsx,
 R03-01 - akcesoria.xlsx,
 R03-01 - komponenty.xlsx.
Utwórz nowy skoroszyt w Excelu lub raport w Power BI Desktop i zaimportuj powyższe pliki
do edytora Power Query. Każdy z tych plików składa się z jednego arkusza o odpowiedniej nazwie
(plik R03-01 - rowery.xlsx zawiera arkusz Rowery, plik R03-01 - akcesoria.xlsx — arkusz Akcesoria,
a R03-01 - komponenty.xlsx — arkusz Komponenty). Jeżeli nie pamiętasz, jak importuje się skoroszyty,
wróć do ćwiczenia 3.1 i wykonaj kroki importujące Rowery i Akcesoria. W analogiczny sposób
zaimportuj Komponenty.
1. W panelu Zapytania zaznacz zapytanie Komponenty.
2. W karcie Strona główna kliknij ikonę Dołącz zapytania jako nowe.
3. W oknie Dołączanie zaznacz opcję Co najmniej trzy tabele. Pojawią się listy Dostępne tabele
i Tabele do dołączenia, tak jak na rysunku 3.4. W pierwszej będą widoczne zapytania Rowery,
Akcesoria i Komponenty.
4. Dodaj zapytania Rowery i Akcesoria do listy Tabele do dołączenia i kliknij OK.
Utworzyłeś nowe zapytanie Append1 zawierającej wszystkie produkty. Zmień jego nazwę
na Produkty, a następnie wyładuj pośrednie zapytania w sposób opisany w ćwiczeniu 3.1.
Wskazówka. W oknie Dołączanie, pokazanym na rysunku 3.4, możesz zmieniać kolejność

dołączanych tabel, zaznaczając je i klikając przyciski strzałek po prawej stronie listy Tabele
do dołączenia. Możesz nawet jedną tabelę umieszczać w liście wielokrotnie i w ten sposób
duplikować dane.
Teraz, mając połączone zapytania Rowery, Akcesoria i Komponenty, możesz się przekonać, jak
łatwo wykonuje się to samo przekształcenie w pasku formuły. Gdy zaznaczysz zapytanie Produkty,
pojawi się następująca formuła:
= Table.Combine({Komponenty, Rowery, Akcesoria})
87
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 3.4. W oknie Dołączanie po wybraniu opcji Co najmniej trzy tabele można wybierać kilka
zapytań do połączenia
Czy wygląda znajomo? Wcześniej, gdy łączyłeś dwie tabele, formuła wyglądała tak:
= Table.Combine({Akcesoria, Rowery})
Jak widać, do łączenia zapytań służy funkcja Table.Combine, której argumentem jest lista zapytań
zamknięta w nawiasach klamrowych.
Uwaga. W języku M nawiasy klamrowe wykorzystywane są do definiowana list. Elementy listy

oddzielone są przecinkami. W kolejnych rozdziałach poznasz więcej przykładów list, za pomocą
których można tworzyć przydatne przekształcenia, a nawet modyfikować zapytanie podczas
jego wykonywania.
Teraz, gdy wiesz już, jak połączyć trzy tabele, możesz dołączyć do nich czwartą, ale tym razem
zrobisz to wyłącznie za pomocą kodu. Nie zamykaj utworzonego skoroszytu ani raportu, ponieważ
użyjesz go w następnym ćwiczeniu.
Ćwiczenie 3.2.
Część IV. Rowery + Akcesoria + Komponenty + Ubrania
Wróćmy do naszej firmy. Po rozszerzeniu asortymentu produktów prezes zadecydował
o skonsolidowaniu działu produkującego ubrania z głównym oddziałem. Dostałeś czwartą tabelę
zawierającą katalog ubrań. W tej części ćwiczenia dowiesz się, jak połączyć wszystkie cztery tabele,
ale tym razem nie będziesz korzystał z okna Dołączanie, tylko użyjesz języka M.
88
4650570396d9eb2765da56c12eb840b5
4
Otwórz skoroszyt lub raport, który utworzyłeś w części III ćwiczenia 3.2, i zaimportuj do niego
plik R03-02 - ubrania.xlsx. (W ćwiczeniu 3.1 opisane są kroki importowania tabel Rowery i Akcesoria.
W podobny sposób zaimportuj tabelę Ubrania).
Zaznacz zapytanie Produkty i przyjrzyj się paskowi formuły. Znajdziesz w nim następujący kod:
= Table.Combine({Komponenty, Rowery, Akcesoria})
Umieść w dowolnym miejscu listy wewnątrz nawiasów klamrowych zapytanie Ubrania. Upewnij się,
że wszystkie są oddzielone przecinkami. Na koniec naciśnij Enter. Formuła powinna wyglądać tak:
= Table.Combine({Ubrania, Komponenty, Rowery, Akcesoria})
lub:
= Table.Combine({Komponenty, Ubrania, Rowery, Akcesoria})
lub:
= Table.Combine({Komponenty, Rowery, Ubrania, Akcesoria})
lub:
= Table.Combine({Komponenty, Rowery, Akcesoria, Ubrania})
Aby sprawdzić, czy funkcja Table.Combine działa poprawnie, kliknij ikonę filtru w kolumnie
Kategoria. W panelu, który się pojawi, powinny być widoczne cztery wartości: Akcesoria,
Komponenty, Rowery i Ubrania. Filtrowanie wartości jest prostym i praktycznym sposobem
weryfikowania poprawności przekształceń.
Teraz, po dołączeniu tabeli Ubrania do Produkty, możesz zająć się innym przypadkiem,
czyli łączeniem tabel na szerszą skalę.
Łączenie tabel na szerszą skalę

W poprzednim ćwiczeniu dowiedziałeś się, jak w edytorze Power Query można łączyć kilka tabel
za pomocą przekształcenia Dołącz zapytania lub Dołącz zapytania jako nowe. Te przekształcenia są
oczywiście bardzo przydatne, jeżeli liczba tabel jest określona, ale w praktyce często zdarza się, że nie
wiadomo zawczasu, jak się tabele nazywają. Wtedy ręczne korygowanie zapytań, za każdym razem
gdy zmienią się nazwy tabel, jest bardzo czasochłonnym podejściem, którego należy unikać.
Łączenie tabel zapisanych w folderze

Najczęściej spotykany przypadek można zilustrować na następującym przykładzie: wyobraź sobie, że
musisz połączyć kilka tabel. Każda z nich jest zapisana w osobnym skoroszycie Excela, którego
nazwa zawiera informacje o miesiącu i roku, np.:
 Styczeń2019.xlsx,
 Luty2019.xlsx,
 Marzec2019.xlsx,
 Kwiecień2019.xlsx.
89
4650570396d9eb2765da56c12eb840b5
4
Co miesiąc w folderze pojawia się nowy skoroszyt, a Twoim zadaniem jest aktualizowanie
raportu, czyli dodanie nowych danych. Przyjmijmy, że utworzyłeś już raport, do którego
zaimportowałeś każdą tabelę z osobna i wszystkie połączyłeś, wykorzystując poznaną wcześniej
technikę. Gdy pojawi się nowy plik, np. Maj2019.xlsx, powinieneś wykonać sekwencję operacji
modyfikujących zapytanie: zaimportować plik jako nowe zapytanie, np. Maj2019, a następnie
zmodyfikować w panelu Zastosowane kroki krok łączący wszystkie tabele. Formuła wyglądałaby
wtedy tak (zmiany wyróżnione są pogrubioną czcionką):
= Table.Combine({Styczeń2019, Luty2019, Marzec2019, Kwiecień2019, Maj2019})
Szybko okaże się, że jest to bardzo żmudna metoda, ponieważ należy ją stosować co miesiąc.
Czy nie lepsze byłoby zapytanie, które automatycznie dołączałoby kolejne skoroszyty pojawiające się
w folderze i którego nie trzeba by w ogóle modyfikować, a raport wystarczyłoby po prostu odświeżać?
Przy użyciu opcji importowania skoroszytów z folderu jest to możliwe.
Ćwiczenie 3.3. Łączenie skoroszytów

z produktami zapisanymi w folderze
Wróćmy do naszej firmy Fabryka Przygód. Załóżmy, że programista w dziale IT napisał skrypt
aktualizujący skoroszyt Excela za każdym razem, gdy pojawi się nowy produkt. Co roku tworzony
jest nowy plik aktualizowany na bieżąco. Pliki zapisane są w osobnym folderze, tak jak na rysunku
3.5. Jako szef działu analiz zamierzasz utworzyć raport obejmujący wszystkie produkty.
RYSUNEK 3.5. W tym przykładzie produkty firmy Fabryka Przygód są zapisane w osobnych skoroszytach
Excela w udostępnionym folderze

W Excelu: kliknij kartę Dane, a następnie polecenia Pobierz dane, Z pliku, Z folderu.
W Power BI Desktop: kliknij ikonę Pobierz dane, a następnie Folder i Połącz.
2. W oknie Folder przejdź do folderu C:\Dane\R03\Produkty (patrz rysunek 3.5) lub wpisz tę
ścieżkę w polu Ścieżka folderu. Kliknij OK.
90
4650570396d9eb2765da56c12eb840b5
4
3. W oknie, które się pojawi (o takiej samej nazwie jak nazwa folderu), kliknij przycisk Połącz,
a następnie Połącz i edytuj.
Wskazówka. Nie zaleca się używać polecenia Połącz i załaduj, które łączy wszystkie pliki
i ładuje je do raportu bez uprzedniej edycji. Jeżeli nie wiadomo, które pliki należy wybrać, dobrą
praktyką jest kliknięcie w kroku 3. polecenia Przekształć dane. Otworzy się edytor Power Query
z podglądem folderu, w którym można zastosować filtry wybierające pliki do zaimportowania.
Jeżeli np. w folderze oprócz skoroszytów znajdują się inne pliki, można przefiltrować je według
rozszerzenia .xlsx, gdyż wtedy nie zaimportuje się niewłaściwych plików. Odfiltrowane pliki
można połączyć, klikając ikonę Połącz pliki w nagłówku kolumny Content (zawartość).
4. W oknie Połącz pliki zaznacz Arkusz1, tak jak na rysunku 3.6, i kliknij OK.
RYSUNEK 3.6. W oknie Połącz pliki można wskazać arkusz lub tabelę do połączenia; ze skoroszytów Excela
zapisanych w danym folderze zostaną załadowane wszystkie arkusze o wskazanej nazwie
Uwaga. Okno Połącz pliki jest odpowiednikiem okna Nawigator pojawiającego się podczas
importowania pojedynczego skoroszytu Excela. W oknie Nawigator wybiera się arkusz lub
tabelę do edycji albo załadowania do raportu, natomiast w oknie Połącz pliki wybiera się arkusz
lub tabelę ze wszystkich plików zapisanych we wskazanym folderze. Wybór wykonany na kilku
skoroszytach jest następnie stosowany w odniesieniu do wszystkich plików, jakie się pojawią
w folderze.
5. Zwróć uwagę na pierwszą kolumnę o nazwie Source.Name (Źródło.Nazwa) w panelu

podglądu. Kliknij ikonę filtru w jej nagłówku. W panelu, który się pojawi, będą widoczne
nazwy plików.
91
4650570396d9eb2765da56c12eb840b5
4
Czasami kolumna Source.Name zawiera istotne dane. W opisanym przykładzie jest to rok
wprowadzenia produktu do sprzedaży. Jeżeli ta informacja jest potrzebna w raporcie, można ją z tej
kolumny wyodrębnić. Informacja kontekstowa zazwyczaj nie jest dostępna w osobnej kolumnie,
tylko w nazwie pliku. Na szczęście, z wykorzystaniem kolumny Source.Name ją pozyskać.
Aby wyodrębnić rok 2017 z nazwy R03-03 - 2017.xlsx, możesz zastosować jedno z dwóch
przekształceń. Podobny proces został szczegółowo opisany w rozdziale 2., dlatego tutaj wyróżnione
są tylko jego najważniejsze elementy. Nazwa pliku zawiera prefiks R03-03- oraz sufiks .xlsx.
Pomiędzy nimi znajduje się oznaczenie roku, które można wyodrębnić na dwa sposoby.
 Zastąpić prefiks R03-03- i sufiks .xlsx pustymi ciągami znaków. W tym celu należy użyć
przekształcenia Zamień wartości opisanego w rozdziale 2.
 Podzielić kolumnę Source.Name po dziewiątym znaku, licząc od początku ciągu (używając
przekształcenia Podziel kolumny według liczby znaków), a następnie dzieląc nową kolumnę
według kropki lub czwartego znaku od końca ciągu. Na koniec należy usunąć pierwszą
i trzecią kolumnę, aby pozostała tylko druga zawierająca wyodrębnione informacje o roku.
Teraz możesz załadować połączone tabele do skoroszytu Excela lub raportu Power BI Desktop.
Uwagi do importowania plików z folderu

Poniżej znajdują się trzy ważne komentarze do przekształcenia łączącego pliki zapisane w folderze.
 Jest to bardzo przydatna funkcjonalność. Aby uwzględnić w przekształceniu łączenia tabel
nowy plik, który pojawi się w folderze, nie trzeba modyfikować zapytania. Sprawdź to,
wykonując prosty test. Skopiuj i wklej jeden z istniejących skoroszytów i zmień jego nazwę
utworzonej kopii na R03-03 - 2018.xlsx. Następnie odśwież skoroszyt lub raport, który
utworzyłeś w ćwiczeniu 3.3, i sprawdź, czy pojawiły się produkty z oznaczeniem roku
2018. Czyż nie jest to wspaniała funkcjonalność?
 Po wykonaniu kroku 5. w ćwiczeniu 3.3 zapewne zauważyłeś, że w panelu Zapytania
pojawiły się nowe elementy, m.in. grupy i typy zapytań. Na razie nie zwracaj na nie uwagi.
Wrócimy do nich później przy opisie funkcji zapytań i innych zaawansowanych tematów.
 Można łączyć pliki zapisane w udostępnionym folderze lub witrynie SharePoint. Łącząc
pliki w folderze, możesz udostępniać skoroszyty i raporty innym użytkownikom i odświeżać
je. Jeżeli używasz usługi Power BI, możesz publikować raporty i korzystać z usługi ich
automatycznego odświeżania. Jeżeli folder znajduje się w systemie SharePoint Online lub
OneDrive for Business, wtedy usługa Power BI ma bezpośredni dostęp do danych i można
ją skonfigurować tak, aby regularnie odświeżała raport. Jeżeli folder znajduje się na
lokalnym komputerze, możesz użyć bramy Power BI On-Premises Gateway; przy jej
usługa Power BI zyska dostęp do tego folderu i będzie regularnie odświeżała raport.
Łączenie arkuszy w skoroszycie

Przeanalizujmy ostatni przypadek łączenia tabel na szeroką skalę, tj. zapisanych w kilku arkuszach
jednego skoroszytu. W poprzednim rozdziale połączyłeś produkty Fabryki Przygód zapisane
w osobnych skoroszytach. W każdym z nich znajdowały się inne produkty, a nazwa skoroszytu
zawierała informację o roku. Wyobraź sobie teraz, że te same tabele są zapisywane w osobnych
arkuszach tego samego skoroszytu. Czy można połączyć wszystkie arkusze w jedną tabelę,
92
4650570396d9eb2765da56c12eb840b5
4
zachowując informacje o roku, tak jak na rysunku 3.7? Czy można to zrobić tak, aby nie trzeba było
modyfikować zapytania za każdym razem, gdy zostanie utworzony nowy arkusz? Jak można
sprawić, aby produkty pojawiające się w kolejnych latach były automatycznie dołączane do raportu
po kliknięciu polecenia Odśwież?
RYSUNEK 3.7. Twoim zadaniem jest połączenie produktów zapisanych w osobnych arkuszach z zachowaniem
informacji o roku wprowadzenia do sprzedaży, bez konieczności modyfikowania zapytania w kolejnych latach
Ćwiczenie 3.4. Łączenie arkuszy — rozwiązanie

W tym ćwiczeniu wykorzystasz plik R03-04 - lata w osobnych arkuszach.xlsx.
2. Zaznacz plik R03-04 - lata w osobnych arkuszach.xlsx i kliknij Importuj.
3. W oknie Nawigator kliknij ikonę folderu.
Uwaga. W oknie Nawigator nie zaznaczaj żadnego z arkuszy. Możesz wprawdzie tak zrobić
i dołączać kolejne arkusze, tak jak w ćwiczeniu 3.1, ale metoda ta w dłużnym okresie czasu
okaże się niewłaściwa. Za każdym razem, gdy w skoroszycie pojawi się nowy arkusz, będziesz
musiał modyfikować zapytanie. Dlatego w kroku 3. zaznacz cały skoroszyt, gdyż wtedy
utworzysz właściwe zapytanie.
W Excelu: kliknij Przekształć dane.

W Power BI Desktop: jeżeli przycisk Edytuj jest zablokowany, kliknij prawym przyciskiem
myszy skoroszyt R03-04 - lata w osobnych arkuszach.xlsx i wybierz polecenie Edytuj
z podręcznego menu.
4. W edytorze Power Query zmień nazwę zapytania na Produkty. W panelu podglądu pojawi
się tabela, w której poszczególne arkusze będą umieszczone w osobnych wierszach.
Zawartość każdego arkusza jest ukryta w kolumnie Data. Przed połączeniem arkuszy
usuń kolumny Item, Kind i Hidden (odpowiednio „Element”, „Rodzaj”, „Ukryty”).
93
4650570396d9eb2765da56c12eb840b5
4
Wskazówka. Jeżeli skoroszyt zawiera ukryte arkusze, można je wykluczyć przed połączeniem
w kroku 5. Jest to dobry moment na zastosowanie niezbędnych filtrów. Przykładowo po
zastosowaniu w kolumnie Hidden filtru zawierającego wartość FALSE zostaną wykluczone
ukryte arkusze.
5. W nagłówku kolumny Data kliknij przycisk rozwijania tabeli.

6. Pojawi się panel z listą kolumn o nic niemówiących nazwach Column1, Column2 itd.
Kliknij OK, aby wyświetlić wszystkie kolumny. Połączona tabela oprócz danych zawiera
nazwy kolumn z każdego arkusza, tak jak w pierwszej tabeli na rysunku 3.8.
RYSUNEK 3.8. Ten ciąg przekształceń pozwala oczyścić połączone arkusze
Uwaga. Jeżeli każdy skoroszyt zawiera tabelę danych, wtedy w kroku 6. możesz rozwinąć tabelę
z poprawnymi nazwami kolumn zamiast Column1, Column2 itd. (Aby w Excelu zamienić
zakres komórek na tabelę, zaznacz go lub kliknij komórkę wewnątrz zakresu, a następnie
naciśnij klawisze Ctrl+T).
94
4650570396d9eb2765da56c12eb840b5
4
Rysunek 3.8 przedstawia ciąg przekształceń niezbędny do oczyszczenia połączonej tabeli.

W pierwszym kroku pierwszy wiersz danych jest przenoszony do nagłówków kolumn.
W drugim są usuwane nagłówki skoroszytów 2016 i 2017, a w trzecim zmieniana jest
nazwa kolumny z 2015 na Rok. W tej książce tego rodzaju diagramy są wykorzystywane
do ilustrowania sekwencji przekształceń w bardziej skomplikowanych przypadkach.
Przyjrzyjmy się teraz dokładniej poszczególnym krokom.
7. W karcie Przekształć kliknij ikonę Użyj pierwszego wiersza jako nagłówków. W ten sposób
pierwszy wiersz z pierwszego arkusza zostanie użyty jako nazwy kolumn połączonej tabeli.
8. Zwróć uwagę, że w tabeli znajdują się nagłówki z arkuszy 2016 i 2017. W tych wierszach
w kolumnie Nazwa znajduje się wartość Nazwa, którą należy usunąć. W tym celu kliknij
przycisk filtru w nagłówku tabeli Nazwa i w panelu, który się pojawi, usuń zaznaczenie
przy pozycji Nazwa. Następnie kliknij OK.
9. Kliknij dwukrotnie nagłówek kolumny 2015 i zmień jej nazwę na Rok.
Uwaga. Kroki od 7. do 9. w dłuższym okresie czasu mogą przestać działać poprawnie. Za chwilę
dowiesz się dlaczego i jak temu zapobiec.
Teraz możesz załadować połączoną tabelę do skoroszytu Excela lub raportu Power BI
Desktop. Pomyślnie połączyłeś trzy arkusze i z nazwy każdego z nich wyodrębniłeś rok
wprowadzenia produktów do sprzedaży. Pora więc na przetestowanie skalowalności tego
rozwiązania i sprawdzenie, czy raport poprawnie się odświeży, gdy zostanie dodany
czwarty arkusz o nazwie 2018.
10. Nie zamykaj utworzonego skoroszytu ani raportu. Otwórz plik R03-04 - lata w osobnych
arkuszach.xlsx, utwórz kopię arkusza 2017, zmień jej nazwę na 2018 i zapisz.
Wskazówka. Jeżeli używasz Excela, a nie Power BI Desktop, zauważyłeś, że po otwarciu

edytora nie można korzystać z otwartych wcześniej skoroszytów ani otwierać nowych za
pomocą karty Plik. Dlatego w kroku 10. musisz przed otwarciem skoroszytu zamknąć edytor.
Niedogodność tę można ominąć, uruchamiając nową instancję Excela za pomocą menu Start
w pasku systemu. Nowa instancja nie będzie blokowana przez edytor Power Query.
11. Odśwież zapytanie Produkty w skoroszycie lub raporcie i sprawdź, czy pojawiły się
zduplikowane wiersze z wartością 2018 w kolumnie Rok. To działa!
Dodaj arkusz o nazwie 2014 zawierający dane historyczne. W tym celu utwórz kopię jednego
z istniejących arkuszy i umieść jego zakładkę na początku listy. Teraz, gdy pierwszy arkusz
nazywa się 2014, a nie 2015, raport nie odświeży się i pojawi się komunikat [Expression.Error]
Nie można znaleźć kolumny „2015” w tabeli.
12. Aby doraźnie rozwiązać problem, otwórz edytor Power Query, zaznacz zapytanie Produkty
i w panelu Zastosowane kroki kliknij krok Zmieniono typ. W pasku formuły pojawi się
następujący kod:
= Table.TransformColumnTypes(#"Nagłówki o podwyższonym poziomie",{{"2015", Int64.Type},
{"Nazwa", type text}, {"Kod produktu", type text}, {"Kolor", type text}, {"Koszt",
type any}, {"Cena", type any}, {"Wielkość", type text}, {"Waga", type any},
{"Kategoria", type text}, {"Podkategoria", type text}})
95
4650570396d9eb2765da56c12eb840b5
4
Wyszukaj w formule ciąg "2015" i zamień go na "2014".

13. Kliknij krok Zmieniono nazwy kolumn. W pasku formuły pojawi się następujący kod:
= Table.RenameColumns(#"Przefiltrowano wiersze",{{"2015", "Rok"}})

Wyszukaj w formule ciąg "2015" i zamień go na "2014".
14. Zamknij edytor Power Query i odśwież raport. Dane za rok 2014 zostaną uwzględnione
w raporcie.
Powyższe kroki są zapisane w plikach R03-04 - rozwiązanie 1.xlsx i R03-04 - rozwiązanie 1.pbix.
Jeżeli masz pewność, że pierwszy arkusz w skoroszycie zawsze będzie nazywał się 2015 (lub 2014
po ostatniej zmianie) i że nowe arkusze będą dodawane na końcu listy, Twoje zadanie jest skończone.
Co można jednak zrobić, jeżeli tej pewności nie będzie? W jaki sposób można poprawić zapytanie, aby
nie trzeba było wykonywać kroków od 12. do 14. za każdym razem, gdy zmieni się pierwszy arkusz?
W następnym, ostatnim podpunkcie rozdziału dowiesz się, jak można usprawnić zapytanie,
aby działało poprawnie bez względu na to, jak nazywa się pierwszy arkusz.
Uniwersalna metoda łączenia arkuszy

W tym miejscu rozdziału krótko opisany jest sposób poprawienia zapytania, aby było ono uniwersalne
i nie powodowało problemów z odświeżaniem raportu. W ćwiczeniu 3.4 połączyłeś trzy arkusze
zawierające dane z poszczególnych lat. Jest to skalowalne rozwiązanie umożliwiające łączenie
nowych arkuszy pojawiających się w skoroszycie, ale jeżeli nowy arkusz zostanie utworzony
na początku skoroszytu, wtedy pojawi się błąd.
W ćwiczeniu 3.4 w krokach od 7. do 9. połączyłeś trzy arkusze w jedną tabelę. W rozdziale 10.,
„Od złych do dobrych zapytań”, dowiesz się, jak można zmienić każdy krok, aby uniknąć potencjalnych
problemów. Poniżej krótko opisane zostały popełnione wcześniej pomyłki, a dalej sposoby ich
naprawienia w tym konkretnym przypadku.
 W kroku 7. użyłeś przekształcenia Użyj pierwszego wiersza jako nagłówków, które
automatycznie zmieniło typ kolumn. W efekcie w formule został jawnie użyty rok 2015.
Formuła w takiej postaci spowodowała błąd odświeżenia raportu. W rozdziale 10. taki
przypadek jest nazywany pułapką zmiany typu.
 W kroku 9. zmieniłeś nazwę kolumny z 2015 na Rok. Tutaj również powstała formuła
jawnie odwołująca się do kolumny 2015, co również spowodowało błąd odświeżenia
raportu po dodaniu nowego arkusza 2014 na początku listy. W rozdziale 10. taki przypadek
jest nazywany pułapką zmiany nazwy kolumny.
Zobacz też. Zwróć uwagę, że w kroku 8. niemal wpadłeś w trzecią pułapkę przeszukiwania
filtru polegającą na użyciu listy wartości zamiast wybrania polecenia Filtry tekstu i jawnego
zdefiniowania warunku. W rozdziale 10. poznasz dokładniej tę i inne podobne pułapki.
Aby usunąć powyższe pułapki, wykonaj następujące kroki.

1. Otwórz w edytorze Power Query zapytanie Produkty i z panelu Zastosowane kroki usuń krok
Zmieniono typ (później jawnie określisz typ danych w kolumnie).
2. Kliknij krok Zmieniono nazwy kolumn. W pasku formuły pojawi się następujący kod:
= Table.RenameColumns(#"Przefiltrowano wiersze",{{"2015", "Rok"}})
96
4650570396d9eb2765da56c12eb840b5
4
3. Zamień ciąg "2015" na Table.ColumnNames(#"Przefiltrowano wiersze"){0}. Formuła

przyjmie następującą postać:
= Table.RenameColumns(#"Przefiltrowano wiersze", {{Table.ColumnNames(#"Przefiltrowano
wiersze"){0}, "Rok"}})
Język M jest szczegółowo opisany w rozdziale 9. Na razie nie przejmuj się, jeżeli nie rozumiesz
w pełni jego składni. W 99% przypadków nie będziesz potrzebował modyfikować kodu M,
aby rozwiązać problem. Ponieważ jednak zmieniłeś tutaj formułę, przeanalizujmy krótko,
co się stało.
Zamiast jawnego polecenia dla Power Query „zmień nazwę kolumny 2015 na Rok” użyłeś
„zmień nazwę pierwszej kolumny na Rok”.
W jaki sposób można odwołać się do pierwszej kolumny? Za pomocą funkcji Table.ColumnNames
zwracającej listę nazw kolumn tabeli podanej w argumencie. W tym przypadku jest to tabela
#"Przefiltrowano wiersze", ponieważ taka nazwa została nadana w pierwszym kroku.
Aby odwołać się do pierwszego elementu listy, użyłeś cyfry 0 umieszczonej w nawiasach
klamrowych. W ten sposób w języku M można odwoływać się do określonych elementów
listy lub wierszy tabeli. Indeksy są numerowane od 0. Zatem pierwszy element ma indeks 0,
a n-ty ma indeks n–1. W rozdziale 10. użyjesz funkcji Table.ColumnNames, aby nie odwoływać
się do kolumn za pomocą jawnie podanych nazw, dzięki czemu unikniesz problemów
z odświeżaniem raportu, gdy zmieni się nazwa kolumny.
4. Tworzenie uniwersalnego zapytania zakończ jawnym określeniem typów kolumn:
a. typ kolumny Rok zmień na Liczba całkowita,
b. typ kolumny Koszt zmień na Liczba dziesiętna,
c. typ kolumny Cena zmień na Liczba dziesiętna.
Zamknij edytor i odśwież raport. Arkusze zostaną połączone poprawnie, niezależnie od tego,
jaką nazwę będzie miał pierwszy z nich.
Gotowe rozwiązanie jest zapisane w plikach R03-04 - rozwiązanie 2.xlsx i R03-04 - rozwiązanie 2.pbix.
Podsumowanie
W tym rozdziale poznałeś jedno z najczęściej stosowanych przekształceń w Power Query. Możliwość
łączenia tabel o wspólnym formacie upraszcza analizę i pozwala uniknąć żmudnego przetwarzania
danych umieszczonych w różnych miejscach.
Na początku rozdziału zostały opisane proste przekształcenia Dołącz zapytania i Dołącz
zapytania jako nowe, umożliwiające łączenie dwóch lub więcej tabel. Przedstawione zostały różnice
pomiędzy obiema metodami i omówiona rola przekształcenia Odwołanie i okna Zależności zapytań
w weryfikowaniu poprawności ciągu przekształceń.
Dalej zajęliśmy się praktycznymi przypadkami, w których liczba i nazwy tabel nie są zawczasu
znane. Dowiedziałeś się, jak importować pliki zapisane w folderze, łączyć zawarte w nich tabele
w jedną i zachowywać informację kontekstową zawartą w nazwach plików (kolumna Source.Name).
Poznałeś też przekształcenie do łączenia tabel zapisanych w różnych arkuszach tego samego
skoroszytu z zachowaniem ich nazw. Korzystając z tego przekształcenia, można łączyć nowe arkusze
bez konieczności modyfikowania zapytania.
97
4650570396d9eb2765da56c12eb840b5
4
Na końcu rozdziału zostało opisanych kilka najczęściej spotykanych pułapek. Dokładniej są

one omówione w rozdziale 10. Dowiedziałeś się, jak poprawić zapytanie, wykorzystując funkcję
Table.ColumnNames, dzięki której nie będą pojawiały się problemy z odświeżaniem raportu, gdy
zmieni się nazwa pierwszego arkusza.
W tym rozdziale zostało przyjęte założenie, że łączone tablice mają taki sam format. Przy takim
założeniu zadanie łączenia jest dość proste. W rozdziale 4., „Łączenie niezgodnych tabel”, poznasz
często spotykany przypadek, w którym nawet niewielkie różnice w formatach tabel mogą uniemożliwić
ich połączenie, jeżeli się ich wcześniej odpowiednio nie przygotuje. Wiedza nabyta w rozdziale 4.
będzie miała pierwszorzędne znaczenie. Kiedy stosujesz Power Query, wbrew twierdzeniu Einsteina,
połączenie mądrości i mocy nie jest rzadkością. Co powiedziałby Einstein, gdyby miał Power Query?
98
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 4.
Łączenie niezgodnych tabel
Połącz ekstrema, a otrzymasz prawdziwy środek.

— Friedrich Schlegel

 oceniać skutki błędnego połączenia tabel,
 poprawnie łączyć tabele z kolumnami o niezgodnych nazwach,
 poprawnie łączyć niezgodne tabele zapisane w folderze,
 ujednolicać nazwy kolumn za pomocą tabeli konwersji,
 stosować sposoby ujednolicania tabel różniące się złożonością i wydajnością.
W rozdziale 3., „Łączenie danych z kilku źródeł”, dowiedziałeś się, jak łączyć tabele, aby uprościć
sobie analizę danych i tworzenie raportów. Często zdarza się, że tabele mają różne formaty lub
stopniowo zmieniają się w wyniku modyfikowania ich przez różnych użytkowników nieświadomych
potencjalnego zagrożenia, na jakie narażają w ten sposób tworzenie raportów.
Ten rozdział jest poświęcony poważnemu zadaniu: łączeniu niezgodnych tabel. Aby uświadomić
sobie skalę problemu, wyobraźmy sobie, że tabele są podobne do skarpetek. Operacje, które
wykonywałeś w rozdziale 3., były podobne do zakładania skarpetek. W tym rozdziale dowiesz się,
jak sobie radzić ze skarpetkami, które są nie do pary. Na pewno zgodzisz się, że jeżeli skarpetki są
takie same, noszenie ich jest przyjemnością. Jednak prawdziwym koszmarem jest zakładanie
różnych skarpetek. Czasami znalezienie w stosie ubrań dwóch jednakowych skarpetek okazuje się
niemożliwością. Czy można połączyć ekstrema i założyć skarpetki nie do pary? W praktyce, jeżeli
mamy na myśli tabele, jest to możliwe. Ten rozdział opisuje, jak za pomocą Power Query radzić
sobie z takimi tabelami, choćby były nie wiadomo jak niezgodnie.
Problem z niezgodnymi tabelami

W rozdziale 3. łączyłeś tabele, wykorzystując różne techniki. Ręcznie importowałeś kilka tabel
i łączyłeś je, stosując przekształcenia Dołącz zapytania i Dołącz zapytania jako nowe. Importowałeś
również tabele zapisane w folderze oraz w różnych arkuszach skoroszytu. We wszystkich
ćwiczeniach przyjęte było milczące założenie, że wszystkie tabele mają ten sam format.
4650570396d9eb2765da56c12eb840b5
4
Zrozumiałe jest, że tabele przeznaczone do połączenia muszą mieć wspólny format. Jest to
jednak idealistyczne założenie, rzadko sprawdzające się w praktyce. Często będziesz miał do
czynienia z różnymi formatami tabel lub — co gorsza — z formatami, które w miarę upływu czasu
będą różniły się coraz bardziej. W tym podrozdziale opisane są najczęściej spotykane przypadki
niezgodności tabel i sposoby oceniania ich skutków.
Co to jest niezgodność tabel?

W tym rozdziale niezgodne tabele są to tabele zawierające tego samego rodzaju dane umieszczone
w kolumnach o różnych nazwach. Załóżmy, że Tabela1 składa się z kolumn o nazwach pracownik,
wiek i płeć, natomiast Tabela2 z kolumn Nazwisko, Wiek i K/M. Tabela 4.1 przedstawia różnice
pomiędzy kolumnami obu tabel.
TABELA 4.1. Przykład niezgodnych nazw kolumn
Tabela1 Tabela2 Niezgodność

Kolumna 1 pracownik Nazwisko Różne nazwy
Kolumna 2 wiek Wiek Różne wielkości liter w nazwach
Kolumna 3 płeć K/M Różne nazwy
Symptomy niezgodności tabel i związane z tym ryzyka

Teraz, kiedy wiesz już, czym są niezgodne tabele, możesz poznać symptomy niezgodności
towarzyszące łączeniu tabel lub odświeżaniu raportu opartego na tabelach, które pierwotnie
miały takie same formaty, ale które po pewnym czasie zmieniły się.
Podczas łączenia tabel wszystkie kolumny o takich samych nazwach są poprawnie łączone.
Do tabeli wynikowej są kopiowane wszystkie wiersze z pierwszej kolumny. Ta sama zasada dotyczy
wartości w drugiej kolumnie itd. Wszystkie wiersze kolumny są dołączane do tabeli wynikowej.
Jak jednak Power Query radzi sobie z niezgodnymi kolumnami? W większości przypadków
tworzy tabelę zawierającą wszystkie kolumny tabel źródłowych. Każdy wiersz z pierwszej tabeli jest
kopiowany do tabeli wynikowej. W takich wierszach wszystkie kolumny należące do drugiej tabeli
zawierają puste komórki. W taki sam sposób są kopiowane wiersze drugiej tabeli — wszystkie
kolumny właściwe dla pierwszej tabeli pozostają puste. Jest to tzw. symptom podziału danych,
pokazany na rysunku 4.1. Power Query nie konsoliduje wartości zawartych w różnych kolumnach,
tylko zachowuje oryginalne kolumny z nieciągłymi danymi.
Rysunek 4.1 ilustruje również inny symptom niezgodności tabel — brakujące wartości. Polega
on na tym, że w tabeli wynikowej umieszczane są wszystkie kolumny pierwszej tabeli, a niezgodne
kolumny z drugiej są beztrosko pomijane. W efekcie wiele wierszy w wynikowej tabeli zawiera puste
komórki. Dalej w tym rozdziale poznasz dokładniej powyższe symptomy i sposoby radzenia sobie z nimi.
Jeżeli zlekceważysz opisane symptomy, pojawią się oczywiste ryzyka. Podzielone i brakujące
dane mogą być przyczyną błędów i niedokładności w raportach. Na szczęście wiesz, jak objawiają się
symptomy niezgodności tabel i rozumiesz ich wagę. Czas więc, abyś dowiedział się, jak można
rozwiązywać tego rodzaju problemy i pomyślnie łączyć tabele.
100
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 4.  ŁĄCZENIE NIEZGODNYCH TABEL
RYSUNEK 4.1. Są dwa symptomy niezgodności tabel: podzielone dane i brakujące wartości;
oba mogą skutkować błędnymi raportami
Ćwiczenie 4.1. Uzgadnianie kolumn: podejście reaktywne

W tym ćwiczeniu nauczysz się uzgadniać nazwy kolumn i unikać symptomów podziału i braku
danych opisanych wcześniej w tym rozdziale (patrz rysunek 4.1). W tym ćwiczeniu, demonstrującym
problem i jego rozwiązanie, wykorzystasz skoroszyt z danymi firmy Fabryka Przygód.
Przeanalizujmy najpierw symptom podziału danych na prostym przykładzie i zastanówmy się,
jak można reaktywnie uzgodnić nazwy kolumn. W ćwiczeniu wykorzystasz dwa pliki:
 R04-01 - akcesoria.xlsx,
 R04-01 - rowery.xlsx.
Skoroszyty te zawierają katalogi produktów dwóch kategorii, takich jak Akcesoria i Rowery.
Koszty produktów są zapisane w kolumnie Koszt tabeli Rowery oraz w kolumnie Koszt standardowy
w tabeli Akcesoria. Spróbujmy teraz połączyć obie tabele.
1. Utwórz nowy skoroszyt w Excelu lub raport w Power BI Desktop i zaimportuj do niego oba
powyższe pliki.
2. Zaznacz zapytanie Akcesoria i użyj przekształcenia Dołącz zapytania jako nowe.
3. Przyjrzyj się w zawartości nowego zapytania Append1 w panelu podglądu. Zwróć uwagę,
że zawiera ono zarówno kolumnę Koszt, jak i Koszt standardowy. W wierszach z rowerami
pierwsza kolumna zawiera wartości liczbowe, a druga wartości null, natomiast w wierszach
z akcesoriami pierwsza kolumna zawiera wartości null, a druga wartości liczbowe.
Uwaga. Zapewne zauważyłeś, że połączona tabela nie zawiera informacji o kategorii produktu,
zawartej w nazwie pliku i arkusza. W rozdziale 5., „Zachowywanie kontekstu”, dowiesz się, jak
zachowywać konteksty tabel.
101
4650570396d9eb2765da56c12eb840b5
4
4. Zaznacz zapytanie Akcesoria i zmień nazwę kolumny Koszt standardowy na Koszt.

Gdy ponownie zaznaczysz zapytanie Append1, okaże się, że po uzgodnieniu nazw kolumn
zniknął symptom podziału danych.
Opisane tu rozwiązanie jest proste i na pewno będziesz je często stosował do uzgadniania nazw
kolumn. Czasami jednak nie będziesz mógł robić tego ręcznie. Załóżmy, że masz dwie tabele, każda
zawierająca 100 kolumn. Ręczne zmienianie nazw w opisany tu sposób byłoby powtarzalnym
i czasochłonnym zadaniem. Co gorsza, w większości przypadków podczas łączenia tabel zapisanych
w folderze ręczna zmiana nazwy kolumn nie jest możliwa, o czym przekonasz się w następnym
podrozdziale.
Łączenie niezgodnych tabel zapisanych w folderze

Wcześniej w tym rozdziale nauczyłeś się ręcznie uzgadniać nazwy kolumn przed połączeniem tabel.
Jeżeli w folderze zapisanych jest wiele tabel z niezgodnymi kolumnami, zadanie staje się jeszcze
trudniejsze. Z jednej strony, ręczne uzgadnianie nie jest dobrą praktyką szczególnie wtedy, kiedy
plików jest dużo. Z drugiej, przekształcenie polegające na połączeniu plików zapisanych w folderze
nie daje możliwości indywidualnego traktowania każdego pliku.
Aby sprostać temu wyzwaniu, możesz napisać kod, który zmienia nazwy kolumn u źródła.
Załóżmy jednak, że w folderze jest 60 skoroszytów i każdy zawiera tabelę składającą się z 20 kolumn.
Należałoby sprawdzić 1200 kolumn pod kątem zgodności nazw i ręcznie je zmienić. To nie jest
praktyczna metoda zwłaszcza wtedy, gdy nie jesteś autorem plików, tylko otrzymujesz je regularnie
z zewnątrz.
W rozdziale 3. nauczyłeś się łączyć tabele zapisane w folderze. Jak już się przekonałeś, wykonując
ćwiczenie opisane w tym rozdziale, Power Query wykorzystuje nagłówki pierwszej tabeli do
utworzenia kolumn tabeli wynikowej. Podczas łączenia niezgodnych tabel zapisanych w folderze
szybko pojawi się symptom braku danych. Następne ćwiczenie demonstruje ten symptom oraz
sposób pomyślnego łączenia tabel zapisanych w folderze.
Ćwiczenie 4.2. Część I. Symptom braku wartości

Wróćmy do naszej fikcyjnej firmy Fabryka Przygód. Menedżer każdej z czterech linii produktów
prowadzi w skoroszycie Excela własny katalog. Ty, jako szef działu analiz, dostałeś zadanie połączenia
wszystkich tabel i przygotowania raportu. Jednak po otwarciu skoroszytów stwierdziłeś, że menedżerowie
są kreatywni i zmienili wiele nazw kolumn (patrz rysunek 4.2). Przy próbie połączenia tabel zapisanych
w folderze okazało się, że jest to niemożliwe. W tym ćwiczeniu dowiesz się, jak sobie radzić z takimi
problemami.
RYSUNEK 4.2. Skoroszyty z produktami firmy Fabryka Przygód zawierają kolumny o niezgodnych nazwach
102
4650570396d9eb2765da56c12eb840b5
4
1. Przejrzyj pliki zapisane w folderze C:\Dane\R04\R04-02 - produkty:

a. R04-02 - akcesoria.xlsx,
b. R04-02 - rowery.xlsx,
c. R04-02 - komponenty.xlsx,
d. R04-02 - ubrania.xlsx.
2. Zwróć uwagę, że nazwy kolumn zbyt różnią się od siebie, aby można było poprawiać
indywidualnie każdą z nich.
3. Zaimportuj cztery niezgodne tabele z folderu, aby stwierdzić symptom brakujących wartości.
W Excelu: kliknij kartę Dane, a następnie polecenia Pobierz dane/Z pliku/Z folderu.
4. W oknie Folder przejdź do folderu C:\Dane\R04\R04-02 - produkty i kliknij OK.
6. W oknie Połącz pliki wybierz w liście Przykładowy plik dowolny skoroszyt, zaznacz Arkusz1
i kliknij OK.
Uwaga. W liście Przykładowy plik można wybrać skoroszyt i zastosować jego format do
wszystkich plików w folderze. Efektem wyboru są m.in. nazwy kolumn w wynikowej tabeli.
Ponieważ każda tabela zawiera kolumny o różnych nazwach, wkrótce zobaczysz symptom
brakujących wartości i jego skutki.
7. W oknie edytora przewiń zawartość podglądu, aż zawartość kolumny Source.Name zmieni się
z R04-02 - akcesoria.xlsx na R04-02 - komponenty.xlsx. Kolumny Produkt, ID, KosztStandardowy
i CenaListowa będą zawierały wartości null, tak jak na rysunku 4.3, które przełożą się na puste
wartości w raporcie.
RYSUNEK 4.3. Symptom brakujących wartości pojawia się podczas importowania z folderu wielu tabel
z niezgodnymi nazwami kolumn
Zanim rozwiążesz problem brakujących wartości, otwórz panel Zapytania i zaznacz zapytanie
Przekształć przykładowy plik, które w tej książce jest nazywane zapytaniem przykładowym.
Zapytanie to zostało utworzone podczas łączenia plików zapisanych w folderze. Gdy je zaznaczysz,
zauważysz, że w panelu podglądu dane akcesoriów są pokazywane poprawnie. Rozwiązywanie
problemu brakujących wartości należy zawsze zaczynać od zapytania przykładowego.
103
4650570396d9eb2765da56c12eb840b5
4
Wskazówka. Power Query podczas importowania plików z folderu tworzy przykładową funkcję,
przykładowe zapytanie, plik zapytania i parametr. Obiekty te są wykorzystywane do łączenia
kilku plików na podstawie wybranych danych. Główne przekształcenie każdego pliku jest
zaimplementowane w funkcji. Przekształcenia poszczególnych plików dostosowuje się poprzez
wprowadzanie zmian w przykładowym zapytaniu. Zmiany te są uwzględniane w funkcji
i wprowadzane we wszystkich plikach. Podczas łączenia plików zapisanych w folderze sprawdzaj,
jakie zmiany wprowadza zapytanie Przekształć przykładowy plik we wszystkich plikach przed
ich połączeniem.
Ćwiczenie 4.2. Część II. Założenie takiej samej kolejności kolumn

i ujednolicenie nagłówków
Aby rozwiązać problem brakujących wartości, przyjmijmy założenie, że kolumny — choć różnią się
nagłówkami — są we wszystkich tabelach ułożone w takiej samej kolejności. W takim przypadku do
połączenia tabel będzie można użyć domyślnych nazw kolumn Column1, Column2 itd. Poniższe kroki
należy wykonać po krokach od 1. do 6. z części I ćwiczenia 4.2.
8. Zaznacz zapytanie Przekształć przykładowy plik i zmień jego nazwę na Przykładowe
produkty.
9. W panelu Zastosowane kroki usuń ostatni krok Nagłówki o podwyższonym poziomie.
Kolumny uzyskają nazwy Column1, Column2 itd. Jeżeli wszystkie kolumny we wszystkich
tabelach będą miały takie same, ogólne nazwy, wtedy zostaną poprawnie połączone.
10. Kliknij zapytanie R04-02 - produkty i zwróć uwagę na komunikat Expression.Error:
Nie można znaleźć kolumny „Produkty” w tabeli.
11. W panelu Zastosowane kroki usuń ostatni krok Zmieniono typ. Teraz połączona tabela
nie będzie zawierała brakujących wartości. Możesz się o tym przekonać, przewijając jej
zawartość. Wszystkie wartości z tabeli Akcesoria będą dostępne.
12. W karcie Przekształć kliknij ikonę Użyj pierwszego wiersza jako nagłówków, aby zmienić
nazwy kolumn.
Niestety, połączona tabela zawiera również nagłówki poszczególnych tabel. W rozdziale 3.
podobny problem rozwiązałeś za pomocą filtru. Tutaj jednak kolumny mają różne nazwy
i trudno określić, które z nich należy zastosować w filtrze. Dlatego przed krokiem użyj
indeksu w celu zidentyfikowania wierszy z nagłówkami.
13. W panelu Zapytania kliknij zapytanie Przykładowe produkty. Następnie w karcie Dodaj
kolumnę kliknij ikonę Kolumna indeksu. Pojawi się kolumna zawierająca indeksy wierszy.
Pierwszy wiersz każdej tabeli, zawierający nagłówki kolumn, ma indeks 0.
14. Wróć do zapytania R04-02 - produkty i usuń nagłówki za pomocą filtru odrzucającego indeks
0. W tym celu kliknij przycisk filtru w nagłówku ostatniej kolumny o nazwie 0. W panelu,
który się pojawi, usuń zaznaczenie przy pozycji 0 i kliknij OK.
15. Usuń pierwszą i ostatnią kolumnę (o nazwach odpowiednio R04-02 - akcesoria.xlsx i 0).
Aby zapytanie było uniwersalne, zmodyfikuj je w sposób opisany w rozdziale 3., „Łączenie
danych z kilku źródeł”. W tym przypadku zastąp statyczne odwołanie do kolumny
Source.Name dynamicznym wyrażeniem Table.ColumnName(...){0}.
104
4650570396d9eb2765da56c12eb840b5
4
W pasku formuły znajduje się następujący kod:

= Table.RemoveColumns(#"Przefiltrowano wiersze",{"R04-02 - akcesoria.xlsx", "0"})
Zmień go na następujący:
= Table.RemoveColumns(#"Przefiltrowano wiersze",{Table.ColumnNames(#"Przefiltrowano
wiersze"){0}, "0"})
Teraz możesz załadować połączoną tabelę i rozpocząć analizę danych.
W kroku 8. zmieniłeś nagłówki kolumn na ogólne Column1, Column2 itd. Mogłeś to zrobić,
ponieważ przyjąłeś założenie, że kolumny we wszystkich tabelach są ułożone w takiej samej
kolejności. Zastanówmy się jednak, co by się stało, gdyby w jednej z tabel kolejność kolumn była inna,
np. w tabeli Rowery zamienione byłyby miejscami kolumny Nazwa i Kod_produktu. Po zastosowaniu
opisanej wyżej procedury w wynikowej tabeli powstałby bałagan. Nazwy produktów z tabeli Rowery
zostałyby potraktowane jak kody produktów i odwrotnie. Aby temu zapobiec, mógłbyś się umówić
z menedżerem działu rowerów, aby nie zmieniał kolejności kolumn w źródłowej tabeli. Jest jednak
inne rozwiązanie, opisane dalej w tym rozdziale, polegające na ujednoliceniu nagłówków kolumn
przed połączeniem tabel.
Ćwiczenie 4.3. Proste ujednolicenie nagłówków

za pomocą funkcji Table.TransformColumnNames
Automatyczne kojarzenie i zmienianie nazw kolumn w wielu tabelach jest ważną częścią procesu
łączenia niezgodnych tabel. Jeżeli takich tabel jest dużo, wtedy ręczne zmienianie nazw wybranych
kolumn, tak jak w ćwiczeniu 4.1, jest niepraktycznym rozwiązaniem szczególnie wtedy, gdy plików
jest wiele i często się zmieniają. Jeżeli można przyjąć założenie, że kolumny we wszystkich tabelach
są ułożone w tej samej kolejności, wtedy sprawdzi się rozwiązanie zaprezentowane w ćwiczeniu 4.2.
Jeżeli jednak kolejność kolumn nie jest gwarantowana, wtedy trzeba zastosować bardziej
zaawansowany sposób, jakim jest ujednolicenie nazw kolumn.
Ujednolicenie nazw kolumn jest to prosta operacja na tekstach. Zazwyczaj, aby uzyskać spójny
format tabel, wystarczy wprowadzić niewielkie zmiany we wszystkich niezgodnych kolumnach,
np. zastąpić znaki podkreślenia spacjami lub zmienić wszystkie litery na wielkie.
Prosta operacja na tekstach, np. zmiana wielkości liter, może być bardzo skutecznym sposobem
uzgadniania nazw kolumn. Narzędzie Power Query rozróżnia wielkość liter, zatem np. kolumny
o nazwach kolumna1 i Kolumna1 traktuje jako różne. Jeżeli tabele często się zmieniają, np. małe
litery w nazwach kolumn są zamieniane na wielkie lub odwrotnie, wtedy ujednolicenie ich wielkości
może znacznie zredukować niezgodności.
Aby w prosty sposób przekształcić nazwę kolumny, użyj funkcji Table.TransformColumnNames.
Jeżeli przykładowo ostatni krok w panelu Zastosowane kroki nazywa się Poprzedni krok, wtedy
poniższa formuła zamieni pierwsze litery każdego słowa w nazwie kolumny na wielkie:
= Table.TransformColumnNames(#"Poprzedni krok", Text.Proper)
Natomiast poniższa formuła zamieni wszystkie znaki podkreślenia na spacje:
= Table.TransformColumnNames(#"Poprzedni krok", each Replacer.ReplaceText(_, "_", " "))
W tym ćwiczeniu wykorzystasz powyższe formuły do połączenia tabel produktów firmy
Fabryka Przygód.
105
4650570396d9eb2765da56c12eb840b5
4
Uwaga. Na tym etapie nie musisz w pełni rozumieć składni opisywanych formuł. Ten temat
będzie opisany w rozdziale 9., „Wprowadzenie do języka M”. Na razie musisz jedynie wiedzieć,
że funkcje Text.Proper i Replacer.ReplaceText służą do przekształcania tekstu. Obie można
stosować wewnątrz funkcji Table.TransformColumnNames. W poprzednim przykładzie funkcja
Text.Proper zamieniała pierwsze litery każdego słowa na wielkie, a Replacer.ReplaceText
zamieniała wszystkie znaki podane w drugim argumencie na znaki wskazane w trzecim argumencie.
1. Przejrzyj pliki zapisane w folderze C:\Dane\R04\R04-03 - produkty:

Pliki te zawierają te same dane, co w ćwiczeniu 4.2, ale zostały w nich wprowadzone dwie
zamierzone zmiany. Po pierwsze, inne są nagłówki kolumn. Różnice te można zniwelować,
zamieniając pierwsze litery słów na wielkie oraz zastępując znaki podkreślenia spacjami.
Po drugie, w tabeli Rowery zamienione są miejscami dwie pierwsze kolumny, przez co nie
można ujednolicić ich nagłówków w sposób opisany w ćwiczeniu 4.2.
2. Utwórz nowy skoroszyt w Excelu lub raport w Power BI Desktop i wykonaj poniższe kroki.
i kliknij OK.
Zgodnie z oczekiwaniami, w edytorze Power Query pojawił się symptom brakujących
wartości.
6. Kliknij zapytanie Przekształć przykładowy plik i zmień jego nazwę na Przykładowe produkty.
7. W pasku formuły kliknij przycisk fx (patrz rysunek 4.4).
8. Zwróć uwagę, że w panelu Zastosowane kroki pojawił się nowy krok Niestandardowe1,
a w pasku formuły następujący kod:
= #"Nagłówki o podwyższonym poziomie"
Krok Nagłówki o podwyższonym poziomie był ostatni na liście, zanim kliknąłeś przycisk fx.
Ciąg #"Nagłówki o podwyższonym poziomie" jest zmienną zawierającą wynik wykonania
poprzedniego kroku. Ponieważ wynikiem tym jest tabela z niezgodnymi kolumnami,
możesz zmienić wszystkie litery na małe, używając tej zmiennej z funkcjami
Table.TransformColumnNames i Text.Lower. W tym celu wpisz następującą formułę:
= Table.TransformColumnNames(#"Nagłówki o podwyższonym poziomie", Text.Lower)
106
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 4.4. Za pomocą przycisku fx można utworzyć niestandardowy krok i zdefiniować formułę nowego
przekształcenia modyfikującego poprzedni krok
9. Naciśnij Enter. Zwróć uwagę, że teraz nazwy wszystkich kolumn składają się wyłącznie
z małych liter. Gdybyś chciał zamienić pierwsze litery wszystkich słów na wielkie,
powinieneś użyć w powyższej formule funkcji Text.Proper zamiast Text.Lower.
Uwaga. Jeśli nawet pracujesz na tabelach, których kolumny mają zgodne nazwy i są ułożone we
właściwej kolejności, powinieneś stosować powyższe formuły, aby zapobiec sytuacji, w której
autor tabeli postanowi zmienić wielkość liter na małe lub wielkie albo ich kombinację.
10. Aby zamienić znaki podkreślenia spacjami, kliknij ponownie w pasku formuły przycisk fx.
11. Zwróć uwagę, że w panelu Zastosowane kroki pojawił się nowy krok Niestandardowe2,
= Niestandardowe1
Użyj zmiennej Niestandardowe1 z funkcjami Table.TransformColumnNames
i Replacer.ReplaceText, aby zamienić znaki podkreślenia na spacje. W tym celu
wpisz następującą formułę:
= Table.TransformColumnNames(Niestandardowe1, each Replacer.ReplaceText(_,"_", " "))
12. Naciśnij Enter. Zwróć uwagę, że w nazwach kolumn znajdują się spacje, a nie znaki
podkreślenia. Teraz nagłówki są bardziej czytelne.
13. Zaznacz zapytanie R04-03 - produkty i w panelu Zastosowane kroki usuń ostatni krok
Zmieniono typ. Teraz, kiedy wszystkie kolumny zawierają w nagłówkach spacje zamiast
znaków podkreślenia, wszystkie tabele zostały połączone poprawnie i zniknął symptom
brakujących wartości.
107
4650570396d9eb2765da56c12eb840b5
4
Tabela konwersji
W ćwiczeniu 4.3 zastosowałeś proste przekształcenie nazw niezgodnych kolumn i zastąpiłeś znaki
podkreślenia spacjami. Niestety, w praktyce proste przekształcenia nie wystarczają.
Aby zademonstrować taki przypadek, wróćmy do naszej firmy Fabryka Przygód i danych
użytych w ćwiczeniu 4.2. Tym razem dodatkowo będą zamienione miejscami dwie kolumny,
tak jak w ćwiczeniu 4.3, zatem opisane techniki nie będą działać.
W opisanej niżej serii ćwiczeń wykorzystasz dane zapisane w folderze C:\Dane\R04\R04-04 - produkty.
Każdy z menedżerów inaczej nazwał kolumnę zawierającą identyfikator produktu: ID,
Kod_produktu, Nr_produktu i Kod produktu. Nie możesz więc ujednolicić nagłówków za pomocą
prostych przekształceń. Zamiast tego utworzysz tabelę konwersji zawierającą oryginalne
i ujednolicone nazwy kolumn. Rysunek 4.5 przedstawia niezgodne kolumny i ich reprezentację
w tabeli konwersji. Kolumna Źródło zawiera niezgodną nazwę, która będzie zastąpiona ujednoliconą
nazwą w kolumnie Cel.
RYSUNEK 4.5. Tabela konwersji zawiera powiązane niezgodne i ujednolicone nazwy kolumn
Tworzenie tabeli konwersji może być czasochłonnym zajęciem. Tabela nie musi jednak zawierać
wszystkich nazw. Przykładowo na rysunku 4.5 nie ma pary Nazwa  Nazwa, ponieważ nie jest
potrzebna. Tabela powinna zawierać tylko pary niezgodnych nazw. Jeżeli są setki kolumn, wtedy
w tabeli konwersji należy umieścić tylko różniące się nazwy.
Wskazówka. Jeżeli tabela konwersji jest tabelą zewnętrzną zapisaną w skoroszycie Excela,
można najpierw umieścić w niej kilka niezgodnych nazw kolumn i stopniowo ją uzupełniać
w miarę potrzeb. Po utworzeniu zapytania wykorzystującego tabelę konwersji nie potrzeba go
modyfikować w celu dalszego ujednolicania kolumn. Zamiast tego wystarczy odpowiednio
zmodyfikować tabelę konwersji i odświeżyć raport.
Teraz, gdy wiesz już, jak tworzy się tabelę konwersji, nauczysz się ją wykorzystywać do
ujednolicania niezgodnych kolumn. Użyjesz do tego celu przekształcenia Scal zapytania dostępnego
w karcie Strona główna. Jak pamiętasz z rozdziału 2, „Podstawowe operacje przygotowywania
danych”, przekształcenie to służy do łączenia kilku tabel na podstawie takich samych wartości
zapisanych w określonych kolumnach.
Zanim dowiesz się, jak używać przekształcenia Scal zapytania z tabelą konwersji, zatrzymajmy się
na chwilę, aby omówić jeden z największych problemów z ujednolicaniem kolumn. Pod koniec tego
rozdziału dowiesz się, jak zastępować nazwy kolumn za pomocą funkcji Table.TransformColumnNames
108
4650570396d9eb2765da56c12eb840b5
4
opisanej w ćwiczeniu 4.3, funkcji niestandardowej oraz tabeli konwersji. Ponieważ technika ta
wymaga głębszej znajomości języka M, wcześniej poznasz trzy sposoby wykorzystujące jedynie
interfejs edytora, bez konieczności stosowania zaawansowanych formuł w języku M.
Interfejs edytora Power Query jest wyposażony w wiele przekształceń operujących na kolumnach,
ale nie na ich nagłówkach. Ćwiczenia 4.4, 4.5 i 4.6 skupiają się na ujednolicaniu nazw kolumn przy
użyciu trzech technik wykorzystujących interfejs edytora. Wymagana jest w nich minimalna znajomość
języka M. W tych ćwiczeniach nie jest wykorzystywana funkcja Table.TransformColumnNames,
ponieważ wymagałaby ona utworzenia niestandardowej funkcji. Ćwiczenia te demonstrują, jak
zamiast tego użyć funkcjonalności dostępnych w interfejsie edytora.
Wskazówka. Jeżeli poczułeś się pewnie w języku M, spodoba Ci się czwarta technika, czekająca
na Ciebie pod koniec rozdziału. Prawdopodobnie uznasz, że ćwiczenie 4.7 jest najlepszym
sposobem łączenia niezgodnych tabel i ujednolicania kolumn. Warto jednak, abyś wykonał
poniższe ćwiczenia, dzięki którym docenisz potęgę dostępnych funkcjonalności, jak również
poznasz ich zalety i wady. Ponadto mogą się one przydać w innych sytuacjach.
Ćwiczenie 4.4. Transpozycja z użyciem tabeli konwersji

Aby ujednolicić niezgodne kolumny za pomocą tabeli konwersji, musisz najpierw tymczasowo
przekształcić nazwy kolumn w jednokolumnową tabelę, scalić z nią tabelę konwersji, zastąpić
niezgodne nazwy docelowymi i uzyskanie wyniki z powrotem przekształcić w nagłówki kolumn.
W tym ćwiczeniu poznasz pierwszą z wymienionych wyżej technik. Najpierw zaimportuj tabele
z folderu, wykonując tę samą sekwencję operacji, jak w ćwiczeniach 4.2 i 4.3.
1. Zaimportuj tabelę konwersji.
W Excelu: utwórz nowy skoroszyt, następnie kliknij kartę Dane i polecenia Pobierz dane/
Z pliku/Ze skoroszytu. Wskaż plik R04-04 - tabela konwersji.xlsx. W oknie Nawigator kliknij
tabelę Konwersja_nagłówków, a następnie przycisk Przekształć dane. Na koniec kliknij
Zamknij i załaduj do oraz zaznacz opcję Utwórz tylko połączenie.
W Power BI Desktop: utwórz nowy raport, następnie rozwiń menu Pobierz dane i wybierz
Excel. Wskaż plik R04-04 - tabela konwersji.xlsx. W oknie Nawigator kliknij tabelę
Konwersja_nagłówków, a następnie przycisk Przekształć dane. W panelu Zapytania kliknij
prawym przyciskiem myszy nowe zapytanie i usuń zaznaczenie polecenia Włącz ładowanie.
Na koniec kliknij Zamknij i zastosuj.
2. Zaimportuj następujące pliki znajdujące się w folderze C:\Dane\R04\R04-04 - produkty:
109
4650570396d9eb2765da56c12eb840b5
4
i kliknij OK.
6. W panelu Zapytania kliknij zapytanie Przekształć przykładowy plik i zmień jego nazwę na
Przykładowe produkty. Jak pamiętasz, jest to przykładowe zapytanie, a więc wprowadzone
w nim zmiany będą dotyczyły również zapytania R04-04 - produkty.
7. Zmień nazwę zapytania R04-04 - produkty na Dołączone produkty. Zapisz skoroszyt lub
raport, a następnie utwórz jego trzy kopie, które wykorzystasz w ćwiczeniach 4.5, 4.6 i 4.7.
Transpozycja
Pierwsza technika ujednolicania nazw kolumn polega na użyciu przekształcenia Transponuj
dostępnego w kolumnie Przekształć. W jego efekcie każda komórka kolumny X i wiersza Y jest
zamieniana na kolumnę Y i wiersz X.
W edytorze Power Query o wiele łatwiej manipulować nazwami kolumn, jeżeli są one ułożone
pionowo w jednej kolumnie. W tym momencie przydaje się przekształcenie Transponuj.
Jednak przy próbie transpozycji tabeli przekonasz się, że nie są zachowywane oryginalne nazwy
kolumn. Aby tego uniknąć, musisz anulować użycie pierwszego wiersza tabeli jako nazw kolumn.
W tym celu otwórz skoroszyt lub raport, który utworzyłeś w krokach od 1. do 7., i uruchom edytor
Power Query. W panelu Zapytania zaznacz zapytanie Przykładowe produkty i wykonaj
następujące kroki.
8. W panelu Zastosowane kroki usuń krok Nagłówki o podwyższonym poziomie.
Nagłówki kolumn zostaną umieszczone w pierwszym wierszu tabeli.
9. W karcie Przekształć kliknij ikonę Transponuj. Teraz kolumna Column1 zawiera nazwy
kolumn, które trzeba ujednolicić.
Sekwencja scaleń
Dotarłeś do punktu, w którym scalisz tabelę konwersji z przetransponowaną tabelą i za jednym
razem zamienisz niezgodne nazwy kolumn na docelowe. Wykonaj następujące kroki.
10. Zaznacz zapytanie Przykładowe produkty, a następnie w karcie Strona główna kliknij ikonę
Scal zapytania.
11. W oknie Scalanie, które się pojawi, kliknij w tabeli Przykładowe produkty kolumnę Column1,
a następnie z rozwijanej listy pod tabelą wybierz Konwersja_nagłówków (patrz rysunek 4.6).
W tabeli niżej zaznacz kolumnę Źródło.
12. Sprawdź, czy w rozwijanej liście Rodzaj sprzężenia jest wybrana opcja Lewe zewnętrzne
(wszystkie z prawej, pasujące z drugiej), a następnie kliknij OK.
13. W ostatniej kolumnie, Konwersja_nagłówków, zawierającej obiekty Table, kliknij przycisk po
prawej stronie nagłówka lub zaznacz całą kolumnę i w karcie Przekształć kliknij ikonę Rozwiń.
14. Aby wyodrębnić kolumnę Cel z tabeli Konwersja_nagłówków, usuń w panelu, który się pojawi,
zaznaczenie Źródło i kliknij OK. Pojawi się nowa kolumna o nazwie Konwersja_nagłówków.Cel.
Kolumna ta zawiera wartość z kolumny Cel, jeżeli wartość w kolumnie Column1 jest taka sama
jak w kolumnie Źródło tabeli konwersji, lub jest to wartość null w przeciwnym przypadku.
W tym drugim przypadku zostaną użyte oryginalne nazwy kolumn.
110
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 4.6. Tabelę konwersji i przekształcenie „Scal zapytania” można wykorzystać do ujednolicenia
niezgodnych nazw kolumn
W następnym kroku wykorzystasz kolumnę warunkową zawierającą docelowe nazwy

z kolumny Konwersja_nagłówków.Cel lub oryginalne nazwy, jeżeli nie będą wymienione
w tabeli konwersji.
15. W karcie Dodaj kolumnę kliknij ikonę Kolumna warunkowa. Pojawi się okno Dodawanie
kolumny warunkowej. Wykonaj poniższe kroki, aby ustawić opcje pokazane na rysunku 4.7.
a. W polu Nazwa nowej kolumny wpisz Nowe nazwy kolumn.
b. W rozwijanej liście Nazwa kolumny wybierz Konwersja_nagłówków.Cel.
c. W polu Wartość wpisz null.
d. W lewej rozwijanej liście pod etykietą Wartość wyjściowa wskaż Wybierz kolumnę.
e. W prawej rozwijanej liście pod etykietą Wartość wyjściowa wybierz Column1.
f. W lewej rozwijanej liście pod etykietą W przeciwnym razie wskaż Wybierz kolumnę.
g. W prawej rozwijanej liście pod etykietą W przeciwnym razie wybierz
Konwersja_nagłówków.Cel i kliknij OK.
111
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 4.7. W oknie „Dodawanie kolumny warunkowej” można utworzyć nową kolumnę zawierającą wartości
pochodzące z różnych kolumn w zależności od spełnienia zadanych warunków. W tym przypadku nowa
kolumna będzie zawierała nazwy ujednolicone lub oryginalne, jeżeli nie zostaną znalezione w tabeli konwersji
16. Usuń kolumny Column1 i Konwersja_nagłówków.Cel.

17. Przenieś kolumnę Nazwy nowych kolumn na początek tabeli, przeciągając ją po prostu
z prawej strony na lewą lub stosując poniższą wskazówkę.
Wskazówka. Jeżeli kolumn jest dużo i musisz jedną z nich przenieść na początek tabeli, wtedy
zamiast przeciągać, zaznacz ją, a następnie kliknij w karcie Przekształć ikonę Przenieś i Na początek.
Ewentualnie kliknij prawym przyciskiem myszy nagłówek kolumny i z podręcznego menu
wybierz polecenia Przenieś i Na początek.
Uwaga. Zmienianie kolejności kolumn tabeli jest dość ryzykowną operacją. W rozdziale 10.,
„Od złych do dobrych zapytań”, dowiesz się, jak unikać związanych z tą operacją problemów.
Podczas przenoszenia kolumny formuła odwołująca się do kolumn tworzy podatne za zakłócenia
zapytanie, które może uniemożliwić odświeżenie raportu, jeżeli jakiejś kolumny zabraknie lub
zostanie zmieniona jej nazwa.
Powtórna transpozycja
W kroku 9. przetransponowałeś tabelę i umieściłeś nagłówki w kolumnie Column1. Przy użyciu
transpozycji mogłeś skonsolidować oryginalne nagłówki w kolumnie Column1 z nazwami w kolumnie
Źródło w tabeli konwersji. Następnie za pomocą kolumny warunkowej zamieniłeś niezgodne nagłówki
na nazwy z kolumny Cel tabeli konwersji. Teraz kolumna Column1 zawiera ujednolicone wartości,
których można użyć jako nazw nagłówków. Czas z powrotem przetransponować tabelę i odtworzyć
nagłówki z kolumny Column1. Wykonaj poniższe kroki.
18. W karcie Przekształć kliknij ikonę Transponuj. Nazwy kolumn znajdą się w pierwszym
wierszu tabeli, dlatego musisz je przenieść z powrotem do nagłówków.
19. W karcie Przekształć kliknij ikonę Użyj pierwszego wiersza jako nagłówków.
20. W panelu Zapytania zaznacz zapytanie Dołączone produkty. Jeżeli w panelu podglądu pojawi
się błąd, usuń z panelu Zastosowane kroki krok Zmieniono typ. Zadanie wykonane.
112
4650570396d9eb2765da56c12eb840b5
4
Gotowe rozwiązanie znajduje się w plikach R04-04 - rozwiązanie - transpozycja.xlsx

i R04-04 - rozwiązanie - transpozycja.pbix.
Niestety, opisana technika jest skuteczna tylko w przypadku niewielkich ilości danych. Duże
tabele, złożone z bardzo wielu wierszy zajmują mnóstwo pamięci. Power Query obsługuje tabele
zawierające maks. 16 384 kolumn. Przy próbie transpozycji tabeli złożonej z więcej niż 16 384
wierszy pojawi się komunikat o błędzie, dane będą importowane przez długi czas i zajmą dużo
pamięci. Jednak nawet w przypadku tabeli złożonej np. z 15 000 wierszy należy z powodu zajętości
pamięci i długotrwałego odświeżania danych zastosować inną technikę. Potrzebne jest rozwiązanie,
które nie zawiedzie nawet przy dużych tabelach.
Ćwiczenie 4.5. Anulowanie przestawienia,

scalenie i powtórne przestawienie
Lepszym sposobem umieszczenia nazw kolumn w nowej kolumnie i przygotowania jej do scalenia
z tabelą konwersji jest użycie przekształcenia Anuluj przestawienie. W tym ćwiczeniu dowiesz się,
jak je stosować i jak przywrócić ujednolicone nazwy za pomocą przekształcenia Tabela przestawna.
Zobacz też. W rozdziale 6., „Rozdzielanie tabel”, opisano wiele różnych zastosowań
przekształcenia Anuluj przestawienie, natomiast rozdział 7., „Zaawansowane metody
przestawiania tabel i anulowania przestawień”, zawiera praktyczne przykłady użycia
przekształcenia Tabela przestawna.
W tym ćwiczeniu wykorzystasz plik, który utworzyłeś w ćwiczeniu 4.4, w krokach od 1. do 7.

1. Otwórz kopię skoroszytu lub raportu, którą utworzyłeś w ćwiczeniu 4.4, w kroku 7.,
a następnie uruchom edytor Power Query.
2. W panelu Zapytania zaznacz zapytanie Przykładowe produkty, a następnie w karcie Dodaj
kolumnę kliknij ikonę Kolumna indeksu. W następnym kroku dowiesz się, do czego ta
kolumna będzie potrzebna.
3. Zaznacz kolumnę Indeks, kliknij prawym przyciskiem myszy jej nagłówek i wybierz
polecenie Anuluj przestawienie innych kolumn. Powstanie nowa tabela zawierająca kolumny
Indeks, Atrybut i Wartość. Kolumna Indeks zawiera identyfikator wiersza, który w kroku 6.
wykorzystasz do przywrócenia tabeli do pierwotnej postaci. Kolumna Atrybut zawiera nazwy
kolumn, a kolumna Wartość oryginalne wartości. Teraz możesz w kolumnie Atrybut
zastosować funkcje przekształcające tekst.
4. Zmień nazwę kolumny Atrybut na Column1, by wykonać następne kroki.
5. Aby zmienić nazwy niezgodnych kolumn, wykonaj sekwencję scaleń opisaną w ćwiczeniu
4.4, w krokach od 10. do 17.
6. Aby z powrotem przestawić tabelę, zaznacz kolumnę Nowe nazwy kolumn i w karcie
Przekształć kliknij ikonę Kolumna przestawna.
Zobacz też. Przekształcenie Kolumna przestawna jest bardzo przydatne. W rozdziale 7. dowiesz
się, jak można je wykorzystywać do przetwarzania tabel o nieuporządkowanej strukturze.
113
4650570396d9eb2765da56c12eb840b5
4
7. W oknie Kolumna przestawna wybierz w rozwijanej liście Kolumna wartości pozycję

Wartość, rozwiń sekcję Opcje zaawansowane i w rozwijanej liście Agreguj funkcję wartości
wybierz pozycję Nie agreguj. Kliknij OK.
8. Usuń kolumnę Indeks.
9. W panelu Zapytania zaznacz zapytanie Dołączone produkty. Jeżeli pojawi się komunikat
o błędzie, usuń w panelu Zastosowane kroki ostatni krok Zmieniono typ.
Gotowe rozwiązanie znajduje się w plikach R04-05 - rozwiązanie - anulowanie przestawienia.xlsx
i R04-05 - rozwiązanie - anulowanie przestawienia.pbix.
Przekształcenie Anulowanie przestawienia można wprawdzie stosować w przypadku dużych
ilości danych, ale przekształcenie Kolumna przestawna, przywracające tabelę do pierwotnej postaci,
może zajmować sporo pamięci i spowalniać odświeżanie raportu. Przyczyną jest konieczność
przeglądania przez Power Query całego zbioru danych, wyszukiwanie w kolumnie Column1
unikatowych wartości, a następnie tworzenie z nich nowej kolumny. Dlatego nie jest to idealna
technika, jeżeli danych jest dużo, tabele trzeba łączyć sprawnie, a raporty muszą się odświeżać szybko.
Ćwiczenie 4.6. Transpozycja samych nazw kolumn

Wydajną metodą przekształcania nazw kolumn dużej tabeli w nową kolumnę i przygotowywania
jej do skonsolidowania z tabelą konwersji jest transpozycja samych nazw kolumn. Jest to pośrednie
przekształcenie, po którym następuje scalenie zapytań. Rysunek 4.8 przedstawia proces transpozycji
nazw kolumn, ujednolicenia nazw i powtórnej transpozycji przywracającej tabeli oryginalną postać.
RYSUNEK 4.8. Ujednolicenie nazw kolumn wymaga wykonania dziewięciu przekształceń
114
4650570396d9eb2765da56c12eb840b5
4
Technika pokazana na rysunku 4.8 jest prosta w implementacji, jeżeli trzeba połączyć kilka tabel
za pomocą przekształcenia Dołącz zapytania. Jednak komplikuje się w przypadku importu plików
z folderu, ponieważ wymaga zastosowania niestandardowych funkcji. Tutaj została pokazana
jedynie w celach demonstracyjnych. Możesz ją stosować wtedy, gdy z powodów wydajnościowych
nie będziesz mógł wykorzystać technik opisanych w ćwiczeniach 4.4 i 4.5 lub nie chcesz używać
języka M wykorzystanego w ćwiczeniu 4.7.
1. Otwórz kopię skoroszytu lub raportu, którą utworzyłeś w ćwiczeniu 4.4, w krokach od 1.
do 7., a następnie uruchom edytor Power Query.
2. W panelu Zapytania zaznacz zapytanie Przykładowe produkty, a następnie w panelu
Zastosowane kroki usuń krok Nagłówki o podwyższonym poziomie. W ten sposób nazwy
kolumn zostaną umieszczone w pierwszym wierszu tabeli.
3. W panelu Zapytania kliknij prawym przyciskiem myszy zapytanie Przykładowe produkty,
a następnie wybierz polecenie Duplikuj. Zaznacz zapytanie Przykładowe produkty (2),
w kolumnie Strona główna kliknij ikonę Zachowaj wiersze i polecenie Zachowywanie
pierwszych wierszy. W oknie, które się pojawi, wpisz w polu Liczba wierszy liczbę 1
i kliknij OK.
Uwaga. Power Query podczas łączenia plików zapisanych w folderze tworzy funkcję zapytania,
przykładowe zapytanie, zapytanie pliku i parametr. Obiekty te są wykorzystywane do łączenia
kilku plików na podstawie wskazanego pliku. Podstawowe przekształcenie każdego pliku jest
zaimplementowane w funkcji. W celu dostosowania przekształcenia indywidualnie do każdego
pliku wprowadza się zmiany w przykładowym zapytaniu. W tym ćwiczeniu takim zapytaniem jest
Przekształć przykładowy plik, które przemianowałeś na Przykładowe produkty. Zmiany wprowadzane
w przykładowym zapytaniu są przenoszone do funkcji i w efekcie stosowane we wszystkich
plikach w folderze. Jeżeli użyjesz przekształcenia Duplikuj lub Odwołanie w przykładowym
zapytaniu, wtedy przekształcenia zastosowane w nowym zapytaniu nie będą przenoszone do
funkcji, chyba że zastosujesz zaawansowaną technikę wiążącą nowe zapytanie z sekwencją
przekształceń w przykładowym zapytaniu. Takie wiązanie wykonasz w krokach 21. i 22.
4. W karcie Przekształć kliknij ikonę Transponuj, aby przygotować tabelę do ujednolicenia.

W tym miejscu mógłbyś wykonać sekwencję scaleń podobną do opisanej w krokach od 10.
do 17. ćwiczenia 4.4. Jednak tutaj nie możesz tego zrobić, ponieważ musisz wprowadzić kilka
ważnych modyfikacji.
5. Zaznacz zapytanie Przykładowe produkty (2) i w karcie Strona główna kliknij ikonę Scal
zapytania.
6. W oknie Scalanie zaznacz w tabeli Przykładowe produkty (2) kolumnę Column1, a w rozwijanej
liście niżej wybierz pozycję Konwersja_nagłówków. Zaznacz kolumnę Źródło, tak jak
w ćwiczeniu 4.4 (patrz rysunek 4.6).
7. Sprawdź, czy w rozwijanej liście Rodzaj sprzężenia wybrana jest opcja Lewe zewnętrzne
(wszystkie z prawej, pasujące z drugiej), a następnie kliknij OK. Pojawi się nowa kolumna
o nazwie Konwersja_nagłówków zawierająca obiekty Table.
8. Teraz musisz utworzyć kolumnę indeksu, dzięki której w następnym kroku nie zmieni się
kolejność nazw kolumn w kolumnie Column1. Kliknij w karcie Dodaj kolumnę ikonę
Kolumna indeksu. W kroku 13. dowiesz się, dlaczego jest to ważne.
115
4650570396d9eb2765da56c12eb840b5
4
9. Zaznacz kolumnę Konwersja_nagłówków, a następnie w karcie Przekształć kliknij ikonę

Rozwiń.
10. W oknie Rozwiń Konwersja_nagłówków usuń zaznaczenie Źródło i kliknij OK. Nowa kolumna
zostanie przekształcona w Konwersja_nagłówków.Cel zawierającą wartość z kolumny Cel,
jeżeli wartość w kolumnie Column1 będzie taka sama jak w kolumnie Źródło tabeli
konwersji, lub null w przeciwnym przypadku.
11. W kolumnie Dodaj kolumnę kliknij Kolumna warunkowa.
12. W oknie Dodawanie kolumny warunkowej wykonaj następujące kroki.
a. W polu Nazwa nowej kolumny wpisz Nowe nazwy kolumn.
b. W rozwijanej liście Nazwa kolumny wybierz Konwersja_nagłówków.Cel.
c. W polu Wartość wpisz null.
d. W lewej rozwijanej liście pod etykietą Wartość wyjściowa wskaż Wybierz kolumnę.
e. W prawej rozwijanej liście pod etykietą Wartość wyjściowa wybierz Column1.
f. W lewej rozwijanej liście pod etykietą W przeciwnym razie wskaż Wybierz kolumnę.
g. W prawej rozwijanej liście pod etykietą W przeciwnym razie wybierz
Konwersja_nagłówków.Cel i kliknij OK.
13. Sprawdź, czy wartości w kolumnie Indeks są ułożone w kolejności rosnącej. Jeżeli nie,
posortuj je, ponieważ kolejność nazw kolumn jest tutaj bardzo ważna. W kroku 9.
rozszerzyłeś tabelę, a w tym kroku kolejność wierszy mogła zostać zaburzona. Dlatego
do zachowania właściwej kolejności nazw jest wykorzystywana kolumna Indeks, którą
utworzyłeś w kroku 8.
14. Usuń kolumny Column1, Konwersja_nagłówków.Cel i Indeks. Zachowaj tylko ostatnią
kolumnę, czyli Nowe nazwy kolumn.
15. W kolumnie Przekształć kliknij ikonę Transponuj. W ten sposób uzyskasz ujednolicone
nazwy kolumn.
Zakończyłeś ujednolicanie nazw kolumn w zapytaniu Przykładowe produkty (2), oznaczone
numerem 5 na rysunku 4.4. Teraz możesz wykonać pozostałą sekwencję przekształceń.
16. Aby usunąć stare nagłówki, wróć do oryginalnego zapytania Przykładowe produkty. Zaznacz je,
a następnie w karcie Strona główna kliknij ikonę Usuń wiersze i polecenie Usuwanie pierwszych
wierszy. W oknie, które się pojawi, wpisz w polu Liczba wierszy liczbę 1 i kliknij OK.
17. W karcie Strona główna kliknij ikonę Dołącz zapytania. W oknie Dołączanie, które się
pojawi, wybierz w rozwijanej liście Tabela do dołączania pozycję Przykładowe produkty (2)
i kliknij OK.
18. Zwróć uwagę, że tym razem w panelu podglądu ujednolicone nazwy kolumn zawarte w tabeli
Przykładowe produkty (2) pojawiły w ostatnim wierszu. Dlatego musisz tabele zamienić
miejscami. W pasku formuły znajduje się następujący kod:
= Table.Combine({#"Usunięto pierwsze wiersze", #"Przykładowe produkty (2)"})
Zamień w powyższej formule miejscami zmienne #"Usunięto pierwsze wiersze"
i #"Przykładowe produkty (2)", tak jak niżej:
= Table.Combine({#"Przykładowe produkty (2)", #"Usunięto pierwsze wiersze"})
116
4650570396d9eb2765da56c12eb840b5
4
19. Teraz, gdy ujednolicone nazwy kolumn znalazły się w pierwszym wierszu, możesz je
przenieść do nagłówków. W tym celu kliknij w karcie Przekształć ikonę Użyj pierwszego
wiersza jako nagłówków, a w panelu Zastosowane kroki usuń wiersz Zmieniono typ.
Uwaga. Usunięcie kroku Zmieniono typ jest bardzo ważne. Ponieważ kolumna Wielkość w tabeli
Akcesoria zawiera wyłącznie liczby, edytor Power Query ustala jej typ na Liczba całkowita.
Jednak w innych tabelach, np. Rowery, w tej kolumnie znajdują się poprawne wartości tekstowe.
Jeżeli nie usuniesz kroku zmieniającego typ kolumn, pojawią się komunikaty o błędach, a kolumna
Wielkość będzie zawierała tylko liczby.
20. W panelu Zapytania zaznacz zapytanie Dołączone produkty. Błąd, który się pojawi, możesz
poprawić, usuwając z panelu Zastosowane kroki krok Zmieniono typ.
Teraz, gdy przewiniesz tabelę do momentu, aż w kolumnie Source.Name pojawi się wartość
R04-04 - rowery.xlsx, zauważysz, że wartości w kolumnach Nazwa i Kod produktu są
zamienione miejscami (patrz rysunek 4.9). Zatem opisane ujednolicenie nie działa poprawnie.
RYSUNEK 4.9. W zapytaniu Dołączone produkty wartości Nazwa i Kod produktu

pobrane z tabeli Rowery są zamienione miejscami
Wskazówka. Sprawdzenie końcowego efektu jest ważną czynnością w Power Query. Zawartość
panelu podglądu może być bardzo myląca, jak w tym przykładzie, ponieważ stanowi ona tylko
część danych. Tutaj wszystko działało jak należy dla tabeli Akcesoria, ale po bliższym przyjrzeniu
się połączonej tabeli okazało się, że zawartość kolumn Nazwa i Kod produktu pobrane z tabeli
Rowery są zamienione miejscami. Dlatego zawsze dokładnie sprawdzaj wynikowe dane.
117
4650570396d9eb2765da56c12eb840b5
4
Zatrzymajmy się na chwilę, aby zrozumieć, co się stało i dlaczego ujednolicenie nie działa
poprawnie. Dobra wiadomość jest taka, że zapytanie Przykładowe produkty (2) działa poprawnie
dla pojedynczego pliku. Gdy je klikniesz, zauważysz, że w ostatnim kroku w panelu
Zastosowane kroki nagłówki kolumn zostały ujednolicone zgodnie z oczekiwaniami. Zła jest
jednak wiadomość, że ujednolicenie obejmuje tylko jeden plik. Gdy przykładowe zapytanie
zostało zastosowane w przykładowej funkcji w odniesieniu do wszystkich plików w folderze,
bezkrytycznie przekształciło wszystkie nagłówki we wszystkich plikach.
Dlaczego wykorzystywany jest ten sam pojedynczy plik? Spójrz na zapytanie Przykładowe
produkty (2). Gdy w panelu Zastosowane kroki zaznaczysz krok Źródło, wtedy w panelu
formuły pojawi się kod ładujący arkusz Excela wskazany w parametrze Parametr1. Parametr
ten został utworzony przez Power Query podczas łączenia plików zapisanych w folderze.
Gdy klikniesz ten parametr w panelu Zapytania, zobaczysz, że ma on wartość Przykładowy
plik. Zapytanie o tej nazwie również znajduje się w panelu Zapytania i zwraca zawartość
skoroszytu R04-04 - akcesoria.xlsx.
Dlaczego więc zostały zamienione miejscami wartości kolumn Nazwa i Kod produktu z tabeli
Rowery? Ponieważ w skoroszycie R04-04 - akcesoria.xlsx powyższe kolumny są ułożone
w innej kolejności niż w R04-04 - rowery.xlsx. Nie można zatem zastosować ujednolicenia
przystosowanego do tabeli Akcesoria w odniesieniu do tabel, w których kolejność kolumn
jest inna.
Aby poprawić ten błąd, musisz się dowiedzieć, jak stosować zapytanie Przykładowe produkty (2)
indywidualnie dla każdego pliku w folderze. Jak pamiętasz, w kroku 3. tego ćwiczenia zapytanie
Przykładowe produkty (2) utworzyłeś poprzez zduplikowanie zapytania Przykładowe produkty.
Jest to przykładowe zapytanie wykonywane dla każdego pliku, wywołujące zapytanie
Przykładowe produkty (2). Ponieważ jednak Przykładowe produkty (2) nie jest już
przykładowym zapytaniem, jest wykonywane tylko dla pliku R04-04 - akcesoria.xlsx.
Potrzebny jest więc sposób przekształcenia zapytania Przykładowe produkty (2) tak, aby
wykorzystywało parametr z nazwą pliku z zapytania Przykładowe produkty i ujednolicało
nagłówki we wszystkich plikach. W tym celu musisz przekształcić zapytanie Przykładowe
produkty (2) w funkcję (zwaną również funkcją niestandardową), która będzie wywoływana
podczas przetwarzania każdego pliku zapisanego w folderze. Wykonaj poniższe kroki, aby
utworzyć taką funkcję na podstawie zapytania Przykładowe produkty (2).
21. W panelu Zapytania kliknij prawym przyciskiem myszy zapytanie Przykładowe produkty (2)
i wybierz polecenie Utwórz funkcję. Pojawi się okno o tej samej nazwie. W polu Nazwa funkcji
wpisz FnUjednolicenieNazwKolumn i kliknij OK. Jak pokazuje rysunek 4.10, zostanie utworzona
funkcja, która będzie wywoływana dla wszystkich plików.
Teraz funkcja FnUjednolicenieNazwKolumn będzie wywoływana przez zapytanie
Przykładowe produkty, a nie przez Przykładowe produkty (2).
22. W panelu Zapytania zaznacz zapytanie Przykładowe produkty, a w panelu Zastosowane kroki
zaznacz krok Dołączone zapytanie. W pasku formuły pojawi się następujący kod:
= Table.Combine({#"Przykładowe produkty (2)", #"Usunięto pierwsze wiersze"})
Zastąp go poniższym kodem:
= Table.Combine({FnUjednolicenieNazwKolumn(#"Parametr1"), #"Usunięto pierwsze wiersze"})
118
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 4.10. Funkcja FnUjednolicenieNazwKolumn z przykładowym zapytaniem „Przykładowe produkty (2)”
Funkcja FnUjednolicenieNazwKolumn odczytuje zawartość skoroszytu Excela podanego w jej

argumencie i zwraca ujednolicone nazwy kolumn. Tabela #"Usunięto pierwsze wiersze"
jest tworzona w ostatnim kroku zapytania Przykładowe produkty przed dołączeniem jej do
wyniku. Zawiera ona wiersze danych bez nagłówków.
Dlaczego wykorzystywany jest tutaj parametr #"Parametr1"? Jak pamiętasz, parametr ten
w zapytaniu Przykładowe produkty (2) zawsze zawiera nazwę pliku z akcesoriami. Jednak
teraz, w kontekście funkcji, zawiera nazwę odpowiedniego pliku, określonego przez
zapytanie Przykładowe produkty.
23. Wróć do zapytania Dołączone produkty i przewiń zawartość panelu podglądu do chwili
pojawienia się w kolumnie Source.Name wartości R04-04 - rowery.xlsx. Jak się przekonasz,
dane zostały umieszone we właściwych kolumnach. Zamknij edytor Power Query i załaduj
dane do raportu.
Gotowe rozwiązanie znajduje się w plikach R04-06 - rozwiązanie - transpozycja nagłówków.xlsx
i R04-06 - rozwiązanie - transpozycja nagłówków.pbix.
Ćwiczenie 4.7. Ujednolicenie nazw kolumn za pomocą języka M

W tym ćwiczeniu opisana jest najskuteczniejsza metoda ujednolicania nazw kolumn przy użyciu
tabeli konwersji. Polega ona na użyciu języka M i zastosowaniu tabeli konwersji bezpośrednio
w odniesieniu do nazw kolumn.
Jak pamiętasz, w ćwiczeniu 4.3 wykonałeś proste przekształcenie nazw kolumn za pomocą funkcji
Table.TransformColumnNames, której drugim argumentem była właściwa funkcja modyfikująca tekst,
np. Text.Proper, która zamieniała pierwsze litery każdego słowa na wielkie.
119
4650570396d9eb2765da56c12eb840b5
4
W ostatnim ćwiczeniu utworzysz niestandardową funkcję, która ujednolici nazwy kolumn

według reguł zdefiniowanych w tabeli konwersji. Wcześniej jednak musisz poznać jeszcze jedno
przekształcenie, przy użyciu którego kod będzie prostszy i będzie szybciej przeszukiwał tabelę
konwersji. Jak pamiętasz, tabela ta zawiera pary wartości Źródło i Cel. Teraz przetransponujesz tę
tabelę i użyjesz pierwszego wiersza jako nagłówków. W nowej tabeli wartości źródłowe będą
nagłówkami kolumn, a docelowe będą umieszczone w pierwszym wierszu, tak jak na rysunku 4.11.
RYSUNEK 4.11. Transpozycja oryginalnej tabeli konwersji skutkuje utworzeniem jednowierszowej tabeli
zawierającej wartości źródłowe i docelowe, dzięki czemu metoda ujednolicania nazw kolumn jest
bardziej wydajna
Po takim przekształceniu funkcja niestandardowa będzie wyszukiwała wartości źródłowe

w nagłówkach tabeli i odczytywała wartości docelowe z wiersza. Aby przetransponować tabelę
konwersji, wykonaj poniższe kroki.
1. Otwórz kopię skoroszytu lub raportu, który utworzyłeś w ćwiczeniu 4.4, w krokach od 1. do 7.
2. W panelu Zapytania zaznacz zapytanie Konwersja_nagłówków.
3. W karcie Przekształć kliknij ikonę Transponuj, a następnie Użyj pierwszego wiersza jako
nagłówków.
4. W panelu Zastosowane kroki usuń automatycznie utworzony krok Zmieniono typ1. Nie jest
on potrzebny i jeżeli go nie usuniesz, zmiany, które będziesz wprowadzał w przyszłości
w kolumnie Źródło, mogą uniemożliwiać odświeżanie raportu.
5. W panelu Zapytania zaznacz zapytanie Przykładowe produkty, a następnie w pasku formuły
kliknij przycisk fx, tak jak w ćwiczeniu 4.3, w kroku 7.
6. W pasku formuły pojawi się poniższy kod:
= #"Nagłówki o podwyższonym poziomie"

= Table.TransformColumnNames(#"Nagłówki o podwyższonym poziomie",
each try Table.Column(Konwersja_nagłówków, _){0} otherwise _)
7. Naciśnij Enter i sprawdź nagłówki kolumn w panelu podglądu. Jak się przekonasz, zostały
ujednolicone. Teraz kliknij zapytanie Dodane produkty i sprawdź, czy niezgodne tabele
zostały poprawnie połączone.
Przeanalizujmy krótko powyższe wyrażenie. W ćwiczeniu 4.3 wykorzystałeś funkcję
Table.TransformColumnNames. Tym razem skupimy się na jej drugim argumencie:
each try Table.Column(Konwersja_nagłówków, _){0} otherwise _
W rozdziale 9. dokładniej poznasz tego rodzaju wyrażenia. Kombinacja słowa kluczowego each
i znaku podkreślenia jest skróconą definicją funkcji. W tym przypadku argumentem funkcji
Table.TransformColumnNames jest inna funkcja, która za pomocą słowa each i znaku podkreślenia
jest wywoływana dla każdej nazwy kolumny.
120
4650570396d9eb2765da56c12eb840b5
4
Wróćmy teraz do podstaw składni i przeanalizujmy powyższe wyrażenie krok po kroku.

Do odwołania się do pierwszej komórki wiersza w tabeli konwersji użyłeś zapisu {0}. Jak pamiętasz,
wartości indeksu w języku M zaczynają się od zera, zatem w celu odwołania się do pierwszej
komórki należy użyć zera, a nie jedynki. Nawiasy klamrowe definiują listę, do której elementów
można odwoływać się za pomocą indeksu.
Załóżmy, że tabela Konwersja_nagłówków zawiera kolumnę Kolumna1. Aby odwołać się do listy
wartości w kolumnie Kolumna1, należy użyć następującego wyrażenia:
Konwersja_nagłówków[Kolumna1]
W naszej formule nazwę kolumny reprezentuje znak podkreślenia umieszczony w argumencie
funkcji. Aby odwoływać się do poszczególnych kolumn tabeli Konwersja_nagłówków za pomocą ich
nazw, należy użyć następującej funkcji:
each Table.Column(Konwersja_nagłówków, _)
Zwróć uwagę, że użyta została funkcja Table.Column. Poniższe wyrażenie nie jest poprawne:
each Konwersja_nagłówków[_]
Wyrażenie to odwołuje się do kolumny o nazwie _ i w efekcie pojawi się następujący komunikat:
Expression.Error: Nie można znaleźć kolumny „_” w tabeli.
Aby uniknąć tego problemu, należy użyć funkcji Table.Column, której argumentami są nazwa
tabeli i nazwa funkcji, a zwracanym wynikiem lista kolumn. Łącząc oba opisane wyrażenia, można
odwoływać się do wartości docelowej za pomocą wartości źródłowej będącej nazwą kolumny
w przetransponowanej tabeli konwersji utworzonej w kroku 3.
each Table.Column(Konwersja_nagłówków, _){0}
Dlaczego w kroku 6. zostały dodatkowo użyte słowa try/otherwise? Jak wiesz, tabela konwersji
nie zawiera wszystkich nazw kolumn, a jedynie te niezgodne. Dlatego wyrażenie z kroku 6. zawiera
słowa try/otherwise wyróżnione pogrubioną czcionką:
each try Table.Column(Konwersja_nagłówków, _){0} otherwise _
Jeżeli wartość źródłowa nie zostanie znaleziona w tabeli Konwersja_nagłówków, wtedy wyrażenie
po słowie try nie zostanie wykonane. Zamiast niego zostanie wykonane wyrażenie po słowie
otherwise zwracające wartość źródłową.
Poniżej ponownie jest pokazana cała funkcja:
= Table.TransformColumnNames(#"Nagłówki o podwyższonym poziomie",
each try Table.Column(Konwersja_nagłówków, _){0} otherwise _)
Funkcję tę można przełożyć na naturalny język w następujący sposób: „weź tabelę utworzoną
w kroku Nagłówki o podwyższonym poziomie i zmień nazwy jej kolumn według następującej reguły:
spróbuj znaleźć w tabeli konwersji kolumnę o nazwie takiej jak kolumna w powyższej tabeli. Jeżeli
się uda, zwróć znajdującą się w tej kolumnie nazwę docelową. W przeciwnym przypadku zwróć
nazwę kolumny z tabeli Nagłówki o podwyższonym poziomie”.
Jeżeli nie rozumiesz wszystkich opisanych tu zawiłości, nie przejmuj się. Do łączenia niezgodnych
tabel przy użyciu tabeli konwersji możesz stosować metody opisane w ćwiczeniach 4.4, 4.5 i 4.6.
Celem ćwiczenia 4.7 było pokazanie, jak szybko można łączyć niezgodne tabele za pomocą języka M.
Warto, abyś wrócił do tego ćwiczenia, gdy po przeczytaniu rozdziału 9. dowiesz się więcej o tym języku.
Gotowe rozwiązanie znajduje się w plikach R04-07 - rozwiązanie - język M.xlsx
i R04-07 - rozwiązanie - język M.pbix.
121
4650570396d9eb2765da56c12eb840b5
4
Podsumowanie
W tym rozdziale poznałeś skutki łączenia niezgodnych tabel oraz różne techniki umożliwiające
wiązanie nazw kolumn i pomyślne łączenie tabel.
Dowiedziałeś się, jak rozpoznawać symptomy niezgodności tabel, takie jak podział danych
i brakujące wartości. Nauczyłeś się również ręcznie zmieniać nazwy kolumn przed połączeniem tabel.
Jeżeli we wszystkich tabelach zapisanych w folderze kolumny są ułożone w takiej samej kolejności,
wtedy możesz stosować technikę uzgadniania nagłówków. Poznałeś funkcję Table.TransformColumnNames
i użyłeś jej do wykonania prostych przekształceń nazw kolumn, takich jak zamiana pierwszych liter
słów z małych na wielkie oraz zastąpienie znaków podkreślenia spacjami.
Za pomocą tabeli konwersji można ujednolicać nazwy kolumn w sytuacjach, gdy nie jest możliwe
użycie funkcji przekształcających tekst. Poznałeś trzy techniki wykorzystujące tabelę konwersji do
zmiany niezgodnych nagłówków: transpozycję, anulowanie przestawienia i transpozycję samych
nazw kolumn. Na koniec zastosowałeś najskuteczniejszą metodę ujednolicania nagłówków
wykorzystującą kod w języku M.
Poniższa tabela zawiera podsumowanie opisanych technik wraz z ich zaletami i wadami.
Technika Zalety Wady

1. Uzgodnienie nagłówków Prosta i wydajna implementacja. Jeżeli tabele różnią się
kolejnością kolumn, wtedy
wartości są zamienione
miejscami.
2. Transpozycja, scalenie Prosta implementacja Duże zapotrzebowanie na
i ponowna transpozycja uwzględniająca różnice pamięć. Technika nieskuteczna,
w kolejności kolumn. jeżeli połączona tabela składa się
z więcej niż 16 384 wierszy.
3. Anulowanie przestawienia, Prosta implementacja Technika znacznie wolniejsza
scalenie i przestawienie przystosowana do dużych ilości od 1., 4. i 5.
danych, uwzględniająca różnice
w kolejności kolumn.
4. Transpozycja samych Technika uwzględniająca Najdłuższy czas implementacji.
nazw kolumn różnice w kolejności kolumn.
Odświeżanie raportu odbywa się
znacznie szybciej niż
w technikach 2 i 3.
5. Ujednolicenie nazw kolumn Najskuteczniejsza technika Wymagana znajomość języka M.
przy użyciu języka M pod względem wydajności.
Szybka implementacja.
Możliwość łączenia niezgodnych tabel oferuje wiele korzyści. Wyobraź sobie, że pracujesz
w firmie, która co jakiś czas przejmuje inne firmy. Techniki opisane w tym rozdziale możesz
wykorzystywać do szybkiego konsolidowania danych pochodzących z przejętych firm i tworzenia
raportów, zanim dział IT zintegruje bazy danych. Opisane metody analityki biznesowej robią
wielkie wrażenie podczas łączenia dużych ilości tego rodzaju danych.
122
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 5.
Pozyskiwanie kontekstu
Dla mnie kontekst jest kluczem — od niego zaczyna się zrozumienie wszystkiego.
— Kenneth Noland

 pozyskiwać podczas dołączania zapytań kontekst zapisany w nazwach plików i arkuszy,
 stosować przekształcenie Wyszczególnij z tytułami tabel i dynamicznie zapisywać zawarte
w nich konteksty w tabelach,
 wyodrębniać tytuły tabel za pomocą przekształcenia Wyszczególnij i kolumny
niestandardowej przed połączeniem plików zapisanych w folderze,
 wyodrębniać tytuły tabel za pomocą przekształceń Wyszczególnij i Wypełnij w dół
oraz kolumn warunkowych po połączeniu arkuszy skoroszytu,
 stosować zaawansowane techniki pozyskiwania kontekstu z komórki o zadanym indeksie
oraz innej komórki leżącej w jej pobliżu.
W rozdziałach 3., „Łączenie danych z kilku źródeł”, i 4., „Łączenie niezgodnych tabel”, poznałeś
kilka praktycznych przykładów łączenia niezgodnych tabel, których kolumny wymagały
ujednolicenia nagłówków. Często zdarza się, że kontekstowa, kluczowa w analizie informacja, jest
zapisana poza tabelami. Łączenie tabel z pominięciem tej informacji może prowadzić do uzyskania
bezwartościowych wyników. W tym rozdziale dowiesz się, jak pozyskiwać kontekst tabeli oraz jak
łączyć osobne tabele wraz z ich informacjami kontekstowymi. Poznasz różne przypadki i metody
dynamicznego wyszukiwania i pozyskiwania kluczowych informacji z jednoczesnym pomijaniem
mniej istotnych. Wszak od kontekstu, jak powiedział Kenneth Noland (choć prawdopodobnie
w innym kontekście), zaczyna się zrozumienie wszystkiego. Bez kontekstu traci się cenne informacje.
4650570396d9eb2765da56c12eb840b5
4
zawartego w nazwach plików i skoroszytów
W rozdziałach 3. i 4. poznałeś różne metody łączenia kilku tabel danych fikcyjnej firmy Fabryka
Przygód. Tabele te zawierały różne kategorie produktów, np. rowery i akcesoria. Szczęśliwym trafem
(albo umyślnie) informacje o kategoriach były umieszczone w osobnej kolumnie, która podczas
łączenia tabel nie ulegała zmianie. W tym podrozdziale zajmiemy się innym typowym przypadkiem,
w którym kluczowe informacje kontekstowe zawarte są w nazwach arkuszy lub plików, a nie
w kolumnie tabeli. Celem jest znalezienie sposobu umieszczenia tych informacji w kolumnie,
aby zachować kontekst danych.
Zacznijmy od prostego przykładu.
Ćwiczenie 5.1. Część I. Kolumna niestandardowa

W tym ćwiczeniu zaimportujesz i połączysz dane o dwóch kategoriach produktów Fabryki Przygód
(rowerach i akcesoriach) zapisanych w osobnych skoroszytach. Wynik nie będzie zawierał nazw
kategorii, zatem nie będziesz mógł wykonać żadnych analiz porównujących sprzedaż obu linii
produktów. Dowiesz się jednak, jak łatwo można pozyskiwać informacje o kontekście i umieszczać
je w końcowych wynikach.
W ćwiczeniu wykorzystasz skoroszyty R05-01 - rowery.xlsx i R05-01- akcesoria.pbix.
1. Utwórz pusty skoroszyt lub raport i zaimportuj do niego powyższe skoroszyty. W oknie
Nawigator zaznacz Arkusz1. Zauważ, że w oknie edytora Power Query pojawią się zapytania
o nazwach Arkusz1 i Arkusz1 (2), tak jak na rysunku 5.1, a ponadto nie będzie kolumny
z informacjami o kategoriach produktów.
RYSUNEK 5.1. Podczas importowania danych o rowerach i akcesoriach z dwóch arkuszy

(każdy o nazwie Arkusz1) tracony jest kontekst zawarty w nazwach plików
124
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 5.  POZYSKIWANIE KONTEKSTU
2. Zmień nazwę zapytania Arkusz1 na Rowery, a Arkusz1 (2) na Akcesoria. Jeżeli nie pamiętasz,
które zapytanie jest które, kliknij w panelu Zastosowane kroki krok 1. W pasku formuły
pojawi się nazwa pliku. Przykładowo formuła importująca skoroszyt z katalogiem rowerów
wygląda następująco:
= Excel.Workbook(File.Contents("C:\Dane\R05\R05-01 - rowery.xlsx"), null, true)
Ewentualnie kliknij ikonę ustawień po prawej stronie kroku Źródło. Pojawi się okno,
w którym w polu Ścieżka pliku będzie widoczna nazwa skoroszytu.
3. W panelu Zapytania kliknij zapytanie Rowery. W kolumnie Strona główna rozwiń ikonę
Dołącz zapytania i wybierz polecenie Dołącz zapytania jako nowe.
4. W oknie Dołączanie, w rozwijanej liście Tabela podstawowa wybierz Rowery, a w liście
Tabela do dołączenia do tabeli podstawowej wybierz Akcesoria. Kliknij OK.
Pojawi się nowe zapytanie Append1 zawierające dane rowerów i akcesoriów, ale bez
kategorii. Zmiana oryginalnych nazw zapytań w kroku 2. okazała się niewystarczająca
do zachowania informacji o kontekście. Możesz to jednak naprawić.
5. W panelu Zapytania kliknij zapytanie Rowery.
6. W karcie Dodaj kolumnę kliknij ikonę Kolumna niestandardowa.
7. W oknie, które się pojawi, wpisz w polu Nazwa nowej kolumny nazwę Kategoria, a w polu
Formuła kolumny niestandardowej następującą formułę:
= "Rowery"
8. Kliknij OK, aby zamknąć okno, a następnie w panelu Zapytania zaznacz zapytanie Akcesoria.
9. W karcie Dodaj kolumnę kliknij ikonę Kolumna niestandardowa.
10. W oknie, które się pojawi, wpisz w polu Nazwa nowej kolumny nazwę Kategoria, a w polu
Formuła kolumny niestandardowej następującą formułę:
= "Akcesoria"
11. Kliknij OK, aby zamknąć okno, a następnie w panelu Zapytania zaznacz zapytanie Append1.
Gdy przewiniesz zawartość panelu podglądu w dół, zauważysz, że kolumna Kategoria zawiera
poprawne informacje kontekstowe dla wierszy pochodzących z zapytań Rowery i Akcesoria.
Gotowe rozwiązanie jest zapisane w plikach R05-01 - rozwiązanie - część 1.xlsx
oraz R05-01 - rozwiązanie - część 1.pbix.
Ćwiczenie 5.1.
Część II. Pozyskiwanie kontekstu z nazwy pliku lub arkusza
Regułą jest, że używając przekształceń Dołącz zapytania i Dołącz zapytania jako nowe, tracimy kontekst
zawarty w nazwach zapytań. W takim przypadku trzeba w każdej tabeli tworzyć niestandardową
kolumnę. Jednak podczas łączenia plików zapisanych w folderze niezbędna informacja kontekstowa
jest umieszczana w kolumnie Source.Name i nie trzeba tworzyć niestandardowej kolumny. W rozdziale 3.,
w punkcie „Łączenie tabel zapisanych w folderze” został opisany podobny przypadek, w którym
wyodrębniany był rok wprowadzenia produktu do sprzedaży.
125
4650570396d9eb2765da56c12eb840b5
4
W przypadku importowania arkuszy ze skoroszytu Excela istnieją dwa sposoby pozyskiwania

kontekstu zawartego w ich nazwach. Jeżeli arkuszy jest kilka, a ich nazwy nie zmieniają się, można
importować każdy z nich osobno i tworzyć kolumny niestandardowe w sposób opisany w części I
ćwiczenia 5.1.
Wypróbuj ten sposób na skoroszycie R05-01 - rowery i akcesoria.xlsx. Zaimportuj oba zawarte
w nim arkusze i połącz zapytania Rowery i Akcesoria za pomocą przekształcenia Dołącz zapytania
jako nowe. Jeżeli nie utworzysz niestandardowych kolumn w obu zapytaniach, nie uzyskasz
informacji o kategoriach produktów.
Jeżeli skoroszyt składa się z wielu arkuszy, a w ich nazwach zawarty jest kontekst, możesz
zastosować technikę opisaną w rozdziale 3., w ćwiczeniu 3.4. Poniżej znajduje się opis, jak to zrobić
na przykładzie pliku R05-01 - rowery i akcesoria.xlsx.
W Excelu: kliknij kartę Dane, a następnie polecenia Pobierz dane, Z pliku, Ze skoroszytu.
2. Odszukaj plik R05-01 - rowery i akcesoria.xlsx i kliknij przycisk Importuj.
3. W oknie Nawigator kliknij prawym przyciskiem myszy nazwę R05-01 - rowery
i akcesoria.xlsx i z podręcznego menu wybierz polecenie Przekształć dane.
4. Usuń wszystkie kolumny oprócz Name i Data. W pierwszej kolumnie znajduje się
informacja kontekstowa o kategorii produktów. Rozwiń kolumnę Data.
5. Zastosuj technikę opisaną w ćwiczeniu 3.4, aby nadać kolumnom nazwy zapisane
w pierwszym wierszu.
Gotowe rozwiązanie jest zapisane w plikach R05-01 - rozwiązanie - część 2.xlsx
oraz R05-01 - rozwiązanie - część 2.pbix.
z tytułów tabel przed ich połączeniem
W części II ćwiczenia 5.1 połączyłeś arkusze Rowery i Akcesoria i wykorzystałeś informacje
o kategoriach zawarte w nazwach arkuszy. Niestety, w praktyce często zdarza się, że kluczowych
informacji kontekstowych nie ma w tabelach, nazwach plików ani nazwach arkuszy.
W części I ćwiczenia 5.1 przed połączeniem zapytań Rowery i Akcesoria utworzyłeś kolumny
niestandardowe zawierające nazwy kategorii. Teraz poznasz bardziej zaawansowaną odmianę tej
techniki, umożliwiającą pozyskiwanie kontekstu z tytułów tabel umieszczonych przed wierszami
zawierającymi właściwe dane. Technika ta jest bardzo przydatna podczas łączenia tabel za pomocą
przekształceń Dołącz zapytania i Dołącz zapytania jako nowe, jak również w czasie łączenia plików
zapisanych w folderze, o czym się niedługo przekonasz. Rysunek 5.2 przedstawia przekształcenia
niezbędne do wyodrębnienia informacji z tytułów tabel i umieszczenia ich w nowej kolumnie.
Uwaga. Tutaj, inaczej niż w części I ćwiczenia 5.1, zamiast jawnego określania zawartości kolumny
niestandardowej za pomocą ciągów "Rowery" i "Akcesoria" zastosujesz ogólną metodę wyodrębniania
wartości z tytułu tabeli. Ponieważ treść tytułu nie jest zawczasu znana, potrzebny jest sposób
pozyskiwania informacji z wielu tabel o różnych tytułach.
126
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 5.2. Technika pozyskiwania kontekstu z tytułów tabel przed ich połączeniem jest zilustrowana na
przykładzie danych firmy Fabryka Przygód; dzięki niej tytuły można pozyskiwać dynamicznie i umieszczać
je w połączonych wynikach

za pomocą przekształcenia Drill Down
W tym ćwiczeniu wykonasz sekwencję przekształceń pokazaną na rysunku 5.2 w celu wyodrębnienia
słowa „Rowery” z komórki arkusza i umieszczenia go w nowej kolumnie tabeli Rowery. W następnym
ćwiczeniu dowiesz się, jak uogólnić tę technikę i stosować ją w odniesieniu do wielu plików
zapisanych w folderze przed połączeniem zawartych w nich tabel.
Uwaga. Opisaną technikę możesz stosować również podczas łączenia plików tekstowych i CSV
zapisanych w folderze, jeżeli informacja kontekstowa znajduje się w wierszu poprzedzającym
właściwe wiersze z danymi.
W ćwiczeniu wykorzystasz skoroszyt R05-02 - rowery.xlsx.

2. Odszukaj plik R05-02 - rowery.xlsx i kliknij przycisk Importuj.
3. W oknie Nawigator zaznacz Arkusz1, kliknij przycisk Przekształć dane i zmień nazwę
zapytania na Rowery.
4. W pliku Zastosowane kroki usuń krok Zmieniono typ. (Nie jest to obowiązkowa operacja,
ale nie ma potrzeby automatycznego określania typu danych, ponieważ pierwszy wiersz
jest pusty i Power Query na tym etapie nie jest w stanie poprawnie rozpoznać typów).
127
4650570396d9eb2765da56c12eb840b5
4
5. Jeżeli w panelu Zastosowane kroki znajduje się krok Nagłówki o podwyższymy poziomie,
również go usuń.
6. W karcie Strona główna rozwiń ikonę Usuń wiersze i wybierz polecenie Usuń puste wiersze,
aby usunąć puste wiersze z zaimportowanej tabeli. Dlaczego to jest ważne? Ponieważ tytuły
od danych są często oddzielone pustymi wierszami. Dzięki temu później, po wyodrębnieniu
i zapisaniu nazwy kategorii zawartej w tytule arkusza, łatwiej będzie importować dane.
7. W panelu Zapytania kliknij prawym przyciskiem myszy zapytanie Rowery i z podręcznego
menu wybierz polecenie Odwołanie. Utworzysz zapytanie Rowery (2). Zaznacz je i zwróć
uwagę, że pierwszy wiersz zawiera wartość Rowery. Kliknij ją prawym przyciskiem myszy
i z podręcznego menu wybierz polecenie Wyszczególnij. W panelu podglądu pojawi się
słowo „Rowery”.
Nie zamykaj edytora. Po zapoznaniu się z operacją wyszczególnienia przejdziesz do
następnego kroku.
Kod M operacji wyszczególnienia wartości komórki

Gdy w ostatnim kroku użyłeś polecenia Wyszczególnij, w pasku formuły pojawił się następujący kod:
= Źródło{0}[Column1]
Powyższa formuła wyodrębnia tekst „Rowery” z tabeli danych. Identyfikator Źródło jest nazwą
tabeli utworzonej w poprzednim kroku. Nazwa tej tabeli jest również widoczna w pierwszym kroku,
w panelu Zastosowane kroki.
Wyrażenie Źródło{0} zwraca pierwszy wiersz tabeli Źródło, wyrażenie Źródło{1} zwraca drugi
wiersz itd. Indeks przyjmuje wartości od 0 do n–1, gdzie n oznacza liczbę wierszy. Na początku
konwencja ta może wydawać Ci się dziwna, ale szybko się do niej przyzwyczaisz. Ponadto,
w większości przypadków do wyszczególnienia pojedynczej komórki będziesz używał interfejsu
graficznego edytora.
W narzędziu Power Query wiersze tabeli są reprezentowane w postaci rekordów, czyli list par
klucz-wartość, gdzie klucz jest nazwą kolumny, a wartość jest zawartością komórki w danej kolumnie.
Aby odwołać się za pomocą klucza do wartości w danym rekordzie, należy użyć formuły rekord[klucz],
gdzie rekord jest nazwą rekordu, a klucz nazwą klucza. Zatem formuła Źródło{0}[Column1]
odwołuje się najpierw do pierwszego wiersza tabeli Źródło, a następnie do wartości w kolumnie
Column1. Rysunek 5.3 ilustruje sposób, w jaki powyższa formuła implementująca przekształcenie
Wyszczególnij odwołuje się do słowa „Rower”. Robi to w dwóch krokach: najpierw odwołuje się
do rekordu w tabeli, a następnie do komórki w rekordzie.
Wskazówka. Aby odwoływać się do wierszy, kolumn i komórek, nie musisz znać języka M.
Żeby dowiedzieć się, jaka jest składnia potrzebnego wyrażenia, po prostu użyj przekształcenia
Wyszczególnij i sprawdź kod, który pojawi się w pasku formuły. Zwróć uwagę, że zawartość
pojedynczej komórki możesz odczytywać, odwołując się najpierw do kolumny, a potem do
wiersza. Przykładowo wyrażenie Źródło{0}[Column1] zwraca ten sam wynik, co Źródło
[Column1]{0}. Ostatnie wyrażenie działa w nieco inny sposób: najpierw odczytuje listę
wszystkich elementów kolumny Column1, a następnie zwraca pierwszy element listy.
128
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 5.3. Przekształcenie Wyszczególnij generuje formułę w języku M, której działanie można podzielić
na dwa kroki
Umieszczenie wyniku wyszczególnienia w zapytaniu

Wykonaj poniższe kroki będące kontynuacją ćwiczenia 5.2.
8. Teraz, gdy wiesz już, jak odczytywać wartość komórki za pomocą przekształcenia
Wyszczególnij, usuń zapytanie Rowery (2) i zaznacz zapytanie Rowery.
9. Ponownie użyj przekształcenia Wyszczególnij, ale w odniesieniu do zapytania Rowery.
W tym celu kliknij prawym przyciskiem myszy komórkę zawierającą wartość „Rowery”
i wybierz polecenie Wyszczególnij.
10. W pasku formuły pojawi się następujący kod:
= #"Usunięto puste wiersze"{0}[Column1]

Teraz składnia formuły powinna być zrozumiała. Opisuje ona operację wykonywaną
po kroku Usunięto puste wiersze widocznym w panelu Zastosowane kroki. (Zapis #"..."
złożony ze znaków Unicode, spacji i znaków specjalnych, jest w języku M identyfikatorem).
Wynikiem tej operacji jest wartość „Rowery” widoczna w panelu podglądu.
11. Zwróć uwagę, że ostatni krok w panelu Zastosowane kroki ma nazwę Column1. Aby nadać
mu bardziej zrozumiałą etykietę, kliknij go prawym przyciskiem myszy i wybierz polecenie
Właściwości. Następnie w oknie o tej samej nazwie wpisz w polu Nazwa nazwę Tytuł.
Na koniec zamknij okno. (W oknie Właściwości można zmieniać nazwę kroku i dodawać
do niego opis, dzięki czemu ciąg przekształceń jest bardziej zrozumiały).
Teraz, po wyodrębnieniu tytułu, wróć do tabeli i usuń wiersz z tytułem, tak jak w kroku 3.
na rysunku 5.2. Ponieważ tytuł jest widoczny w panelu podglądu, musisz wrócić do kroku
sprzed przekształcenia Wyszczególnij tak, aby nie zmienić kroku Tytuł.
129
4650570396d9eb2765da56c12eb840b5
4
12. Kliknij przycisk fx w pasku formuły i zamień kod:

= Tytuł
na:
= #"Usunięto puste wiersze"
W ten sposób zachowasz krok Tytuł i wrócisz do poprzedniego kroku. Teraz w panelu
podglądu będzie widoczna tabela, a nie słowo „Rowery”. Krok Tytuł wykorzystasz za chwilę.
13. Aby usunąć pierwszy wiersz tabeli, tak jak w kroku 3. na rysunku 5.2, kliknij w karcie Strona
główna ikonę Usuń wiersze, a następnie polecenie Usuwanie pierwszych wierszy. W oknie,
które się pojawi, wpisz w polu Liczba wierszy wartość 1 i kliknij OK, aby zamknąć okno.
Uwaga. Usuwanie określonej liczby wierszy (np. jednego, tak jak w tym ćwiczeniu) nie jest
dobrą praktyką. W punkcie „Wskazówki kontekstowe” tego rozdziału dowiesz się, jak można
pomijać nieistotne informacje, usuwając dynamicznie określoną, a nie stałą liczbę wierszy.
14. Zgodnie w krokiem 4. na rysunku 5.2, przenieś pierwszy wiersz tabeli do nagłówków.
W tym celu w karcie Przekształć kliknij ikonę Użyj pierwszego wiersza jako nagłówków.
15. Na koniec, zgodnie z ostatnim krokiem na rysunku 5.2, utwórz niestandardową kolumnę
zawierającą słowa „Rowery”. W tym celu kliknij w karcie Dodaj kolumnę ikonę Kolumna
niestandardowa. W oknie, które się pojawi, wpisz w polu Nazwa nowej kolumny nazwę
Kategoria, a w polu Formuła kolumny niestandardowej następującą formułę:
= Tytuł
Powinna pojawić się nowa kolumna zawierająca słowa „Rowery”. Wyodrębniłeś więc dynamicznie
to słowo z komórki skoroszytu i zgodnie z krokami pokazanymi na rysunku 5.2 umieściłeś je w tabeli.
Opisana technika jest w praktyce bardzo przydatna. Można ją stosować w różnych przypadkach
importowania danych z dowolnych źródeł i zapisanych w różnych formatach (gdy informacje
kontekstowe zawarte są nie tylko w tytułach tabel umieszczonych w komórkach arkusza).
Uwaga. Rozdzielanie serii przekształceń na dwa przepływy, a następnie łączenie ich w jeden
przepływ jest bardzo przydatną techniką. Gdy lepiej poznasz język M, wtedy zamiast tworzyć
niestandardowe kroki, tak jak w tym ćwiczeniu, będziesz opisaną technikę stosował bezpośrednio
w zaawansowanym edytorze.
Gotowe rozwiązanie jest zapisane w plikach R05-02 - rozwiązanie.xlsx oraz R05-02 - rozwiązanie.pbix.

podczas importowania plików z folderu
W ćwiczeniu 5.2 wyodrębniłeś pojedynczy tytuł tabeli zapisany w arkuszu. Czas uogólnić tę technikę
na kilka skoroszytów zapisanych w folderze.
1. Przejrzyj następujące pliki zapisane w folderze C:\Dane\R05\R05-03 - produkty:
a. R05-03-01.xlsx,
b. R05-03-02.xlsx,
130
4650570396d9eb2765da56c12eb840b5
4
c. R05-03-03.xlsx,
d. R05-03-04.xlsx.
2. Zwróć uwagę, że w każdym skoroszycie tabela produktów ma inny tytuł, tak jak na rysunku
5.4. Pliki specjalnie mają nic niemówiące nazwy, zatem jedynym sposobem pozyskania
informacji o kategoriach produktów jest wyodrębnienie ich z tytułów tabel.
RYSUNEK 5.4. W edytorze Power Query można łączyć kilka tabel i wyodrębniać ich tytuły

i kliknij OK.
7. Zwróć uwagę, że połączona tabela w panelu podglądu nie zawiera informacji o kategorii
produktów. Jak poprzednio, jest to efekt nadania plikom nic niemówiących nazw. Zaznacz
zapytanie Przekształć przykładowy plik i zmień jego nazwę na Przykładowe produkty.
Dodatkowo z panelu Zastosowane kroki usuń krok Nagłówki o podwyższonym poziomie.
131
4650570396d9eb2765da56c12eb840b5
4
8. W karcie Strona główna kliknij ikonę Usuń wiersze i wybierz polecenie Usuń puste wiersze,
zgodnie z krokiem 1. na rysunku 5.2.
9. Aby wyodrębnić tytuł tabeli Rowery, tak jak w ćwiczeniu 5.2 (kroki od 9. do 15.), i umieścić
tytuły wszystkich tabel w kolumnie Kategoria, wykonaj następujące operacje na zapytaniu
Przykładowe produkty.
a. Kliknij prawym przyciskiem myszy komórkę zawierającą wartość „Rowery” i wybierz
polecenie Wyszczególnij.
b. Zwróć uwagę, że w pasku formuły pojawi się następujący kod:
= #"Usunięto puste wiersze"{0}[Column1]

c. W panelu Zastosowane kroki pojawił się krok Column1. Kliknij go prawym przyciskiem
myszy i wybierz polecenie Właściwości. W oknie, które się pojawi, wpisz w polu Nazwa
nazwę Tytuł i kliknij OK, aby zamknąć okno.
d. W pasku formuły kliknij przycisk fx i w miejsce formuły:
= Tytuł
wpisz następujący kod:
= #"Usunięto puste wiersze"
e. W karcie Strona główna kliknij ikonę Usuń wiersze i wybierz polecenie Usuwanie
pierwszych wierszy. W oknie, które się pojawi, wpisz w polu Liczba wierszy wartość 1
i kliknij OK, aby zamknąć okno.
f. W karcie Przekształć kliknij ikonę Użyj pierwszego wiersza jako nagłówków.
g. W karcie Dodaj kolumnę kliknij ikonę Kolumna niestandardowa. W oknie, które się
pojawi, wpisz w polu Nazwa nowej kolumny nazwę Kategoria, a polu Formuła kolumny
niestandardowej następującą formułę:
= Tytuł
10. W panelu Zastosowane kroki usuń krok Zmieniono typ. (Krok ten może powodować błędy
w kolumnie Wielkość. Typy kolumn określisz później).
11. W panelu Zapytania zaznacz zapytanie R05-03 - produkty.
12. W panelu Zastosowane kroki usuń krok Zmieniono typ.
13. W nagłówku kolumny Kategoria kliknij przycisk filtru i sprawdź, czy lista, która się pojawi,
zawiera poprawne nazwy wszystkich czterech kategorii.
Gotowe rozwiązanie jest zapisane w plikach R05-03 - rozwiązanie.xlsx oraz
W następnym podrozdziale dowiesz się, jak pozyskiwać informacje kontekstowe po połączeniu
tabel. Dzięki temu będziesz mógł przekształcać zapytanie R05-03 - produkty, a nie Przykładowe
produkty. Technika ta okaże się szczególnie przydatna w ćwiczeniu 5.4 podczas łączenia arkuszy
skoroszytu.
132
4650570396d9eb2765da56c12eb840b5
4
Pozyskiwanie kontekstu z tytułów tabel po ich połączeniu

Wcześniej w tym rozdziale dynamicznie wyodrębniałeś i umieszczałeś w niestandardowej tabeli
tytuły tabel przed ich połączeniem. Jest to skuteczna metoda podczas łączenia tabel zapisanych
w folderze. Czasami jednak łatwiej wyodrębniać tytuły z już połączonych tabel. Jest tak w przypadku,
gdy tabele zapisane są w osobnych arkuszach jednego skoroszytu lub w tym samym pliku
tekstowym, oddzielone tytułami.

zapisanych w arkuszach jednego skoroszytu
Poniższe ćwiczenie demonstruje metodę pozyskiwania informacji o kategoriach produktów firmy
Fabryka Przygód z poszczególnych arkuszy jednego skoroszytu. W praktyce skoroszyt może
zawierać dziesiątki arkuszy, a w każdym z nich informacja kontekstowa może być zapisana w tytule
tabeli, tak jak na rysunku 5.5. Zwróć uwagę, że w tym przypadku arkusze, podobnie jak pliki
w ćwiczeniu 5.3, nie zawierają w swoich nazwach żadnych istotnych informacji kontekstowych.
RYSUNEK 5.5. Dane produktów firmy Fabryka Przygód są zapisane w osobnych arkuszach jednego
skoroszytu, a informacje o kategoriach znajdują się w tytułach tabel, a nie w nazwach arkuszy
Poniższe ćwiczenie demonstruje, jak wyodrębniać tytuły tabel po połączeniu arkuszy.

1. Otwórz skoroszyt R05-04 - produkty.xlsx i przejrzyj jego zawartość. Zwróć uwagę, że
produkty poszczególnych kategorii są umieszczone w osobnych arkuszach: Arkusz1,
Arkusz2, Arkusz3 i Arkusz4, a nad tabelami umieszczone są tytuły Rowery, Akcesoria,
Komponenty i Ubrania (patrz rysunek 5.5).
3. Odszukaj plik R05-04 - produkty.xlsx i kliknij przycisk Importuj.
4. W oknie Nawigator kliknij prawym przyciskiem myszy nazwę R05-04 - produkty.xlsx
i z podręcznego menu wybierz polecenie Przekształć dane.
133
4650570396d9eb2765da56c12eb840b5
4
5. Zwróć uwagę, że z tabeli widocznej w panelu podglądu nie można uzyskać informacji
o kategoriach produktów. W rozdziale 3. informacja kontekstowa była zapisana w nazwie
arkusza. Można ją było łatwo wyodrębnić za pomocą kolumny Name. Niestety, w tym
ćwiczeniu nazwy arkuszy nie zawierają informacji kontekstowych. Usuń wszystkie kolumny
oprócz Data. W tym celu kliknij prawym przyciskiem myszy nagłówek tej kolumny i wybierz
polecenie Usuń inne kolumny.
6. Rozwiń kolumnę Data. W tym celu kliknij przycisk znajdujący się po prawej stronie jej
nagłówka lub zaznacz tę kolumnę, a następnie w karcie Przekształć kliknij ikonę Rozwiń.
W oknie Rozwiń Data kliknij OK.
Pierwsza tabela ma rysunku 5.6 przedstawia złączone dane, zawierające m.in. tytuły Rowery,
Akcesoria, Komponenty i Ubrania. Aby je wyodrębnić i umieścić w kolumnie Kategoria,
wykonaj sekwencję przekształceń pokazanych na tym rysunku.
RYSUNEK 5.6. Metoda pozyskiwania informacji kontekstowych po połączeniu tabel pozwala łączyć arkusze
skoroszytu i wyodrębniać z nich tytuły tabel
7. W karcie Strona główna kliknij ikonę Usuń wiersze, a następnie polecenie Usuń puste wiersze.
Powód, dla którego trzeba wykonać to przekształcenie, jest oczywisty: podobnie jak
w ćwiczeniu 5.3, pomiędzy tytułem a właściwą tabelą znajduje się pusty wiersz, który
sprawia, że arkusz jest bardziej czytelny. Ten wiersz jest tutaj usuwany.
8. W karcie Dodaj kolumnę kliknij ikonę Kolumna warunkowa. Celem jest utworzenie
kolumny, która ułatwi wyszukiwanie wierszy zawierających tytuły. Można to zrobić na
dwa sposoby.
a. Najprostszy polega na wpisywaniu w nowej kolumnie wartości 1, jeżeli pierwsza kolumna
zawiera wartość Rowery, Akcesoria, Komponenty lub Ubrania, albo wartości 0 w przeciwnym
przypadku. Nie jest to jednak zlecana metoda, ponieważ opiera się na sztywno zdefiniowanych
tytułach. Jeżeli w przyszłości będą pojawiały się nowe kategorie, trzeba będzie za każdym
razem uwzględniać je w przekształceniu.
134
4650570396d9eb2765da56c12eb840b5
4
b. Bardziej uniwersalne rozwiązanie polega na wyszukaniu wierszy, które we wszystkich

kolumnach oprócz Data.Column1 zawierają wartości null. Wtedy zapytanie wystarczy
zdefiniować raz, bez konieczności modyfikowania go za każdym razem, gdy pojawi się
arkusz z nową kategorią.
Wskazówka. W praktyce często będziesz mógł pozyskiwać informacje kontekstowe, stosując

różne metody. Przyjęcie jasno sprecyzowanych założeń ułatwia wybranie najlepszej z nich.
9. Zastosuj drugą, lepszą metodę. W oknie Dodawanie kolumny warunkowej zdefiniuj reguły
wyszukiwania wierszy z tytułami (na podstawie rysunku 5.7 sprawdź, czy wybrałeś
poprawne opcje).
a. W polu Nazwa nowej kolumny wpisz To tytuł.
b. W rozwijanej liście Nazwa kolumny wybierz Data.Column2.
c. W rozwijanej liście Operator wybierz nie równa się.
d. W polu Wartość wpisz null.
e. W polu Wartość wyjściowa wpisz 0.
f. Kliknij przycisk Dodaj regułę, w rozwijanej liście Nazwa kolumny wybierz
Data.Column3, a następnie wykonaj ponownie kroki od c do e.
g. Kliknij przycisk Dodaj regułę, w rozwijanej liście Nazwa kolumny wybierz
h. Kliknij przycisk Dodaj regułę, w rozwijanej liście Nazwa kolumny wybierz
i. Kliknij przycisk Dodaj regułę, w rozwijanej liście Nazwa kolumny wybierz
j. W polu W przeciwnym razie wpisz 1 i kliknij OK, aby zamknąć okno.
Teraz dodaj następną kolumnę warunkową, która będzie zawierała właściwy tytuł tabeli,
jeżeli kolumna To tytuł będzie zawierała 1 lub null w przeciwnym przypadku. Przygotujesz
się w ten sposób do kroku 3., „Wypełnienie tabeli” przedstawionego na rysunku 5.6.
10. W karcie Dodaj kolumnę kliknij ikonę Kolumna warunkowa i w oknie Dodawanie kolumny
warunkowej wykonaj poniższe kroki.
a. W polu Nazwa nowej kolumny wpisz Tytuł.
b. W rozwijanej liście Nazwa kolumny wybierz To tytuł.
c. W rozwijanej liście Operator wybierz równa się.
d. W polu Wartość wpisz 1.
e. W pierwszej rozwijanej liście pod etykietą Wartość wyjściowa wskaż pozycję Wybierz kolumnę.
f. W drugiej rozwijanej liście pod etykietą Wartość wyjściowa wybierz pozycję Data.Column1.
g. W polu W przeciwnym razie wpisz null i kliknij OK, aby zamknąć okno.
Utworzyłeś kolumnę Tytuł zawierającą nazwy kategorii w wierszach, w których znajdują się
tytuły tabel, oraz wartości null w pozostałych wierszach. Teraz użyjesz przekształcenia
Wypełnij w dół.
135
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 5.7. Do dynamicznego wyszukiwania tytułów tabel użyj kolumny warunkowej
11. Kliknij prawym przyciskiem myszy kolumnę Tytuł i wybierz polecenie Wypełnij, a następnie
W dół. W ten sposób w każdym wierszu umieścisz informacje o kategorii produktu.
Teraz możesz przefiltrować wiersze. Użyjesz w tym celu kolumny To tytuł.
12. Kliknij w nagłówku kolumny To tytuł ikonę filtru i w oknie, które się pojawi, usuń zaznaczenie
przy wartości 1. Kliknij OK.
13. Usuń kolumnę To tytuł, ponieważ nie będzie już potrzebna.
14. Wykonaj poniższe kroki, aby — podobnie jak w rozdziale 3. podczas łączenia arkuszy
— użyć pierwszego wiersza jako nagłówków kolumn.
a. W karcie Przekształć kliknij ikonę Użyj pierwszego wiersza jako nagłówków.
b. Zmień nagłówek kolumny Rowery na Kategoria.
c. Zastosuj w kolumnie Nazwa filtr usuwający wiersze zawierające wartość Nazwa.
Wskazówka. Możesz usprawnić krok 14b, zamieniając w pasku formuły fragment kodu "Rowery"
na List.Last(Table.ColumnNames(#"Zmieniono typ")). Poniżej przedstawiona jest pełna formuła:
= Table.RenameColumns(#"Zmieniono typ",
{{List.Last(Table.ColumnNames(#"Zmieniono typ")), "Kategoria"}})
Dzięki temu zmienisz nazwę ostatniej kolumny, a nie jawnie wskazanej o nazwie Rowery.
Jest to ważne, ponieważ w praktyce dane się zmieniają. Zapytanie w oryginalnej formie przestanie
działać, jeżeli w pierwszym arkuszu zostanie umieszczona tabela inna niż Rowery. Jeżeli natomiast
zapytanie będzie zmieniało ostatnią kolumnę, wtedy będzie działać poprawnie. W rozdziale 9.,
„Wprowadzenie do języka M”, dowiesz się więcej o użytym tutaj kodzie, natomiast w rozdziale
10., „Od złych do dobrych zapytań", nauczysz się optymalizować zapytania, w tym pozyskiwać
kontekst i zmieniać nazwy kolumn.
136
4650570396d9eb2765da56c12eb840b5
4
15. Zamknij edytor i załaduj połączone arkusze do raportu.

Wskazówki kontekstowe
W ćwiczeniu 5.4 wyodrębniłeś tytuły tabel po połączeniu arkuszy i użyłeś ich jako nazw kategorii.
Ponieważ nagłówki kolumn były zapisane w wierszach danych, do ich wyszukania użyłeś kolumny
warunkowej. Aby dynamicznie wyszukiwać wiersze z tytułami, przyjąłeś założenie, że tytuły znajdują
się w wierszach, w których wszystkie kolumny oprócz pierwszej są puste. Co można jednak zrobić,
jeżeli takie założenie nie jest możliwe? Czy można wyszukiwać tytuły np. w pobliżu innych komórek?
W tym podrozdziale dowiesz się, jak wyszukiwać informacje kontekstowe w określonych
miejscach, w pobliżu wskazanych komórek kotwic. Takie komórki wykorzystasz jako wskazówki do
wyszukiwania potrzebnych informacji kontekstowych. Dowiesz się również, jak pomijać nieistotne
informacje.
W ćwiczeniu wykorzystasz inną wersję skoroszytu zawierającego katalog produktów firmy
Fabryka Przygód. Tym razem, inaczej niż w ćwiczeniu 5.4, nazwa kategorii będzie umieszczona
w innej, mniejszej tabeli, powyżej właściwej tabeli produktów, tak jak na rysunku 5.8. Nazwę
kategorii wyodrębnisz, wykorzystując miejsce, w którym znajduje się tekst „Kategoria”.
RYSUNEK 5.8. Twoje zadanie polega na wyodrębnieniu nazwy kategorii z górnej tabeli
i umieszczeniu jej w nowej kolumnie połączonej tabeli
Ćwiczenie 5.5. Kolumna indeksu jako wskazówka

W tym ćwiczeniu zastosujesz inną technikę pozyskiwania informacji o kategorii. Zaimportujesz
arkusze zawierające wskazówki, które wykorzystasz do połączenia tabel i wyodrębnienia informacji
o kategoriach produktów.
1. Otwórz skoroszyt R05-05 - produkty.xlsx i przejrzyj jego zawartość. Dane produktów są
umieszczone w czterech arkuszach. Jak pokazuje rysunek 5.8, nazwa każdej kategorii — Rowery,
Akcesoria, Komponenty i Ubrania — jest zapisana w osobnej małej tabeli znajdującej się
powyżej właściwej tabeli z produktami. Arkusze mają nazwy Arkusz1, Arkusz2, Arkusz3
i Arkusz4, zatem nie można na ich podstawie rozróżnić kategorii.
137
4650570396d9eb2765da56c12eb840b5
4

3. Odszukaj plik R05-05 - produkty.xlsx i kliknij przycisk Importuj.
4. W oknie Nawigator kliknij prawym przyciskiem myszy nazwę R05-05 - produkty.xlsx
i z podręcznego menu wybierz polecenie Przekształć dane.
5. Kliknij prawym przyciskiem myszy nagłówek kolumny Data i wybierz polecenie Usuń inne
kolumny. Podobnie jak w ćwiczeniu 5.4, musisz znaleźć sposób wyszukania wiersza zawierającego
informację o kategorii. Na razie jest za wcześnie na rozwijanie kolumny Data, ponieważ
najpierw musisz wyodrębnić z tabeli wskazówki kontekstowe, czyli numery jej wierszy.
W ćwiczeniu 5.4 przyjąłeś założenie, że informacja o kategorii znajduje się w wierszu,
w którym wszystkie kolumny oprócz pierwszej są puste. Opierając się na tym założeniu,
utworzyłeś kolumnę warunkową wyszukującą takie wiersze. W tym ćwiczeniu nie możesz
przyjąć takiego założenia. Jak pokazuje rysunek 5.8, komórka A3 zawierająca nazwę
kategorii znajduje się po lewej stronie komórki B3 zawierającej tekst „Data raportu”.
W jaki sposób można wyodrębnić nazwę kategorii? Można wprawdzie założyć, że informacja
o kategorii znajduje się w wierszu, w którym pierwsze dwie kolumny zawierają wartości,
a pozostałe są puste. Byłoby to jednak ryzykowne założenie. Co by się stało, gdyby potrzebne
informacje zostały umieszczone w kolumnach C3 i C4?
Problem możesz rozwiązać, przyjmując inne założenie. Po usunięciu pustych wierszy
komórka zawierająca nazwę kategorii będzie zawsze znajdowała się w drugim wierszu
i pierwszej kolumnie (w ćwiczeniu 5.6 poznasz inną metodę wyodrębniania nazwy kategorii).
Aby wyodrębnić nazwę kategorii, musisz najpierw oznaczyć drugi wiersz każdego arkusza
(po usunięciu pustych wierszy). W tym celu w każdej tabeli znajdującej się w kolumnie
Data utwórz kolumnę indeksu.
6. W karcie Dodaj kolumnę kliknij ikonę Kolumna indeksu. Utworzysz kolumnę z domyślnymi
ustawieniami, m.in. indeksem rozpoczynającym się od zera. Następnie skopiuj do schowka
kod, który pojawi się w pasku formuły:
= Table.AddIndexColumn(#"Usunięto inne kolumny", "Indeks", 0, 1)
Usuń w panelu Zastosowane kroki ostatni krok. Był potrzebny jedynie do uzyskania formuły,
którą wykorzystasz w kolejnych krokach.
7. W karcie Dodaj kolumnę kliknij ikonę Kolumna niestandardowa. Pojawi się okno o takiej
samej nazwie.
8. Wklej skopiowaną formułę do pola Formuła kolumny niestandardowej, a następnie
zmodyfikuj ją w następujący sposób (patrz rysunek 5.9).
a. Usuń pierwszy znak równości. Ten znak jest wpisywany domyślnie.
b. Zamień ciąg #"Usunięto inne kolumny" na [Data]. W tym celu zaznacz go, a następnie
w liście Dostępne kolumny kliknij pozycję Data.
Wynikowa formuła wygląda następująco:
= Table.AddIndexColumn([Data], "Indeks", 0, 1)
138
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 5.9. Po dodaniu do każdej tabeli kolumny indeksu będziesz mógł odczytywać wskazówki niezbędne
do wyodrębnienia informacji o kategorii
Wskazówka. Kliknięcie nazwy kolumny w liście Dostępne kolumny powoduje wygenerowanie

kodu M odwołującego się do wartości zawartych w danej kolumnie. Wartości te można następnie
wykorzystać do utworzenia nowej niestandardowej kolumny. W tym przypadku po kliknięciu
kolumny Data został w polu formuły wygenerowany kod [Data].
9. W polu Nazwa nowej kolumny wpisz Tabela z indeksem i kliknij OK. W panelu podglądu
będą widoczne dwie kolumny: Data, zawierająca obiekty Table z zaimportowanymi
arkuszami, oraz Tabela z indeksem, zawierająca te same obiekty, ale z kolumnami indeksów.
10. Usuń tabelę Data. Od tej chwili będziesz pracował na kolumnie Tabela z indeksem.
11. Kliknij przycisk znajdujący się po prawej stronie nagłówka kolumny Tabela z indeksem, aby
ją rozwinąć. Usuń zaznaczenie opcji Użyj oryginalnej nazwy kolumny jako prefiksu i kliknij OK.
Jak się przekonasz, nazwy kategorii znajdują się w wierszach, w których kolumna indeks
zawiera wartość 1, natomiast wartości Kategoria i Data raportu w wierszach z indeksami 0.
Teraz kolejne przekształcenia będą proste.
12. Aby oznaczyć wiersze zawierające wartości Kategoria, kliknij w karcie Dodaj kolumnę ikonę
Kolumna warunkowa. W oknie, które się pojawi, wprowadź następujące zmiany.
a. W polu Nazwa nowej kolumny wpisz Kategoria.
b. W rozwijanej liście Nazwa kolumny wybierz Indeks.
c. W rozwijanej liście Operator wybierz równa się.
d. W polu Wartość wpisz 1.
139
4650570396d9eb2765da56c12eb840b5
4
e. W pierwszej rozwijanej liście pod etykietą Wartość wyjściowa wskaż pozycję

Wybierz kolumnę.
f. W drugiej rozwijanej liście pod etykietą Wartość wyjściowa wybierz pozycję Column1.
g. W polu W przeciwnym razie wpisz null i kliknij OK, aby zamknąć okno.
13. W kolumnie Kategoria zastosuj przekształcenie Wypełnij w dół.
14. W kolumnie Indeks zastosuj filtr odrzucający wartości 0, 1 i 2.
Teraz, po wyodrębnieniu informacji o kategorii i odrzuceniu nieistotnych informacji
w wierszach o indeksach 1, możesz usunąć kolumnę Indeks.
15. Wykonaj trzy dobrze znane Ci kroki.
a. W kolumnie Przekształć kliknij ikonę Użyj pierwszego wiersza jako nagłówków.
b. Zmień nazwę kolumny Rowery na Kategoria.
Wskazówka. Jak pamiętasz z ćwiczenia 5.4 (krok 14b), przekształcenie zmiany nazwy kolumny
możesz usprawnić, zastępując w pasku formuły fragment kodu "Rowery" wyrażeniem
List.Last(Table.ColumnNames(#"Zmieniono typ")).
Załaduj zapytanie do raportu. Dzięki wskazówkom uzyskanym przed połączeniem tabel

wyodrębniłeś informacje o kategoriach produktów i umieściłeś je w połączonej tabeli. W tym
przypadku wskazówkami były kolumny indeksów utworzone dla każdego arkusza.
Ćwiczenie 5.6. Wyszukiwanie informacji kontekstowych

w pobliżu określonych komórek
W ćwiczeniu 5.6 przyjąłeś założenie, że w każdym arkuszu nazwa kategorii znajduje się w drugim
wierszu i pierwszej kolumnie (po usunięciu pustych wierszy). Teraz zmienisz to założenie i przyjmiesz,
że kategoria może znajdować się w dowolnym wierszu, zatem do jej wyodrębnienia nie można użyć
numeru wiersza.
W tym ćwiczeniu założysz, że nazwa kategorii znajduje się w pierwszej kolumnie, poniżej komórki
zawierającej wartość Kategoria. Na rysunku 5.10 jest to komórka A6 znajdująca się poniżej komórki A5.
Komórka zawierająca wartość Kategoria będzie „kotwicą”, czyli wskazówką, gdzie znajduje się nazwa
kategorii. Na tej podstawie utworzysz uniwersalne zapytanie, które będzie działało poprawnie nawet
wtedy, kiedy arkusz będzie się zmieniał w miarę upływu czasu.
Aby ćwiczenie było bardziej interesujące, powyżej komórki zawierającej wartość Kategoria
znajdują się nieistotne informacje. Nie możesz więc zakładać, że nazwa kategorii jest umieszczona
w konkretnym wierszu. Co więcej, tabele danych w poszczególnych arkuszach również znajdują się
różnych wierszach. Ilustruje to rysunek 5.10.
W tym ćwiczeniu poznasz nową technikę dynamicznego określania indeksów wierszy zawierających
nazwy kategorii oraz dane. Przy jej użyciu pominiesz nieistotne informacje w każdym arkuszu,
wyodrębnisz jedynie nazwy kategorii i połączysz tabele z danymi. Technika ta wymaga zastosowania
funkcji PositionOf, której argumentami jest lista elementów i szukana wartość, a zwracanym
wynikiem numerowany od zera indeks pozycji, na której znajduje się dana wartość w liście.
140
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 5.10. Twoje zadanie polega na pominięciu nieistotnych informacji, wyodrębnieniu nazwy kategorii
z górnej tabeli i umieszczeniu jej w nowej kolumnie połączonej tabeli
1. Zaimportuj skoroszyt R05-06 - produkty.xlsx w sposób opisany w ćwiczeniu 5.5, w krokach

od 2. do 9. lub otwórz jeden z plików: R05-06 - szybki start.xlsx lub R05-06 - szybki start.pbix.
W panelu podglądu powinny pojawić się dwie kolumny: Data, zawierająca obiekty Table
z zaimportowanymi arkuszami, oraz Tabela z indeksem, zawierająca te same obiekty, ale
z kolumnami indeksów.
2. W karcie Dodaj kolumnę kliknij ikonę Kolumna niestandardowa. W oknie o tej samej nazwie
wykonaj poniższe kroki.
a. W polu Nazwa nowej kolumny wpisz Indeks wiersza z kategorią.
b. W polu Formuła kolumny niestandardowej wpisz poniższą formułę:
List.PositionOf([Data][Column1], "Kategoria")
Kliknij OK, aby zamknąć okno. Powyższa formuła wykonuje na kolumnie Column1 operację
za pomocą funkcji List.PositionOf. Wyrażenie [Data][Column1] umieszczone w pierwszym
argumencie funkcji wskazuje kolumnę Column1, natomiast drugi argument zawiera ciąg
"Kategoria". Funkcja wyszukuje ten ciąg w liście wartości odczytanej z kolumny i zwraca
jego pozycję, czyli numer wiersza zawierającego wartość Kategoria.
Jak się przekonasz, kolumna Indeks wiersza z kategorią zawiera różne wartości. Każda z nich
oznacza miejsce (numerowane od zera) komórki zawierającej wartość Kategoria.
Teraz utwórz następną kolumnę niestandardową. Tym razem wyszczególnisz każdy obiekt
tabeli w karcie Data, wykorzystując indeks określony w poprzednim kroku. Na tej podstawie
znajdziesz nazwy kategorii. Jak pamiętasz, komórka z nazwą kategorii znajduje się poniżej
komórki zawierającej wartość Kategoria. Dlatego indeks znajdujący się w kolumnie Indeks
wiersza z kategorią zwiększysz o 1.
3. W karcie Dodaj kolumnę kliknij ikonę Kolumna niestandardowa. W oknie, które się pojawi,
wprowadź następujące zmiany.
a. W polu Nazwa nowej kolumny wpisz Kategoria.
[Data]{[Indeks wiersza z kategorią] + 1}[Column1]
141
4650570396d9eb2765da56c12eb840b5
4
Kliknij OK, aby zamknąć okno. Wcześniej, w podrozdziale „Kod M operacji

wyszczególnienia wartości komórki”, użyłeś prostszej wersji tej formuły:
Źródło{0}[Column1]
Składnia formuły w obu przypadkach jest taka sama. Jest to następujące odwołanie
do pojedynczej komórki tabeli:
Tabela{indeks_wiersza}[nazwa_kolumny]
Jak wiesz, nawiasy klamrowe i indeks służą do odwoływania się do wierszy tabeli. Nawiasy
kwadratowe i nazwa kolumny stanowią odwołanie do wskazanej kolumny. Formuła w kroku
3b najpierw odwołuje się za pomocą wyrażenia [Data] do obiektów Table w kolumnie Data,
a następnie odczytuje wartość znajdującą się w wierszu wskazywanym przez indeks odczytany
z kolumny Indeks wiersza z kategorią i powiększony o 1. Na koniec formuła odwołuje się do
komórki w zadanym wierszu i w kolumnie Column1.
Nazwy kategorii umieściłeś w kolumnie Kategoria. Teraz pora wyszukać indeks wiersza
zawierającego nagłówki kolumn. Następny krok jest podobny do kroku 2. Różni się jedynie
tym, że wyszukiwany jest w nim ciąg „Nazwa”, a nie „Kategoria”.
4. W karcie Dodaj kolumnę kliknij ikonę Kolumna niestandardowa. W oknie o tej samej nazwie
a. W polu Nazwa nowej kolumny wpisz Indeks wiersza z nazwą.
List.PositionOf([Data][Column1], "Nazwa")
5. Usuń kolumny Indeks wiersza z kategorią i Data. W następnym kroku wykorzystasz
kolumnę Tabela z indeksem, którą utworzyłeś w kroku 1.
6. Rozwiń tabelę Data, klikając przycisk znajdujący się po prawej stronie jej nagłówka.
Usuń zaznaczenie opcji Użyj oryginalnej nazwy kolumny jako prefiksu i kliknij OK.
W tym momencie masz nazwy kategorii wyodrębnione z połączonych tabel. Twoim
następnym zadaniem jest wykorzystanie wskazówek zawartych w kolumnach Indeks i Indeks
wiersza z nazwą. Musisz odrzucić wszystkie wiersze, których indeksy są mniejsze od wartości
w kolumnie Indeks wiersza z nazwą, ponieważ wiersze te nie zawierają informacji o produktach.
Zrobisz to w dwóch krokach: najpierw utworzysz kolumnę warunkową, a następnie przefiltrujesz
tabelę, wykorzystując wartości zawarte w nowej kolumnie.
7. W karcie Dodaj kolumnę kliknij ikonę Kolumna warunkowa, a następnie w oknie, które się
pojawi, wykonaj następujące kroki (patrz rysunek 5.11).
a. W rozwijanej liście Nazwa kolumny wybierz Indeks.
b. W rozwijanej liście Operator wybierz jest większe niż lub równe.
c. W pierwszej rozwijanej liście pod etykietą Wartość wskaż pozycję Wybierz kolumnę.
d. W drugiej rozwijanej liście pod etykietą Wartość wybierz pozycję Indeks wiersza z nazwą.
e. W polu Wartość wyjściowa wpisz liczbę 1.
f. W polu W przeciwnym razie wpisz 0 i kliknij OK, aby zamknąć okno.
142
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 5.11. Aby odrzucić wiersze znajdujące się powyżej tabeli danych, wykonaj krok 7. i sprawdź,
czy w oknie „Dodawanie kolumny warunkowej” wybrałeś ustawienia takie, jak na tym rysunku
8. W kolumnie Niestandardowe zastosuj filtr odrzucający wartość 0, a następnie usuń kolumny

Indeks, Indeks wiersza z nazwą i Niestandardowe.
9. Wykonaj trzy dobrze znane Ci kroki.
a. W kolumnie Przekształć kliknij ikonę Użyj pierwszego wiersza jako nagłówków.
b. Zmień nazwę kolumny Rowery na Kategoria.
Wskazówka. Podobnie jak w ćwiczeniach 5.4 i 5.5, możesz usprawnić zapytanie, zastępując
w kroku 9b, w pasku formuły fragment kodu "Rowery" wyrażeniem
List.Last(Table.ColumnNames(#"Zmieniono typ")).
Podsumowanie
W tym rozdziale dowiedziałeś się, jak wyodrębniać informacje kontekstowe zapisane poza tabelami
danych. Poznałeś kilka praktycznych przykładów łączenia informacji kontekstowych z danymi
pochodzącymi z kilku źródeł.
Na początku rozdziału zastosowałeś podstawowe przekształcenie Dołącz zapytania i kolumnę
niestandardową do wyodrębnienia informacji kontekstowych z nazw plików i arkuszy.
Dowiedziałeś się, jak można dynamicznie wyszukiwać i wyodrębniać z arkuszy tytuły tabel
przed ich połączeniem, a następnie umieszczać pozyskane informacje w połączonej tabeli po
zaimportowaniu plików zapisanych w folderze. Za pomocą przekształcenia Wypełnij w dół
utworzyłeś kolumnę zawierającą informacje o kategoriach produktów. Nauczyłeś się tworzyć
w języku M formuły odwołujące się do określonych komórek tabeli.
143
4650570396d9eb2765da56c12eb840b5
4
Do pozyskiwania kontekstu z kilku skoroszytów zapisanych w tym samym folderze zastosowałeś

technikę wyszukiwania i zapisywania informacji po połączeniu tabel. Wykorzystałeś kolumny
warunkowe i przekształcenie Wypełnij w dół do utworzenia kolumny z kategoriami odczytanymi
z osobnych skoroszytów. Technika ta jest szczególnie przydatna w sytuacjach, gdy pozyskiwanie
informacji przed połączeniem tabel nie jest możliwe.
Dowiedziałeś się, jak wykorzystywać wskazówki kontekstowe do odrzucania nieistotnych
informacji, wyszukiwania ważnych danych i umieszczania ich w połączonych tabelach. W jednym
z ćwiczeń użyłeś języka M do utworzenia kolumny indeksu, wyszukania nazw kategorii i zapisania
ich w tabeli. Dowiedziałeś się, jak wykorzystywać kolumnę warunkową, kolumnę indeksu
i przekształcenie Wypełnij w dół do tworzenia nowej kolumny z informacjami kontekstowymi.
Na końcu rozdziału wykorzystałeś wskazówki do wyodrębnienia informacji kontekstowych
zapisanych w komórkach znajdujących się w pobliżu innych komórek (kotwic). Jeżeli ważne dane są
zakotwiczone, wtedy można tworzyć uniwersalne zapytania. Dowiedziałeś się, jak wykorzystywać
funkcję PositionsOf do wyszukiwania potrzebnych komórek kotwic i jak je wyszczególniać,
wykorzystując indeks.
W rozdziale 6., „Rozdzielanie tabel”, poznasz kilka często spotykanych przypadków, w których
kontekst jest zapisany w tabelach w skomplikowany sposób, co utrudnia jego pozyskiwanie
i uniemożliwia wykorzystanie biznesowego potencjału danych.
Kontekst jest kluczem do zrozumienia wszystkiego, jeżeli zatem nie pozyskasz go, stracisz wgląd
w ważne dane.
144
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 6.
Dekomponowanie tabel
Dajcie mi wystarczająco długą dźwignię i punkt podparcia, a poruszę cały glob.

— Archimedes

 rozpoznawać niewłaściwą strukturę tabel,
 stosować podstawowe przekształcenia dekomponujące tabelę, tj. Anuluj przestawienie
kolumn, Anuluj przestawienie innych kolumn i Anuluj przestawienie tylko zaznaczonych
kolumn,
 stosować podstawowe przekształcenia dekomponujące poprawiające kontekst tabeli,
 skutecznie usuwać wiersze i kolumny sumujące z tabel podczas ich importowania,
 dekomponować tabelę z hierarchią agregacji danych 2×2 w wierszach i kolumnach,
 usuwać sumy częściowe.
Do tej pory poznałeś wiele różnych przykładów przetwarzania nieprzygotowanych danych.

Nauczyłeś się stosować różne techniki łączenia tabel i oczyszczania danych w poszczególnych
kolumnach. W rozdziale 5., „Pozyskiwanie kontekstu”, dowiedziałeś się, jak ważny jest kontekst
danych i jak go pozyskiwać. Teraz, gdy wiesz już, jak poprawnie importować dane pochodzące
z różnych źródeł, formatować je, agregować i pozyskiwać z nich kontekst, czas zająć się bardziej
wyrafinowanym problemami.
Tabele przedstawiają dane w określonym kontekście. Pozyskiwanie kontekstu jest to ściśle
określona kwestia, natomiast dobór najlepszej reprezentacji kontekstu to zupełnie inna sprawa.
W tym rozdziale nauczysz się poprawiać struktury tabel w raportach, dzięki czemu dane będą lepiej
reprezentowane i łatwiej je będzie analizować. Przekształcenie Anuluj przestawienie jest podstawową
techniką przetwarzania źle zaprojektowanych tabel, którą każdy dobry analityk musi znać. Jest to
dźwignia Archimedesa i punkt podparcia, poruszające dane wszelkich wielkości i formatów.
4650570396d9eb2765da56c12eb840b5
4
Rozpoznawanie źle zaprojektowanych tabel

W nauce o języku można wyróżnić dziedziny składni, semantyki i pragmatyki. Składnia skupia się
na zależnościach między słowami, semantyka na znaczeniu zdań, a pragmatyka na wpływie
kontekstu na znaczenie przekazu. Tutaj składnię, semantykę i pragmatykę możemy traktować jako
metafory przygotowywania i przekształcania danych.
W poprzednich rozdziałach nauczyłeś się poprawiać „składnię” danych, tj. porządkować ich
niewłaściwy format. Wzbogacałeś „semantykę”, łącząc osobne zbiory danych i pozyskując ich
kontekst. W tym rozdziale skupisz się na bardziej subtelnych zagadnieniach i poznasz „pragmatykę”
danych. Podobnie jak w pragmatyce językowej, gdzie kontekst lub ton wypowiedzi może wpływać
na interpretację przekazu, w analityce od sposobu, w jaki jest zaprojektowana tabela, może zależeć
interpretacja zawartych w niej informacji.
Jeżeli tabela jest dobrze zaprojektowana, można ją skutecznie przetwarzać za pomocą tabeli
przestawnej lub wykresu przestawnego w Excelu albo elementów wizualnych Power BI. Natomiast
źle zaprojektowana tabela wymaga wykonania nadmiernie skomplikowanych przekształceń.
W tym rozdziale dowiesz się, jak zmieniać strukturę źle zaprojektowanych tabel i sposób
reprezentacji danych, aby można było skuteczniej je przetwarzać za pomocą tabel przestawnych
w Excelu lub elementów wizualnych Power BI. Źle zaprojektowana tabela to taka, która niewłaściwie
oddaje rzeczywistość w raportach. Rozpoznanie źle zaprojektowanej tabeli nie zawsze jest prostym
zadaniem. Jednym ze sposobów wykrywania tego symptomu jest intuicyjne sprawdzanie, czy każdy
wiersz tabeli właściwie oddaje istotę rzeczy.
Dane umieszczone w tabeli lub zestawie połączonych tabel zawsze reprezentują jakąś rzeczywistą
treść. Mogą nią być np. przychody w firmie, wyniki pomiarów w eksperymentach naukowych, oceny
uczniów lub wyniki meczów. Wszystkie tego typu wielkości i ich opisy są reprezentowane w postaci
zbiorów wartości, tekstowych i liczbowych, umieszczonych w tabelach. Tabela jest dobrze
zaprojektowana, kiedy każdy jej wiersz reprezentuje unikatową wielkość.
Aby przekonać się, jak trudno rozpoznać złą strukturę tabeli, przeanalizujemy cztery tabele
zaprojektowane na różne sposoby, zawierające tę samą treść: wyniki sprzedaży fikcyjnej firmy
Fabryka Przygód. Jak pokazuje rysunek 6.1, każda z tabel ma inny układ i inaczej pokazuje
sumaryczne wyniki sprzedaży według klientów i kategorii produktów.
Tabela nr 1 na rysunku 6.1 ma układ typowej tabeli przestawnej w Excelu, w której w polu
Wiersze jest umieszczona nazwa klienta, w polu Kolumny nazwa kategorii, a w polu Wartości wyniki
sprzedaży. Tabela ta dobrze prezentuje się w raporcie, ale ze względu na swoją strukturę nie jest
dobrym źródłem danych dla tabeli przestawnej w Excelu lub elementu wizualnego Power BI.
Tabela nr 2 również jest typową tabelą przestawną, w której w polu Kolumny są umieszczone
nazwa klienta i kategoria, a w polu Wartości wyniki sprzedaży. Jeżeli znasz tabele przestawne,
zgodzisz się, że obie tabele, nr 1 i nr 2, reprezentują dane w bardzo podobny sposób.
Tabela nr 3 jest specjalnym przypadkiem. Jej struktura jest ogólnym zbiorem par klucz-wartość.
Choć tabela jest czytelna i można określić kontekst poszczególnych wartości, nie nadaje się do
wykorzystania w Excelu lub Power BI.
146
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 6.  DEKOMPONOWANIE TABEL
RYSUNEK 6.1. Potrafisz rozpoznać, która z tabel przedstawiających sumaryczne wyniki według klientów
i kategorii produktów jest źle zaprojektowana?
Najlepiej jest zaprojektowana tabela nr 4. Zawiera dane o przychodach podsumowane według

klientów i kategorii, zapisane w formacie umożliwiającym przetwarzanie ich w Excelu lub Power BI.
Tabela ta, użyta jako źródło danych, pozwała łatwo uzyskać tabele nr 1 i nr 2. Wystarczy w tym celu
odpowiednio przeciągnąć nagłówki Klient, Kategoria i Przychód do pól Wiersze, Kolumny i Wartości
tabeli przestawnej. Tabela taka jak ta jest często nazywana tabelą faktów, ponieważ reprezentuje
fakty o zawartych w niej wielkościach, czyli w tym przypadku przychody podsumowane według
nazw klientów i kategorii produktów.
Zobacz też. Tabele faktów często pojawiają się również z tabelami wyszukiwania i wymiarów
w układzie gwiaździstym. W rozdziale 2., „Podstawowe operacje przygotowywania danych”,
zostało opisane tworzenie tabeli faktów i tabeli wyszukiwania za pomocą odwołań po usunięciu
duplikatów danych. Aby dowiedzieć się więcej o tabelach faktów w kontekście modelowania
danych w narzędziach Power BI i Power Pivot, sięgnij po książkę Analyzing Data with Power BI
and Power Pivot for Excel Alberto Ferrariego i Marco Russo.
Tabele nr 2 i nr 3 można określić jako nieintuicyjne reprezentacje przychodów firmy Fabryka

Przygód, a więc są to źle zaprojektowane tabele. Trudniej jednak stwierdzić, że tabela nr 1 również
ma tę wadę. W odróżnieniu od tabel nr 2 i nr 3 ma ona układ tabeli przestawnej w Excelu lub
Power BI. Co jest zatem nie tak z jej strukturą? Tabela ta zawiera cztery kolumny tego samego typu,
tj. wyniki sprzedaży produktów różnych kategorii.
147
4650570396d9eb2765da56c12eb840b5
4
Jeżeli stwierdzisz, że tabela źródłowa zawiera kilka kolumn z różnymi kontekstami tego samego
atrybutu, możesz założyć, że można jej nadać lepszy układ. Często np. w źle zaprojektowanej tabeli
dane za poszczególne lata znajdują się w osobnych kolumnach, przy czym każda z nich jest tego
samego typu liczbowego. W tabeli nr 1 przychody dla każdej kategorii produktów są umieszczone
w osobnych kolumnach. Aby podsumować przychody według klientów, należałoby zsumować
wartości w każdej z czterech kolumn, co nie jest praktyczną operacją w Excelu lub Power BI.
Zatem spośród wszystkich tabel przedstawionych na rysunku 6.1 przychody firmy Fabryka
Przygód najlepiej reprezentuje tabela nr 4. Co można jednak zrobić, jeżeli dane źródłowe są
sformatowane tak jak tabele nr 1, nr 2 lub nr 3? Czy można taką tabelę przekształcić do postaci
podobnej do tabeli nr 4 i ułatwić sobie w ten sposób analizę? W praktyce często będziesz miał do
czynienia z tabelami takimi jak trzy pierwsze na rysunku 6.1, a odpowiedź na powyższe pytanie
brzmi: „Tak, można je przekształcać”. Ten rozdział pokazuje, jak można je zamieniać w tabele
faktów, łatwiejsze do przetwarzania za pomocą Excela i Power BI.
Dalej w tym rozdziale opisane jest przekształcenie Anulowanie przestawienia i jego zastosowanie
do przetwarzania tabel, takich jak tabela nr 1 na rysunku 6.1.
Wprowadzenie do anulowania przestawienia

Przekształcenie Anuluj przestawienie kolumn jest dostępne w karcie Przekształć lub w podręcznym
menu pojawiającym się po kliknięciu prawym przyciskiem myszy nagłówka jednej lub kilku
zaznaczonych kolumn. Są trzy odmiany tego przekształcenia:
 Anuluj przestawienie kolumn,
 Anuluj przestawienie innych kolumn,
 Anuluj przestawienie tylko zaznaczonych kolumn.
Wszystkie trzy dają ten sam efekt, ale mogą działać inaczej w miarę dodawania do tabeli
kolejnych kolumn. Dalej w tym rozdziale poznasz różnice pomiędzy tymi przekształceniami.
Przekształcenie Anuluj przestawienie tylko zaznaczonych kolumn zamienia każdą komórkę
w kolumnie na osobny wiersz zawierający kolumny, które nie zostały zaznaczone, oraz dwie
dodatkowe, czyli Atrybut i Wartość. Kolumna Atrybut zawiera nazwę oryginalnej kolumny, a druga
umieszczoną w niej wartość. Rysunek 6.2 pokazuje, jak jest przekształcana każda komórka
oryginalnej tabeli podczas anulowania przestawienia.
Na początku anulowanie przestawienia kolumn może wydawać się skomplikowane. Dlatego
warto pamiętać, że w tym przekształceniu kolumny tabeli dzielą się na dwie grupy.
 Kolumny kotwice, które nie są dekomponowane. Reprezentują one atrybuty, które mają
zostać zachowane. Na rysunku 6.2 jest tylko jedna taka kolumna, tj. Akcesoria. Dalej w tym
rozdziale poznasz przykłady z kilkoma kolumnami kotwicami.
 Kolumny zdekomponowane zawierające różne wartości tego samego atrybutu. Przykładowo
kolumny Akcesoria, Rowery, Komponenty i Ubrania zawierają dane o przychodach. Każda
z nich reprezentuje inną kategorię produktów Fabryki Przygód, ale zawiera wartości tego
samego atrybutu, tj. przychody.
148
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 6.2. Ten diagram pokazuje zmiany położenia określonej wartości z oryginalnej tabeli podczas
anulowania przestawienia
Ćwiczenie 6.1. Przekształcenia Anuluj przestawienie kolumn

i Anuluj przestawienie innych kolumn
W tym ćwiczeniu nauczysz się korzystać z dwóch podstawowych przekształceń, takich jak Anuluj
przestawienie kolumn i Anuluj przestawienie innych kolumn. Wykorzystasz dane firmy Fabryka
Przygód zapisane w formacie podobnym do przedstawionego na rysunku 6.1.
2. Odszukaj plik R06-01.xlsx i kliknij przycisk Importuj.
3. W oknie Nawigator zaznacz tabelę Przychody i kliknij przycisk Przekształć dane.
4. Zwróć uwagę, że tabela widoczna w panelu podglądu zawiera przychody podsumowane
według kategorii Akcesoria, Rowery, Komponenty i Ubrania. Zaznacz cztery ostatnie kolumny.
W tym celu naciśnij klawisz Ctrl i kliknij nagłówek każdej kolumny lub zaznacz kolumnę
Akcesoria, a następnie naciśnij klawisze Shift+End lub trzykrotnie Shift+strzałka w prawo.
5. W kolumnie Przekształć kliknij ikonę Anuluj przestawienie kolumn. Ewentualnie kliknij
prawym przyciskiem myszy zaznaczone kolumny i wybierz polecenie Anuluj przestawienie
kolumn. Tabela zostanie zdekomponowana do postaci tabeli nr 4 z rysunku 6.2.
149
4650570396d9eb2765da56c12eb840b5
4
Zwróć uwagę, że w pasku formuły pojawi się następująca funkcja:

= Table.UnpivotOtherColumns(#"Zmieniono typ", {"Klient"}, "Atrybut", "Wartość")
Usuń z panelu Zastosowane kroki krok Anulowano przestawienie kolumn i zaznacz kolumnę
Klient. Następnie rozwiń w karcie Przekształć ikonę Anuluj przestawienie kolumn i wybierz
polecenie Anuluj przestawienie innych kolumn. Ewentualnie kliknij prawym przyciskiem myszy
zaznaczone kolumny i wybierz polecenie Anuluj przestawienie innych kolumn. Uzyskasz taki sam
efekt, co w kroku 6. Zauważ, że pasek formuły zawiera tę samą funkcję Table.UnpivotOtherColumns,
co poprzednio. Jedyna różnica pomiędzy obydwoma przekształceniami leży w ich nazwach.
Czym więc naprawdę różnią się przekształcenia Anuluj przestawienie kolumn i Anuluj
przestawienie innych kolumn, skoro odpowiadające im funkcje w języku M są takie same? Niczym
poza sposobem użycia. Jeżeli kolumn kotwic jest więcej niż kolumn do zdekomponowania, wtedy
zaznacza się te ostatnie i stosuje przekształcenie Anuluj przestawienie kolumn. W przeciwnym
przypadku stosuje się przekształcenie Anuluj przestawienie innych kolumn.
W tym miejscu na pewno zastanawiasz się, dlaczego obie formuły obu przekształceń są takie
same. Oba polecenia wywołują takie same przekształcenia, ponieważ przyjęte jest w nich wspólne
założenie: w większości przypadków kolumny kotwice nie zmieniają się w miarę upływu czasu,
w odróżnieniu od kolumn dekomponowanych. Przykładowo tabela źródłowa w ćwiczeniu 6.1
zawiera cztery kategorie produktów. Jeżeli firma Fabryka Przygód w przyszłości wejdzie na nowy
rynek lub przejmie kolejną firmę oferującą inną kategorię produktów, wtedy w tabeli źródłowej
pojawi się kolejna kolumna z nową kategorią. Przy użyciu funkcji Table.UnpivotOtherColumns
zapytanie jest skalowalne i nie trzeba go zmieniać w celu zdekomponowania kolejnej kolumny.
Typowym przypadkiem, w którym użycie funkcji Table.UnpivotOtherColumns jest bardzo
uzasadnione, jest dekompozycja tabeli zawierającej kilka kolumn z tymi samymi atrybutami,
ale za różne okresy czasu, np. lata, kwartały lub miesiące. Wtedy używając przekształcenia Anuluj
przestawienie kolumn, można tworzyć uniwersalne zapytania, które będą poprawnie dekomponować
tabele i nie będą ich zmieniać, gdy w miarę upływu czasu pojawią się kolumny obejmujące kolejne
przedziały czasu.
Wskazówka. Ponieważ przekształcenia Anuluj przestawienie kolumn i Anuluj przestawienie

innych kolumn operują na poziomie formuł, zalecane jest sprawdzanie, czy kolumny kotwice
nie zmieniają się po zastosowaniu tych przekształceń.
Formuły M wykorzystywane w przekształceniach Anuluj przestawienie kolumn i Anuluj

przestawienie innych kolumn jawnie odwołują się do kolumn kotwic za pomocą ich nazw.
Przykładowo w poprzednim ćwiczeniu kotwicą była kolumna Klient. Jeżeli zmienisz jej nazwę,
wtedy zapytanie nie wykona się. Co gorsza, jeżeli w tabeli pojawi się kolejna kolumna kotwica,
wtedy zostanie ona zdekomponowana wraz z innymi kolumnami, co może doprowadzić do
uzyskania nieoczekiwanych wyników.
Rysunek 6.3 pokazuje, dlaczego zapytanie nie będzie działać po dodaniu do tabeli z ćwiczenia 6.1
nowej kolumny z adresem klienta. Kolumna Adres zostanie zdekomponowana razem z kolumnami
Akcesoria, Rowery, Komponenty i Ubrania. Ponieważ „Adres” nie jest nazwą kategorii, a kolumna ta
nie zawiera wyników sprzedaży, przy próbie nadania kolumnie Wartość typu Liczba dziesiętna
pojawi się błąd.
150
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 6.3. Dodanie nowej kolumny kotwicy uniemożliwia zdekomponowanie tabeli za pomocą
przekształcenia Anuluj przestawienie kolumn lub Anuluj przestawienie innych kolumn
Jeszcze poważniejszy problem pojawi się, gdy nowa kolumna kotwica będzie zawierała liczby.
Wyobraź sobie, że do tabeli użytej w ćwiczeniu 6.1 została dodana kolumna zawierająca całkowitą
sprzedaż dla poszczególnych klientów. Po odświeżeniu raportu kolumna ta zostanie zdekomponowana
wraz z kolumnami poszczególnych kategorii, potraktowana jak kolumna z przychodami nowej
kategorii i w raporcie pojawią się błędne wyniki.
Co można więc zrobić, jeżeli w tabeli źródłowej będą pojawiać się nowe kolumny kotwice?
Odpowiedź na to pytanie znajdziesz dalej w tym rozdziale.
Ćwiczenie 6.2. Anulowanie przestawienia tylko zaznaczonych kolumn

Jak napisałem wcześniej w tym rozdziale, jeżeli zmieni się kolumna kotwica, wtedy przekształcenie
Anuluj przestawienie innych kolumn nie powiedzie się. Nie będzie można użyć przekształcenia
Anuluj przestawienie kolumn, ponieważ w pasku formuły jest ono zamieniane za pomocą funkcji
Table.UnpivotOtherColumns na Anuluj przestawienie innych kolumn. Dlatego w takim przypadku
należy stosować trzecią odmianę przekształcenia, czyli Anuluj przestawienie tylko zaznaczonych
kolumn. W tym ćwiczeniu wykorzystasz dane innej fikcyjnej firmy, o nazwie Światowi Importerzy,
i zdekomponujesz tabele zawierające przychody za lata 2015, 2016, 2017 i 2018.
151
4650570396d9eb2765da56c12eb840b5
4
4. Zwróć uwagę, że tabela w panelu podglądu zawiera przychody poszczególnych dostawców

za lata 2015, 2016, 2017 i 2018. Zaznacz cztery ostatnie kolumny.
5. W kolumnie Przekształć rozwiń ikonę Anuluj przestawienie kolumn i wybierz polecenie
Anuluj przestawienie tylko zaznaczonych kolumn. Ewentualnie kliknij prawym przyciskiem
myszy zaznaczone kolumny i z podręcznego menu wybierz polecenie Anuluj przestawienie
tylko zaznaczonych kolumn. Tabela zostanie zdekomponowana zgodnie z oczekiwaniami.
W pasku formuły pojawi się formuła wykorzystująca funkcję Table.Unpivot:
= Table.Unpivot(#"Zmieniono typ", {"2015", "2016", "2017", "2018"}, "Atrybut", "Wartość")
Zwróć uwagę, że formuła zawiera na stałe wpisane oznaczenia lat. Jeżeli w tabeli pojawi się
kolumna z przychodami za rok 2019, wtedy zostanie potraktowana jak kolumna kotwica, tak jak
na rysunku 6.4.
RYSUNEK 6.4. Jeżeli w tabeli pojawi się kolumna z danymi za kolejny rok, w przekształceniu
„Anuluj przestawienie tylko zaznaczonych kolumn” zostanie potraktowana jak kolumna kotwica
i tabela zostanie niewłaściwie zdekomponowana
Aby w takim przypadku kolumna 2019 nie była traktowana jak kotwica, zaleca się stosowanie
przekształcenia Anuluj przestawienie innych kolumn. Zważywszy na mankamenty przekształcenia
Anuluj przestawienie tylko zaznaczonych kolumn, należy je stosować tylko wtedy, gdy dekomponowane
kolumny nie zmieniają się, natomiast zmianom ulegają tylko kolumny kotwice.
Przetwarzanie sum całkowitych

Tabele często zawierają kolumny i wiersze z sumami całkowitymi. Pojawia się pokusa, aby
importować je do zapytań, ale nie należy tak robić. Zamiast tego na etapie importu należy usuwać
takie kolumny i wiersze. Sumy mogą uniemożliwiać tworzenie prostych, powtarzalnych raportów.
Ćwiczenie 6.3 demonstruje taki przypadek.
Zobacz też. Oprócz tabel zawierających sumy całkowite nie jest zalecane przetwarzanie tabel
z sumami częściowymi. Ten temat jest opisany dalej w tym rozdziale.
152
4650570396d9eb2765da56c12eb840b5
4
Ćwiczenie 6.3. Dekompozycja tabeli zawierającej sumy całkowite

Poniższe ćwiczenie demonstruje efekt dekompozycji tabeli zawierającej sumy całkowite.
Pokazuje również najlepszy sposób usuwania kolumny lub wiersza z takimi sumami.
Zwróć uwagę, że tabela widoczna w panelu podglądu zawiera przychody podsumowane
według kategorii Akcesoria, Rowery, Komponenty i Ubrania. Ostatni wiersz i ostatnia
kolumna zawierają całkowite sumy przychodów, tak jak na rysunku 6.5.
RYSUNEK 6.5. Dekompozycja tabeli zawierającej wiersz i kolumnę z sumami całkowitymi może skutkować
uzyskaniem błędnych wyników, dlatego takie wiersze i kolumny należy usuwać z zapytania
4. Zaznacz kolumnę Klient, a następnie w kolumnie Przekształć rozwiń ikonę Anuluj

przestawienie kolumn i wybierz polecenie Anuluj przestawienie innych kolumn. Ewentualnie
kliknij prawym przyciskiem myszy nagłówek kolumny Klient i z podręcznego menu wybierz
polecenie Anuluj przestawienie innych kolumn.
Tabela zostanie zdekomponowana. Zwróć uwagę, że dla każdego klienta zostanie utworzony
wiersz zawierający w kolumnie Atrybut wartość Suma. Gdy ponadto przewiniesz tabelę na
sam dół, zobaczysz pięć wierszy zawierających w kolumnie Klient wartości Suma.
Jeżeli zaimportujesz do skoroszytu lub raportu Power BI wiersze i kolumny zawierające sumy
całkowite i zsumujesz kolumnę Wartość, otrzymasz wynik czterokrotnie większy od faktycznego.
Stanie się tak dlatego, że przychód dla każdego klienta i każdej kategorii zostanie zsumowany
czterokrotnie. Aby dowiedzieć się, dlaczego tak jest, policz, ile razy w oryginalnej tabeli pojawia się
wartość przychodu dla wybranego klienta i kategorii: pierwszy raz w określonej komórce, drugi
w sumie wiersza dla danego klienta, trzeci w sumie kolumny dla danej kategorii i czwarty
w całkowitej sumie w prawym dolnym rogu tabeli.
Obecność kolumny i wiersza zawierających sumy może zaburzyć obliczenia i wyniki w raporcie.
Ponadto raport może być podatny na błędy w danych. Dlatego takie wiersze i kolumny musisz usuwać
za pomocą filtrów w elementach wizualnych raportu lub przy użyciu zaawansowanych miar DAX.
Przeanalizujmy formułę DAX, którą można zastosować w tym przypadku. (Otwórz w tym celu
raport Power BI R06-03 - złe rozwiązanie.pbix).
153
4650570396d9eb2765da56c12eb840b5
4
Do zsumowania wszystkich przychodów możesz użyć następującej miary DAX (przy założeniu,
że tabela nazywa się Przychody, a kolumna Przychód):
Całkowity przychód = SUM ( Przychody[Przychód] )
Niestety, uzyskane w ten sposób wyniki będą czterokrotnie większe od rzeczywistych, dlatego
musisz użyć innej formuły:
Całkowity przychód = CALCULATE (
SUM ( Przychody[Przychód] );
FILTER ( Przychody;
Przychody[Klient] <> "Suma" && Przychody[Kategoria] <> "Suma")
)
Powyższą formułę możesz stosować, kiedy będziesz zmuszony przetwarzać dane zawierające
sumy. Jednak lepszym sposobem jest usuwanie sum na poziomie zapytania.
Usuwanie sum
Możesz wprawdzie kontynuować ćwiczenie i odrzucać za pomocą filtru sumy natychmiast po
zdekomponowaniu tabeli, ale takie podejście jest pod względem wydajnościowym nieefektywne,
ponieważ wydłuża czas ładowania danych. Odświeżanie raportu możesz przyspieszyć, usuwając
niepotrzebną kolumnę i wiersz z sumą z tabeli przed jej zdekomponowaniem. W tym celu wykonaj
następujące kroki.
5. W panelu Zastosowane kroki usuń krok Anulowano przestawienie innych kolumn.
6. Zaznacz kolumnę Suma i naciśnij klawisz Delete.
W tym ćwiczeniu Suma jest nazwą kolumny, którą możesz bezpiecznie usunąć,
wykorzystując interfejs edytora. W następnym ćwiczeniu poznasz przypadek, w którym
kolumna z sumami nazywa się Column10. Jeżeli tabela w miarę upływu czasu będzie
rozbudowywana o dodatkowe kolumny (a kolumna z sumami będzie przesuwana w prawą
stronę), wtedy usuwanie kolumn o tego rodzaju ogólnych nazwach może skutkować
uzyskiwaniem nieoczekiwanych wyników. Ćwiczenie 6.4 demonstruje, jak usuwać ostatnią
kolumnę z sumami za pomocą formuły w języku M.
7. W kolumnie Strona główna rozwiń ikonę Usuń wiersze i wybierz polecenie Usuwanie
końcowych wierszy.
8. W oknie, które się pojawi (o tej samej nazwie), wpisz w polu Liczba wierszy wartość 1
Przekształcenie Usuwanie końcowych wierszy jest najprostszym sposobem usuwania wiersza
z sumami, ale często trzeba również usuwać dodatkowe wiersze poniżej tabeli; dzieje się tak
szczególnie wtedy, kiedy źródłem jest skoroszyt zawierający nieoczyszczone dane. Aby
zapytanie było skalowalne i usuwało sumy wraz z dodatkowymi ostatnimi wierszami,
możesz użyć formuły M, która będzie dynamiczne wykrywać sumy i usuwać je wraz
z innymi niepotrzebnymi wierszami.
W tym przypadku formuła usuwająca ostatni wiersz ma następującą postać:
= Table.RemoveLastN(#"Usunięto kolumny",1)
Zamiast niej możesz użyć następujące formuły:
= Table.FirstN(#"Usunięto kolumny",
List.PositionOf(#"Usunięto kolumny"[Klient], "Suma"))
154
4650570396d9eb2765da56c12eb840b5
4
Po naciśnięciu Enter powinieneś uzyskać ten sam wynik, co poprzednio. Powyższa formuła
usuwa ostatni wiersz z sumami, jak również wszystkie kolejne wiersze.
Przyjrzyjmy się bliżej tej formule. Funkcja Table.FirstN zachowuje pierwszych N wierszy
tabeli. Ma dwa argumenty: nazwę tabeli i liczbę wierszy, które mają być zachowane.
Identyfikatorem tabeli jest ciąg #"Usunięto kolumny". Funkcję List.PositionOf użytą
w drugim argumencie poznałeś w rozdziale 5. W tym przypadku wyszukuje ona słowo
„Suma” w kolumnie Klient i zwraca jego indeks, którego wartość oznacza dokładnie liczbę
wierszy, jakie mają zostać zachowane.
Teraz, po usunięciu sum, możesz kontynuować dekomponowanie tabeli.
9. Zaznacz kolumnę Klient, a następnie w kolumnie Przekształć rozwiń ikonę Anuluj
przestawienie kolumn i wybierz polecenie Anuluj przestawienie innych kolumn. Ewentualnie
kliknij prawym przyciskiem myszy nagłówek kolumny Klient i z podręcznego menu wybierz
polecenie Anuluj przestawienie innych kolumn. Zmień nazwę kolumny Atrybut na Kategoria,
a nazwę kolumny Wartość na Przychód.
Jak widać, w przypadku stosowania przekształcenia Anuluj przestawienie bardzo ważne jest usuwanie
sum z tabeli. Jest to prosta operacja, a za pomocą nieskomplikowanej formuły M można usuwać nie
tylko wiersz z sumami, ale również inne znajdujące się niżej wiersze zawierające nieistotne informacje.
Dekompozycja tabeli z hierarchią agregacji danych 22

Wcześniej w tym rozdziale dowiedziałeś się, jak dekomponować proste tabele. W praktyce często
będziesz miał do czynienia z tabelami zawierającymi proste sumy, a przekształcenie Anuluj
przestawienie kolumn będzie jedną z najczęściej wykonywanych przez Ciebie operacji. Dotyczy to
szczególnie skoroszytów, których format nie zawsze jest ściśle przestrzegany.
Ponieważ większość użytkowników Excela nie zna tabel przestawnych, powstają statyczne tabele
sumujące zamiast tabel faktów. Jeżeli wykorzystujesz tego rodzaju tabele do przygotowywania
raportów, możesz za pomocą przekształcenia Anuluj przestawienie kolumn nadawać im format
umożliwiający przetwarzanie ich przy użyciu tabel przestawnych Excela lub elementów wizualnych
Power BI. W praktyce jednak będziesz miał do czynienia z o wiele bardziej skomplikowanymi
tabelami, o wielu poziomach agregacji danych w kolumnach i wierszach.
Kolejne dwa ćwiczenia pokazują, jak dekomponować najczęściej spotykane zagnieżdżone tabele.
Za pomocą opisanych tu technik będziesz mógł dekomponować tabele o różnych strukturach
i przekształcać je w tabele faktów gotowe do przetwarzania za pomocą tabel przestawnych Excela
lub elementów wizualnych Power BI.
Ćwiczenie 6.4. Dekompozycja tabeli

z hierarchią agregacji danych 22 i datami
Zanim zaczniesz dekomponować bardziej skomplikowane tabele, przeanalizujmy następujący
przykład: fikcyjna firma Światowi Importerzy planuje rozszerzyć swoją działalność i poszukuje
kapitału na ten cel. Jesteś analitykiem w firmie inwestycyjnej i dostałeś zadanie ocenienia
działalności firmy. Otrzymałeś raport zawierający wyniki sprzedaży podsumowane według lat,
miesięcy, kategorii i nazw dostawców, pokazany w górnej części rysunku 6.6. Natychmiast uznałeś,
że należy go zdekomponować i przekształcić w tabelę faktów widoczną w dolnej części rysunku.
155
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 6.6. Za pomocą Power Query można łatwo dekomponować skomplikowane tabele, takie jak powyższa,
zawierające sumaryczne wyniki sprzedaży; tabela w dolnej części rysunku lepiej nadaje się do analizy
Zanim wykonasz niezbędne operacje dekompozycji tabeli, przeanalizujmy najważniejsze

problemy, jakie się tu pojawiają. Kolumnami kotwicami są Rok i Miesiąc. Jednak po zaimportowaniu
tabeli do edytora Power Query kolumna Rok będzie zawierała wartości null, podobnie jak kolumna
Kategoria dostawców. Anulowanie przestawienia kolumn zawierających przychody nie powiedzie się,
ponieważ nie będzie można utworzyć par kategoria-nazwa dostawcy. Jeżeli anulujesz przestawienie
kolumn Rok i Miesiąc, wtedy nazwy dostawców pojawią się w kolumnie Wartość, a nie Atrybut.
Aby przygotować tabelę do zdekomponowania, musisz wcześniej wykonać nietrywialną
sekwencję przekształceń, takich jak wypełnienie w dół i scalenie kolumn Rok i Miesiąc, transpozycja
tabeli, wypełnienie w dół kolumny Kategoria dostawców, użycie pierwszego wiersza jako nagłówków
i na koniec anulowanie przestawienia. Poniżej opisane są szczegółowo wszystkie kroki.
4. Zwróć uwagę, że tabela widoczna w panelu podglądu zawiera przychody firmy Światowi
Importerzy podsumowane według lat, miesięcy, kategorii i nazw dostawców, tak jak w górnej
części rysunku 6.6.
5. W panelu Zastosowane kroki usuń dwa ostatnie kroki Zmieniono typ i Nagłówki
o podwyższonym poziomie.
6. Czas usunąć sumy w sposób opisany w ćwiczeniu 6.3. Usuń w zwykły sposób ostatnią
kolumnę, a następnie ostatni wiersz z sumami.
Aby usunąć ostatni wiersz, rozwiń w kolumnie Strona główna ikonę Usuń wiersze i wybierz
polecenie Usuwanie końcowych wierszy. W oknie, które się pojawi (o tej samej nazwie),
wpisz w polu Liczba wierszy wartość 1 i kliknij OK.
156
4650570396d9eb2765da56c12eb840b5
4
Wskazówka. Zwróć uwagę, że zaimportowana tabela zawiera kolumny o domyślnych nazwach

Column1, Column2 itd. Gdy usunąłeś kolumnę z sumami (Column10) za pomocą interfejsu
edytora, w pasku formuły pojawił się następujący kod:
= Table.RemoveColumns(#"Zmieniono typ",{"Column10"})
Więcej o ryzykach związanych z usuwaniem kolumn w oparciu o ich nazwy dowiesz się
w rozdziale 10., „Od złych do dobrych zapytań”, jednak warto o nich wspomnieć już teraz.
Jeżeli tabela zostanie rozbudowana o kolejnego dostawcę, wtedy kolumna Column10 nie będzie
zawierała sum. Dlatego lepszym rozwiązaniem jest usunięcie z panelu Zastosowane kroki kroku
Zmieniono typ, a następnie usunięcie ostatniej kolumny za pomocą następującej formuły:
= Table.RemoveColumns(Przychody_DefinedName,
List.Last(Table.ColumnNames(Przychody_DefinedName)))
Funkcja Table.ColumnNames zwraca listę nazw kolumn tabeli Przychody_DefinedName.

Nazwę ostatniej kolumny zwraca funkcja List.Last.
7. Zaznacz kolumnę Column1, a następnie w karcie Transponuj kliknij ikonę Wypełnij

i polecenie W dół. W ten sposób w komórkach zawierających wartości null zostaną
umieszczone poprawne oznaczenia lat. W rozdziale 5. „Pozyskiwanie kontekstu”,
dowiedziałeś się, jak ważne jest to przekształcenie podczas pozyskiwaniu kontekstu danych.
Tutaj użyłeś go do umieszczenia oznaczenia lat w poszczególnych wierszach.
Teraz scal kolumny Rok i Miesiąc w kolumnę Data, tj. zwiń hierarchię rok/miesiąc
do pojedynczej kolumny. (Za chwilę przekonasz się, jak przydatny jest to krok).
8. Zaznacz kolumny Column1 i Column2, a następnie w karcie Przekształć kliknij ikonę Scal
kolumny. W oknie, które się pojawi, wybierz w rozwijanej liście pozycję Spacja i kliknij OK.
Patrząc na kategorie dostawców znajdujące się w pierwszym wierszu, zapewne chciałbyś użyć
przekształcenia Wypełnij w prawo, aby usunąć wartości null. Nie ma takiego przekształcenia,
ale możesz przetransponować tabelę, a następnie w kolumnie Kategorie dostawców zastosować
przekształcenie Wypełnij w dół. Jak pamiętasz z rozdziału 4., „Łączenie niezgodnych tabel”,
przekształcenie Transponuj zamienia i-ty wiersz i j-tą kolumnę na j-ty wiersz i i-tą kolumnę.
9. W karcie Przekształć kliknij ikonę Transponuj.
10. Teraz możesz wypełnić kolumnę zawierającą kategorie dostawców i usunąć wartości null.
W tym celu zaznacz pierwszą kolumnę, a następnie w karcie Przekształć kliknij ikonę
Wypełnij i wybierz polecenie W dół.
12. Zaznacz dwie pierwsze kolumny (kotwice w tym przypadku) zawierające kategorie i nazwy
dostawców. Następnie w karcie Przekształć rozwiń ikonę Anuluj przestawienie kolumn
i wybierz polecenie Anuluj przestawienie innych kolumn. Ewentualnie kliknij prawym
przyciskiem myszy zaznaczone kolumny i z podręcznego menu wybierz polecenie
Anuluj przestawienie innych kolumn.
13. Zmień nazwy kolumn w następujący sposób.
a. Pierwsza kolumna: Kategoria dostawców.
b. Druga kolumna: Dostawca.
157
4650570396d9eb2765da56c12eb840b5
4
c. Trzecia kolumna: Data.

d. Czwarta kolumna: Przychód.
14. Zmień typ kolumny Data na Data. Sprawdź, czy kolumna Przychód jest typu Liczba
dziesiętna lub Waluta.
15. Załaduj zdekomponowaną tabelę do skoroszytu Excela lub raporty Power BI.
Ćwiczenie 6.5. Dekompozycja tabeli

z hierarchią agregacji danych 2×2
Proces dekomponowania tabeli z hierarchią agregacji danych 2×2 i przekształcania jej do tabeli faktów
można uogólnić. W ćwiczeniu 6.4 dwupoziomową hierarchię tworzyły kolumny Rok i Miesiąc, które
scaliłeś, aby pozyskać kontekst. Zastanówmy się teraz, co można zrobić, kiedy scalenie kolumn nie
jest możliwe.
Rysunek 6.7 przedstawia tabelę przychodów firmy Fabryka Przygód podsumowanych według
sprzedawców, klientów, kategorii i podkategorii. Najpierw musisz wykonać operacje przygotowujące
tabelę do zdekomponowania. Te operacje są Ci już znane z ćwiczenia 6.4, natomiast tutaj zostały
uogólnione.
RYSUNEK 6.7. Za pomocą Power Query można dekomponować skomplikowane tabele, takie jak górna,
podsumowująca sprzedaż w firmie Fabryka Przygód; dolna tabela oczywiście lepiej nadaje się do analizy

158
4650570396d9eb2765da56c12eb840b5
4
3. W oknie Nawigator zaznacz tabelę Przychody i kliknij przycisk Przekształć dane. Zwróć
uwagę, że tabela widoczna w panelu podglądu zawiera przychody firmy Fabryka Przygód,
podobnie jak tabela w górnej części rysunku 6.7.
5. Usuń ostatnią kolumnę i ostatni wiersz (z sumami) zgodnie z zaleceniami w ćwiczeniu 6.4.
6. Zaznacz kolumnę Column1, a następnie w karcie Przekształć kliknij ikonę Wypełnij i wybierz
polecenie W dół. Jest to niezbędny krok, aby wartości null zastąpić imionami sprzedawców.
7. Zaznacz kolumny Column1 i Column2, a następnie w karcie Przekształć kliknij ikonę Scal kolumny.
W oknie, które się pojawi, wybierz w rozwijanej liście pozycję Dwukropek i kliknij OK.
Uwaga. W ćwiczeniu 6.4 scalenie kolumn było oczywistym krokiem, gdyż później zamieniłeś
rok i miesiąc na datę. W tym przypadku scalenie kolumn zawierających imiona sprzedawców
i nazwy klientów może się wydawać nierozsądne, ponieważ łączone są dwie różne informacje,
co wprowadza pewne zamieszanie. Niemniej jednak ten krok jest niezbędny do zdekomponowania
tabeli. W kroku 13. z powrotem podzielisz kolumnę i posprzątasz ten tymczasowy bałagan.
Dlaczego do scalenia kolumn użyłeś właśnie dwukropka? Ponieważ przyjęliśmy założenie,

że imiona sprzedawców i nazwy klientów nie zawierają tego znaku. Dzięki temu później
będziesz mógł podzielić kolumnę. Gdy będziesz stosował to przekształcenie w swoich
analizach, pamiętaj, aby wybierać separator, którego nie ma w danych. W kroku 7. możesz
nawet wybrać niestandardową kombinację znaków.
9. Zaznacz kolumnę Column1, a następnie w karcie Przekształć kliknij ikonę Wypełnij i wybierz
polecenie W dół.
11. Zaznacz dwie pierwsze kolumny (kotwice reprezentujące kategorię i klienta).
12. W karcie Przekształć rozwiń ikonę Anuluj przestawienie kolumn i wybierz polecenie Anuluj
przestawienie innych kolumn. Ewentualnie kliknij prawym przyciskiem myszy zaznaczone
kolumny i z podręcznego menu wybierz polecenie Anuluj przestawienie innych kolumn.
Teraz musisz poprawić kolumnę Atrybut zawierającą scalone imiona sprzedawców i nazwy
klientów.
13. Zaznacz kolumnę Atrybut, a następnie w kolumnie Przekształć kliknij ikonę Podziel kolumny
i wybierz polecenie Według ogranicznika. W oknie Dzielenie kolumny według ogranicznika
w rozwijanej liście Wybierz lub wprowadź ogranicznik wskaż Dwukropek i kliknij OK.
14. Zmień nazwy kolumn w następujący sposób.
a. Pierwsza kolumna: Kategoria.
b. Druga kolumna: Podkategoria.
c. Trzecia kolumna: Sprzedawca.
d. Czwarta kolumna: Klient.
e. Piąta kolumna: Przychód.
159
4650570396d9eb2765da56c12eb840b5
4
15. Zmień typ ostatniej kolumny na Liczba dziesiętna lub Waluta.

16. Załaduj zdekomponowaną tabelę do skoroszytu Excela lub raportu Power BI.
Przetwarzanie sum częściowych

Wcześniej w tym rozdziale dowiedziałeś się, dlaczego sumy całkowite znajdujące się w danych
źródłowych mogą być przyczyną komplikacji. Ten sam problem dotyczy sum częściowych. Aby
tabele przestawne w Excelu lub elementy wizualne Power BI zawierały poprawne dane, można
w nich za pomocą filtrów odrzucać zsumowane wartości. Lepiej jednak usuwać sumy częściowe
na poziomie zapytania.
W ćwiczeniu 6.3 dowiedziałeś się, jak w dość prosty sposób usuwać sumy przed zdekomponowaniem
tabeli. Jednak usuwanie sum częściowych z tabeli źródłowej jest dość trudne. Aby zilustrować ten
problem, przyjrzyjmy się tabeli podobnej do wykorzystanej w ćwiczeniu 6.5, ale tym razem zawierającej
sumy częściowe, tak jak na rysunku 6.8.
RYSUNEK 6.8. Przedstawiona tabela zawiera przychody firmy Fabryka Przygód podsumowane według
sprzedawców i kategorii produktów
Ćwiczenie 6.6. Przetwarzanie sum częściowych

W tym ćwiczeniu nauczysz się usuwać sumy częściowe po zdekomponowaniu tabeli. Ważne jest, aby
to robić na tym właśnie etapie, ponieważ kolumny zawierające sumy częściowe mogą zmieniać swoje
położenie w danych źródłowych. Gdybyś to robił przed zdekomponowaniem tabeli, wtedy w przyszłości
usuwane byłyby np. kolumny zawierającą dane produktów, a nie sumy częściowe, przez co pojawiłyby
się problemy. Aby umiejętnie usunąć sumy częściowe, należy najpierw anulować przestawienie
kolumn, a potem odrzucać sumy za pomocą filtrów. Poniższe ćwiczenie ilustruje ten proces.
1. Zaimportuj plik R06-06.xlsx.
3. W panelu Zastosowane kroki usuń dwa ostatnie kroki, czyli Zmieniono typ i Nagłówki
4. Wykonaj kroki od 6. do 15. z ćwiczenia 6.5, aby zdekomponować tabelę. Ewentualnie
otwórz plik R06-05 - rozwiązanie.xlsx lub R06-05 - rozwiązanie.pbix i w panelu
Zastosowane kroki, w kroku Źródło zmień nazwę pliku z R06-05.xlsx na R06-06.xlsx.
Dodatkowo usuń kroki usuwające kolumnę i wiersz z sumami — w tym ćwiczeniu
wykonasz je po zdekomponowaniu tabeli.
160
4650570396d9eb2765da56c12eb840b5
4
5. Zwróć uwagę, że kolumna Kategoria zawiera wartości Akcesoria, suma, Rowery, suma,
Ubrania, suma i Komponenty, suma. (patrz rysunek 6.9). Usuń te wiersze. W tym celu kliknij
przycisk filtru w nagłówku kolumny Kategoria.
RYSUNEK 6.9. Sumy częściowe należy usunąć po zdekomponowaniu tabeli; nie rób tego jednak,
usuwając zaznaczenia w panelu filtr, tylko użyj filtru tekstowego
W tym momencie zapewne chciałbyś w panelu filtru usunąć zaznaczenia pozycji wyróżnionych
na rysunku 6.9. Jeżeli jednak to zrobisz, zapytanie będzie usuwało tylko te właśnie pozycje
i jeżeli w przyszłości w tabeli źródłowej pojawią się nowe kategorie, nie będą usuwane.
6. Aby poprawnie usunąć wiersze, kliknij polecenie Filtry tekstu i Nie kończy się na.
7. W oknie Filtrowanie wierszy, które się pojawi, wpisz w górnym polu po prawej stronie słowo
suma. Następnie zaznacz opcję Oraz, w dolnej rozwijanej liście wybierz nie równa się i w dolnym
polu po prawej stronie wpisz słowo Suma. Kliknij OK, aby zamknąć okno. Sprawdź, czy dane
zostały poprawnie przefiltrowane. W tym celu ponownie kliknij przycisk filtru. W panelu nie
powinny być widoczne pozycje wyróżnione na rysunku 6.9.
Za pomocą powyższego filtru usunąłeś sumy częściowe kategorii. Wciąż jednak istnieją
wiersze zawierające sumy częściowe sprzedawców (wróć do rysunku 6.8 przedstawiającego
wiersze i kolumny zawierające sumy częściowe).
8. Kliknij przycisk filtru w nagłówku kolumny Sprzedawca. Czy widzisz sumy częściowe?
Aby je usunąć, wybierz polecenie Filtry tekstu i Nie kończy się na.
161
4650570396d9eb2765da56c12eb840b5
4
9. W oknie Filtrowanie wierszy wpisz w górnym polu po prawej stronie słowo suma. Zaznacz
opcję Oraz, w dolnej rozwijanej liście wybierz nie równa się i w dolnym polu po prawej
stronie wpisz słowo Suma. Kliknij OK, aby zamknąć okno. Sprawdź, czy dane zostały
poprawnie przefiltrowane. W tym celu ponownie kliknij przycisk filtru. Sumy częściowe
nie powinny już być widoczne w panelu filtru.
10. Załaduj zdekomponowaną tabelę do skoroszytu Excela lub raportu Power BI. Sumy
częściowe i całkowite zostały usunięte.
Podsumowanie
Wracając do analogii z językoznawstwa, w tym rozdziale przeszedłeś z dziedzin składni (oczyszczania
danych) i semantyki (pozyskiwania kontekstu) do dziedziny pragmatyki, w której kontekst danych
może wpływać na ich interpretację. Przekonałeś się, że nawet czyste dane mogą nie nadawać się do
przetworzenia za pomocą tabeli przestawnej Excela lub elementu wizualnego Power BI.
Nauczyłeś się rozpoznawać źle zaprojektowane tabele i poznałeś trzy przekształcenia:
Anuluj przestawienie kolumn, Anuluj przestawienie innych kolumn i Anuluj przestawienie tylko
zaznaczonych kolumn.
Zdekomponowałeś kilka prostych tabel i dowiedziałeś się, jak przetwarzać wiersze i kolumny
zawierające sumy całkowite. Anulowałeś przestawienie kolumn w tabeli z hierarchią agregacji
danych 2×2. W jednym ze scenariuszy przygotowałeś tabelę do zdekomponowania, scalając
kolumny Rok i Miesiąc. Później zająłeś się bardziej ogólnym przypadkiem, w którym scalenie
kolumn stanowiło pośredni krok do dekompozycji tabeli.
W ćwiczeniach w tym rozdziale wykonywałeś serie podobnych operacji: wypełnienie kolumny
kotwicy, scalenie dwóch kolumn w jedną, transpozycja tabeli, wypełnienie nowej kolumny kotwicy,
użycie pierwszego wiersza jako nagłówków kolumn, anulowanie przestawienia kolumn i podzielenie
scalonej kolumny Atrybut.
Na koniec poznałeś technikę usuwania sum częściowych po zdekomponowaniu tabeli. Jest to
bezpieczniejszy sposób niż usuwanie sum przed dekompozycją, ponieważ w miarę upływu czasu
kolumny z sumami mogą zmieniać swoje położenie w tabeli.
W rozdziale 7., „Zaawansowane metody przestawiania tabel i anulowania przestawień”, będziesz
kontynuował swoją przygodę z przekształceniem Anuluj przestawienie kolumn. Poznasz ogólne
rozwiązanie umożliwiające dekomponowanie dowolnej tabeli, bez względu na liczbę poziomów
agregacji danych w wierszach i kolumnach. Dowiesz się również, w jakich sytuacjach takie
przekształcenie jest niewskazane i zamiast niego należy stosować odwrotną operację,
tj. przestawienie kolumn.
162
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 7.
Zaawansowane metody
dekomponowania
i agregowania tabel
Niektórzy malarze przekształcają słońce w żółtą plamę, inni przekształcają żółtą plamę
w słońce.
— Pablo Picasso

 dekomponować tabele z hierarchią agregacji danych 3×3, uogólniać przekształcenia
i dekomponować dowolną tabelę podsumowującą,
 zamieniać sekwencję przekształceń dekomponujących tabelę na funkcję i stosować ją
podczas importowania wielu plików z folderu lub wielu arkuszy ze skoroszytu,
 agregować tabelę, aby odwrócić dekompozycję,
 agregować wielowierszowe rekordy w tabelę faktów.
W tym rozdziale będziesz kontynuował poznawanie przekształcenia Anuluj przestawienie kolumn.

Uogólnisz je, dzięki czemu będziesz mógł je stosować do dekomponowania dowolnych tabel
podsumowujących, niezależnie od liczby poziomów agregacji danych w wierszach i kolumnach.
Dowiesz się również, co robić, gdy tabela jest nadmiernie zdekomponowana i jak z powrotem ją
zagregować. Nauczysz się również zamieniać wielowierszowe rekordy w tabelę za pomocą
przekształcenia Kolumna przestawna.
Niektóre techniki opisane w tym rozdziale wymagają użycia języka M. Został on krótko
przedstawiony w rozdziale 1., „Wprowadzenie do Power Query”, i sporadycznie użyty w innych
rozdziałach. Zachęcam, abyś wrócił do tego rozdziału po dokładnym przeczytaniu rozdziału 9.,
„Wprowadzenie do języka M”.
Przy użyciu opisanych tutaj technik będziesz mógł wykonywać szerokie spektrum przekształceń
i przetwarzać nadmiernie ustrukturyzowane zbiory danych. Wielu analityków wie, jak zamienia się
proste dane w tabele podsumowujące, natomiast Ty będziesz jednym z tych, którzy wiedzą, jak
przekształca się tabele podsumowujące w proste dane.
4650570396d9eb2765da56c12eb840b5
4
Dekomponowanie tabeli
z wielopoziomową hierarchią agregacji danych
W rozdziale 6., „Dekomponowanie tabel”, dowiedziałeś się, jak ważne jest dekomponowanie tabel
i modyfikowanie ich struktur tak, aby można je było przetwarzać za pomocą tabel przestawnych
Excela lub elementów wizualnych Power BI. Swoją przygodę zacząłeś od zdekomponowania prostej
tabeli, a potem zająłeś się bardziej zaawansowanymi przypadkami obejmującymi dwupoziomową
hierarchię agregacji danych.
W tym rozdziale będziesz kontynuował swoją przygodę i dekomponował jeszcze bardziej
skomplikowane tabele o trzech poziomach hierarchii agregacji. Dowiesz się, z jakich przekształceń
składa się uniwersalna procedura umożliwiająca zdekomponowanie tabeli o dowolnej liczbie
poziomów hierarchii.
Wirtualna tabela przestawna, pola wierszy i kolumn

Abyś mógł uogólnić przekształcenia niezbędne do zdekomponowania dowolnej tabeli, musisz
poznać pojęcia pola wierszy oraz pola kolumn i nauczyć się postrzegać tabelę podsumowującą jako
wirtualną tabelę przestawną.
Jeżeli źródłem danych jest tabela podsumowująca, możesz sobie wyobrazić, że została utworzona
w Excelu jako tabela przestawna. W rzeczywistości tak nie jest, bo tabela podsumowująca ma pola
„zakodowane” na stałe, będziesz mógł jednak wyodrębnić jej pola wierszy i kolumn, a potem ją
zdekomponować. Rysunek 7.1 pokazuje, jak przyrównać tabelę źródłową do przestawnej
z odpowiednimi polami umieszczonymi w obszarach wierszy, kolumn i wartości.
RYSUNEK 7.1. Każdą tabelę podsumowującą możesz postrzegać jak wirtualną tabelę przestawną; na tym
rysunku taka tabela jest porównana z rzeczywistą tabelą przestawną zawierającą te same wyniki
164
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 7.  ZAAWANSOWANE METODY DEKOMPONOWANIA I AGREGOWANIA TABEL
Tabela źródłowa pokazana na rysunku 7.1 (zapisana w pliku R07-01.xlsx) zawiera przychody
firmy Fabryka Przygód podsumowane według krajów, stanów/regionów, miast, kolorów, kategorii
i podkategorii. W panelu tabeli przestawnej w dolnej części rysunku widać, że pola Kraj, Stan/region
i Miasto zostały umieszczone w obszarze Wiersze, pola Kolor, Kategoria i Podkategoria w obszarze
Kolumny, a pole Przychód w obszarze Wartości.
Na razie zapewne nie jesteś przekonany, że tabela przestawna może być w czymś pomocna.
Tutaj potrzebna była do zdefiniowania pojęć, których będziemy używać dalej w tym rozdziale.
Dekomponowaną tabelę będziesz mógł sobie wyobrazić jako tabelę przestawną, której odpowiednie
pola zostały umieszczone w obszarach Wiersze i Kolumny. Pojęcia pola wierszy będziesz używał na
określenie kolumn zdekomponowanej tabeli, które mógłbyś umieścić w obszarze Wiersze w panelu
hipotetycznej tabeli przestawnej. Analogicznie pojęcie pola kolumn będzie oznaczało kolumny
zdekomponowanej tabeli, które mógłbyś umieścić w obszarze Kolumny.
Teraz jesteś gotów do pierwszego ćwiczenia, w którym zdekomponujesz tabelę z hierarchią
agregacji danych 3×3. Aby opis był bardziej ogólny, zamiast oznaczenia 3×3 będziemy używać N×M.
Uogólnienie to przyda się dalej w tym rozdziale.
Ćwiczenie 7.1.
Dekompozycja tabeli z hierarchią agregacji danych N×M
Teraz wykonasz serię przekształceń mających na celu zdekomponowanie tabeli źródłowej
przedstawionej na rysunku 7.1. Opisana niżej technika jest podobna do tej, którą stosowałeś
w rozdziale 6. do dekomponowania tabel 2×2. Tutaj jednak będziemy używać ogólnych pojęć, abyś
mógł dekomponować tabele o dowolnej hierarchii agregacji danych w N wierszach i M kolumnach.
Ogólne przekształcenia niezbędne do zdekomponowania tabeli podsumowującej przedstawia
w czytelny sposób rysunek 7.2. Sekwencja kroków jest dość podobna do wykorzystanej w ćwiczeniu
6.5, „Dekompozycja tabeli z hierarchią agregacji danych 2×2”.
Wyobraź sobie, że tabela widoczna w panelu podglądu jest tabelą przestawną, której pola
Kraj, Stan/region i Miasto zostały umieszczone w obszarze Wiersze, a pola Kolor, Kategoria
i Podkategoria w obszarze Kolumny. Niech N i M oznaczają odpowiednio liczbę pól wierszy
i kolumn. W tym przypadku N = 3 i M = 3.
5. Zwróć uwagę, że pierwsze dwie (tj. N–1) kolumny zawierają wartość null (z powodu
hierarchicznej struktury pól wierszy). Zaznacz N–1 kolumn, a następnie w karcie
Przekształć kliknij ikonę Wypełnij i wybierz polecenie W dół.
Teraz musisz scalić wszystkie pola wierszy. W ćwiczeniu 6.5 przekształciłeś w ten sposób
dwie kolumny, natomiast tutaj scalisz trzy, czyli N kolumn.
165
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 7.2. Wykonując przedstawioną tu sekwencję przekształceń, możesz zdekomponować dowolną

tabelę z hierarchią agregacji danych N×M
166
4650570396d9eb2765da56c12eb840b5
4
6. Zaznacz pierwsze N kolumn, a następnie w karcie Przekształć kliknij ikonę Scal kolumny.
Pojawi się okno o tej samej nazwie. W rozwijanej liście Separator wybierz Dwukropek
i kliknij OK.
Uwaga. Upewnij się, że separator, który wybrałeś, nie pojawia się w danych. Zamiast niego
możesz wybrać nietypową kombinację znaków. Pamiętaj, że wybrany separator wykorzystasz
jeszcze w kroku 12.

8. Aby wypełnić pola kolumn i usunąć wartości null z wyższych poziomów hierarchii, zaznacz
M–1 kolumn, a następnie w karcie Przekształć kliknij ikonę Wypełnij i wybierz polecenie W dół.
10. Zaznacz pierwsze M kolumn.
11. W karcie Przekształć kliknij ikonę Anuluj przestawienie kolumn i wybierz polecenie Anuluj
przestawienie innych kolumn. Ewentualnie kliknij prawym przyciskiem myszy zaznaczone
kolumny i z podręcznego menu wybierz polecenie Anuluj przestawienie innych kolumn.
Kolumna Atrybut zawiera scalone pola wierszy (np. Wielka Brytania:Anglia:Liverpool),
będące wynikiem wykonania kroku 6.
12. Zaznacz kolumnę Atrybut, a następnie w karcie Przekształć kliknij ikonę Podziel kolumny
i wybierz polecenie Według ogranicznika. W oknie Dzielenie kolumny według ogranicznika
w rozwijanej liście Wybierz lub wprowadź ogranicznik wskaż Dwukropek i kliknij OK.
Uwaga. Jak wspomniałem, jeżeli dane zawierają dwukropek, użyj zamiast niego tej samej
kombinacji znaków, z której skorzystałeś w kroku 6.
13. Zmień nazwy pierwszych M kolumn na Kolor, Kategoria i Podkategoria, a nazwy N kolejnych
kolumn na Kraj, Stan/region i Miasto.
14. Zmień nazwę kolumny Wartość na inną, opisującą jej zawartość, w tym przypadku Przychód,
i wybierz typ danych Liczba dziesiętna lub Waluta.
15. Załaduj zdekomponowaną tabelę do skoroszytu Excela lub raportu Power BI.
Uogólnienie sekwencji przekształceń

dekomponujących tabelę
Wcześniej w tym rozdziale zdekomponowałeś tabelę z hierarchią agregacji danych 3×3. Teraz
dowiesz się, jak zmodyfikować formuły przekształceń i zamieniać zapytanie w funkcję, której
będziesz mógł używać do dekomponowania dowolnych tabel. Korzyść z utworzenia takiej funkcji
jest oczywista: jeżeli raportów będzie bardzo dużo i w każdym z nich źródłem danych będzie inna
tabela podsumowująca, wtedy raz utworzoną funkcję będziesz mógł wykorzystać w każdym
raporcie. Dzięki niej zamiast całej sekwencji przekształceń opisanych w poprzednim ćwiczeniu
167
4650570396d9eb2765da56c12eb840b5
4
będziesz stosował pojedynczy krok. W tym podrozdziale usprawnisz zapytanie, które utworzyłeś
w ćwiczeniu 7.1, i uogólnisz sekwencję przekształceń dekomponujących, za pomocą których będziesz
mógł przetwarzać dowolną tabelę podsumowującą z dowolną hierarchią pól wierszy i kolumn.
Ćwiczenie 7.2. Zaczynając od końca

Zanim dowiesz się, jak uogólnić sekwencję przekształceń dekomponujących, wykonaj proste ćwiczenie,
w którym wywołasz uniwersalną funkcję. Dzięki temu przekonasz się, jak łatwo można za pomocą
funkcji dekomponować dowolne tabele. W tym ćwiczeniu zaimportujesz inną tabelę niż poprzednio,
tj. z hierarchią 2×2 (widoczną w górnej części panelu podglądu na rysunku 7.3), a następnie
wywołasz funkcję, widoczną w dolnej części rysunku 7.3, wykonującą sekwencję przekształceń
z ćwiczenia 7.1.
RYSUNEK 7.3. W tym ćwiczeniu wywołasz funkcję wykonującą całą sekwencję przekształceń
dekomponujących tabelę
1. Otwórz w Excelu plik R07-02.xlsx lub w Power BI Desktop plik R07-02.pbix.

2. Otwórz edytor Power Query.
W Excelu: kliknij w karcie Dane ikonę Pobierz dane i wybierz polecenie Uruchom edytora
dodatku Power Query.
W Power BI Desktop: kliknij w karcie Strona główna ikonę Edytuj zapytania.
3. W panelu Zapytania zaznacz zapytanie Przychody. Zwróć uwagę, że w panelu podglądu
pojawi się inna tabela niż w poprzednim ćwiczeniu, tj. z hierarchią 2×2 (patrz górna
część rysunku 7.3). W tej tabeli, w obszarze Wiersze zostały umieszczone pola Kategoria
i Podkategoria, a w obszarze Kolumny pola Kolor i Kraj.
168
4650570396d9eb2765da56c12eb840b5
4
Zwróć uwagę, że w panelu Zapytania widoczny jest jeszcze element FnDekomponujTabelę

oznaczony ikoną fx. Jest to funkcja utworzona na podstawie zapytania z ćwiczenia 7.1.
Dalej w tym rozdziale dowiesz się, jak tworzyć takie funkcje. Teraz po prostu użyj jej do
zdekomponowania tabeli Przychody. W tym celu zamiast całej sekwencji przekształceń
wykonasz dwa proste kroki.
4. Upewnij się, że zaznaczone jest zapytanie Przychody, a w pasku formuły kliknij przycisk fx.
Pojawi się nowy krok z następującą formułą:
= Źródło
5. Usuń kod, wpisz następującą formułę i naciśnij Enter:
= FnDekomponujTabelę(Źródło, {"Kategoria","Podkategoria"},
{"Kolor","Kraj"}, "Przychód")
Tabela podsumowująca zostanie przekształcona w tabelę faktów (patrz dolna część rysunku 7.3).
Czy to nie jest magia? Wyobraź sobie, że na podstawie różnych tabel podsumowujących musisz
utworzyć 50 raportów. W takim przypadku powyższa funkcja okaże się niezwykle przydatna.
Przyjrzyjmy się przez chwilę argumentom funkcji FnDekomponujTabelę. Pierwszy zawiera nazwę
tabeli źródłowej, w tym przypadku Źródło. Drugim argumentem jest lista pól wierszy, tj. Kategoria
i Podkategoria. Listę definiuje się za pomocą nawiasów klamrowych, a jej elementy oddziela
przecinkami. Trzecim argumentem jest lista pól kolumn, tj. Kolor i Kraj. Ostatni, czwarty argument
zawiera nazwę kolumny wartości, w tym przypadku Przychód.
Wskazówka. Funkcji FnDekomponujTabelę możesz używać do dekomponowania dowolnej

tabeli. W tym celu musisz ją skopiować do swojego skoroszytu Excela lub raportu Power BI,
ponieważ samo odwołanie się do niej z innego skoroszytu lub raportu nie wystarczy. Aby
skopiować funkcję, kliknij ją prawym przyciskiem myszy w panelu Zapytania i wybierz
polecenie Kopiuj. Następnie w docelowym arkuszu lub raporcie kliknij prawym przyciskiem
myszy puste miejsce w panelu Zapytania i wybierz polecenie Wklej. Ewentualnie w pliku
R07-02.xlsx lub R07-02.pbix możesz otworzyć zaawansowany edytor, skopiować do schowka
kod formuły, a następnie w docelowym raporcie wkleić go do zaawansowanego edytora.
Ćwiczenie 7.3 demonstruje krok po kroku, jak utworzyć funkcję FnDekomponujTabelę.
Ćwiczenie 7.3. Tworzenie funkcji FnDekomponujTabelę

Teraz dowiesz się, jak uogólnić i zamienić w funkcję sekwencję przekształceń dekomponujących
tabelę z ćwiczenia 7.1. Stosując opisaną tu technikę, będziesz mógł nie tylko dekomponować
dowolne tabele podsumowujące, ale przekonasz się również o sile języka M, za pomocą którego
można skutecznie automatyzować proces przetwarzania danych.
Część I. Utworzenie zapytań PolaWierszy, PolaKolumn i PoleWartości

Zacznij od miejsca, w którym zakończyłeś ćwiczenie 7.1, ewentualnie otwórz w Excelu plik
R07-01 - rozwiązanie.xlsx lub w Power BI Desktop plik R07-01 - rozwiązanie.pbix.
2. Utwórz puste zapytanie w następujący sposób.
169
4650570396d9eb2765da56c12eb840b5
4
W Excelu: kliknij prawym przyciskiem myszy panel Zapytania, a następnie wybierz

polecenia Nowe zapytanie, Inne źródła i Puste zapytanie.
W Power BI Desktop: kliknij prawym przyciskiem myszy panel Zapytania, a następnie
wybierz polecenia Nowe zapytanie i Puste zapytanie.
3. Zmień nazwę nowego zapytania na PolaWierszy, a następnie w pasku formuły wpisz
poniższy kod tworzący listę pól wierszy:
= {"Kraj", "Stan / region", "Miasto"}
4. Utwórz następne puste zapytanie, zmień jego nazwę na PolaKolumn i w pasku formuły wpisz
kod tworzący listę pól kolumn:
= {"Kolor", "Kategoria", "Podkategoria"}
Uwaga. Ważne jest, abyś zapytaniom nadał nazwy PolaWierszy i PolaKolumn, ponieważ za chwilę
użyjesz ich w kodzie uogólniającym kroki z ćwiczenia 7.1. Zwróć uwagę, że tamtym ćwiczeniu
symbol N oznaczał liczbę pól wierszy, a M liczbę pól kolumn.
5. Utwórz puste zapytanie, zmień jego nazwę na PoleWartości i w pasku formuły wpisz
następujący kod:
= "Przychód"
Część II. Usunięcie kroków zmieniających typ danych

W tej części ćwiczenia usuniesz kroki Zmieniono typ, ponieważ są one specyficzne dla użytego tutaj
źródła danych i będą utrudniać uogólnianie zapytania, które ma przetwarzać dowolną tabelę
podsumowującą.
6. W panelu Zapytania zaznacz zapytanie Przychody, a następnie w panelu Zastosowane kroki
kliknij krok Zmieniono typ. W pasku formuły pojawi się następujący kod:
= Table.TransformColumnTypes(#"Nagłówki o podwyższonym poziomie",{{"::Kolor", type
text}, {"::Kategoria", type text}, {"Kraj:Stan / region:Miasto / kategoria", type
text}, {"Wielka Brytania:Anglia:Abingdon", type number}, {"Wielka
Brytania:Anglia:Cambridge", type number}, ...
Ten kod został automatycznie utworzony po zastosowaniu przekształcenia Użyj pierwszego
wiersza jako nagłówków. Jest to niepotrzebna formuła, która nie wykona się poprawnie
w przypadku zupełnie nowej tabeli. Dlatego usuń ten krok. W tym celu kliknij ikonę
krzyżyka po lewej stronie i w oknie Usuwanie kroku, które się pojawi, kliknij przycisk Usuń.
Zobacz też. W rozdziale 10., „Od złych do dobrych zapytań”, dowiesz się więcej, dlaczego
należy usuwać krok Zmieniono typ i jawnie ustalać typy kolumn.
7. W panelu Zastosowane kroki kliknij krok Zmieniono typ1. W pasku formuły pojawi się
następujący kod:
= Table.TransformColumnTypes(#"Podzielono kolumnę według ogranicznika",{{"Atrybut.1",
type text}, {"Atrybut.2", type text}, {"Atrybut.3", type text}})
170
4650570396d9eb2765da56c12eb840b5
4
Ten krok został utworzony po podzieleniu kolumny Atrybut. Usuń go, ponieważ w niektórych
przypadkach nie będzie działał. Przykładowo podczas dekomponowania tabeli z dwoma
poziomami hierarchii w wierszach pojawią się dwie, a nie trzy kolumny, których typ
należałoby zmienić. Dlatego kliknij ikonę krzyżyka po lewej stronie kroku i w oknie
Usuwanie kroku kliknij przycisk Usuń.
Część III. Funkcje Table.ColumnNames, List.FirstN i List.Count

W tej części ćwiczenia zmienisz formuły jawnie odwołujące się do nazw kolumn. Uogólnisz je tak,
aby dynamicznie odwoływały się do kolumn na podstawie długości list w zapytaniach PolaWierszy
i PolaKolumn, które utworzyłeś w części I. W tym celu użyjesz trzech przydatnych funkcji:
Table.ColumnNames, List.FirstN i List.Count.
8. W panelu Zastosowane kroki kliknij krok Wypełniono w dół. W pasku formuły pojawi się
następujący kod:
= Table.FillDown(Przychody_DefinedName,{"Column1", "Column2"})
Ten kod został utworzony w ćwiczeniu 7.1, w kroku 5., wypełniającym N–1 kolumn (tj.
wszystkie pola wierszy oprócz ostatniego). Zmień kod tak, aby zamiast wpisanej na stałe listy
{"Column1", "Column2"} wykorzystywał listę dynamiczną, zawierającą nazwy N–1 kolumn
bieżącej tabeli.
Zanim to jednak zrobisz, sprawdźmy szybko, dlaczego w powyższej formule wykorzystywana
jest tabela Przychody_DefinedName, a nie Nawigacja. Gdy przyjrzysz się panelowi Zastosowane
kroki, zauważysz, że krok Wypełniono w dół znajduje się poniżej kroku Nawigacja. Zazwyczaj
formuła odwołuje się do poprzedniego kroku. Tutaj jednak jest inaczej i zamiast tabeli
Nawigacja wykorzystywana jest Przychody_DefinedName. Aby zrozumieć, dlaczego tak jest,
kliknij w karcie Strona główna ikonę Edytor zaawansowany. Pojawi się kod zawierający m.in.
następujący wiersz:
Przychody_DefinedName = Źródło{[Item="Przychody",Kind="DefinedName"]}[Data],
Jak widać, poprawny identyfikator dla kroku Wypełniono w dół to Przychody_DefinedName
(identyfikator znajdujący się przed pierwszym znakiem równości). Teraz, gdy wiesz już, jak
odwoływać się do poprzedniego kroku, zmień krok Wypełniono w dół tak, aby dotyczył N–1
kolumn. Poniżej ponownie pokazana jest oryginalna formuła tego kroku:
= Table.FillDown(Przychody_DefinedName,{"Column1", "Column2"})
Zastąp ją następującą formułą:
= Table.FillDown(Przychody_DefinedName,
List.FirstN(
Table.ColumnNames(Przychody_DefinedName),
List.Count(PolaWierszy) - 1))
Przyjrzyjmy się nowemu kodowi. Pierwotnie drugi argument funkcji Table.FillDown
zawierał statyczną listę kolumn. Aby zastąpić ją dynamiczną listą, trzeba najpierw odczytać
listę wszystkich nazw kolumn tabeli. Do tego celu służy funkcja Table.ColumnNames
z opisanym wcześniej argumentem Przychody_DefinedName:
Table.ColumnNames(Przychody_DefinedName)
Powyższa funkcja odwołuje się do tabeli Przychody_DefinedName utworzonej w kroku
Nawigacja.
171
4650570396d9eb2765da56c12eb840b5
4
Funkcję Table.ColumnNames widziałeś już w kilku wcześniejszych rozdziałach. Tutaj zwraca

ona listę nazw kolumn bieżącej tabeli: Column1, Column2, Column3 itd. Aby otrzymać
pierwsze N–1 nazw, najpierw trzeba wyliczyć wartość N–1. W tym przykładzie N oznacza
liczbę elementów w liście PolaWierszy:
List.Count(PolaWierszy)
Zatem N–1 jest równe następującemu wyrażeniu:
List.Count(PolaWierszy) - 1
Teraz, kiedy wiesz już, jak wyliczać wartość N–1, możesz uzyskać nazwy N–1 kolumn za
pomocą funkcji List.FirstN zwracającej określoną liczbę elementów zadanej listy. Funkcja
ta ma dwa argumenty — listę wejściową i liczbę elementów — które mają zostać zwrócone.
Zatem listę {"Column1", "Column2"} możesz uzyskać za pomocą następującego kodu:
List.FirstN(Table.ColumnNames(Przychody_DefinedName), List.Count(PolaWierszy) - 1)
Wyróżnione wyrażenie stanowi drugi argument funkcji Table.FillDown w zmodyfikowanej
formule:
= Table.FillDown(Przychody_DefinedName,
List.FirstN(
Table.ColumnNames(Przychody_DefinedName),
List.Count(PolaWierszy) - 1))
9. W panelu Zastosowane kroki zaznacz krok Scalono kolumny, który został utworzony
w wyniku scalenia N pierwszych kolumn. W pasku formuły pojawi się kod wykorzystujący
wpisaną na stałe listę {"Column1", "Column2", "Column3"}:
= Table.CombineColumns(
#"Wypełniono w dół",
{"Column1", "Column2", "Column3"},
Combiner.CombineTextByDelimiter(":", QuoteStyle.None),
"Scalone"
)
Uwaga. W pasku formuły powyższy kod jest wpisany w jednym wierszu. Tutaj, aby był bardziej
czytelny, został podzielony na kilka wierszy.
Aby dynamicznie odwołać się do N kolumn tabeli źródłowej, użyj podobnego kodu, jak
w poprzednim kroku, z tą różnicą, że w drugim argumencie funkcji List.FirstN umieść N,
a nie N–1. Poniżej przedstawiona jest zmodyfikowana formuła (w formacie wielowierszowym)
kroku Scalono kolumny:
= Table.CombineColumns(
#"Wypełniono w dół",
List.FirstN(
Table.ColumnNames(#"Wypełniono w dół"),
List.Count(PolaWierszy)
),
Combiner.CombineTextByDelimiter(":", QuoteStyle.None),
"Scalone"
)
172
4650570396d9eb2765da56c12eb840b5
4
10. Przejdź do następnego kroku wymagającego modyfikacji, tj. Wypełniono w dół1. Ten krok
został utworzony w wyniku drugiego przekształcenia Wypełnij w dół (patrz ćwiczenie 7.1,
krok 8.). Poniżej znajduje się kod widoczny w pasku formuły:
= Table.FillDown(#"Transponowano tabelę",{"Column1", "Column2"})
Musisz w nim zamienić wpisaną na stałe listę na jej dynamiczną wersję. Tym razem jednak,
ponieważ operacja jest wykonywana na tabeli przetransponowanej, musisz wypełnić M–1
kolumn wymienionych w liście PolaKolumn. Poniżej przedstawiony został zmodyfikowany kod:
= Table.FillDown(
#"Transponowano tabelę",
List.FirstN(
Table.ColumnNames(#"Transponowano tabelę"),
List.Count(PolaKolumn) - 1
)
)
Tutaj, inaczej niż w kroku 9., do wyliczenia wartości M–1 wykorzystałeś funkcję List.Count
z argumentem PolaKolumn, a nie PolaWierszy.
11. W panelu Zastosowane kroki zaznacz krok Anulowano przestawienie innych kolumn.
W pasku formuły pojawi się kod z wpisanymi na stałe nazwami kolumn:
= Table.UnpivotOtherColumns(#"Nagłówki o podwyższonym poziomie", {"::Kolor",
"::Kategoria", "Kraj:Stan / region:Miasto / kategoria"}, "Atrybut", "Wartość")
W ćwiczeniu 7.1 zastosowałeś przekształcenie Anuluj przestawienie innych kolumn
po uprzednim zaznaczeniu M kolumn. Aby dynamicznie zaznaczać kolumny,
wpisz następujący kod:
= Table.UnpivotOtherColumns(
#"Nagłówki o podwyższonym poziomie",
List.FirstN(
Table.ColumnNames(#"Nagłówki o podwyższonym poziomie"),
List.Count(PolaKolumn)
),
"Atrybut",
PoleWartości
)
Zastosowałeś tutaj podobną technikę jak poprzednio z tą różnicą, że zamiast liczby M użyłeś
M–1, a w argumencie funkcji Table.ColumnNames umieściłeś identyfikator #"Nagłówki
o podwyższonym poziomie" reprezentujący poprzednie przekształcenie.
Dodatkowo, jako nowej nazwy kolumny użyłeś zapytania PoleWartości zamiast ciągu
"Wartość". Dzięki temu będziesz mógł kolumnie nadać nazwę Przychód. Zrobisz to później,
w kroku zmieniającym nazwę kolumny.
12. W panelu Zastosowane kroki zaznacz krok Podzielono kolumnę według ogranicznika.
W pasku formuły pojawi się następujący kod dzielący kolumnę Atrybut na N kolumn
o nazwach Atrybut.1, Atrybut.2 itd.:
= Table.SplitColumn(
#"Anulowano przestawienie innych kolumn",
"Atrybut",
Splitter.SplitTextByDelimiter(":", QuoteStyle.Csv),
{"Atrybut.1", "Atrybut.2", "Atrybut.3"}
)
173
4650570396d9eb2765da56c12eb840b5
4
Czwarty argument funkcji Table.SplitColumn zawiera liczbę lub listę nazw kolumn, które mają
być utworzone w wyniku podziału. Tutaj zamiast domyślnych nazw Atrybut.X użyj nazw
wymienionych w zapytaniu PolaWierszy. Poniżej przedstawiony jest zmodyfikowany kod:
= Table.SplitColumn(
#"Anulowano przestawienie innych kolumn",
"Atrybut",
Splitter.SplitTextByDelimiter(":", QuoteStyle.Csv),
PolaWierszy
)
Część IV. Zmiana nazw kolumn i funkcja List.Zip

Teraz jesteś gotów do zmodyfikowania najtrudniejszego kroku, czyli Zmieniono nazwy kolumn.
13. W panelu Zastosowane kroki zaznacz krok Zmieniono nazwy kolumn. W pasku formuły
pojawi się następujący kod:
= Table.RenameColumns(#"Podzielono kolumnę według ogranicznika",{{"::Kolor", "Kolor"},
{"::Kategoria", "Kategoria"}, {"Kraj:Stan / region:Miasto / kategoria",
"Podkategoria"}, {"Atrybut.1", "Kraj"}, {"Atrybut.2", "Stan / region"}, {"Atrybut.3",
"Miasto"}, {"Wartość", "Przychód"}})
Drugim argumentem użytej tu funkcji Table.RenameColumns jest lista list. Każda wewnętrzna
lista zawiera dwie wartości tekstowe — aktualną i nową nazwę kolumny.
14. Zwróć uwagę, że w kroku 12. nadałeś poprawne nazwy polom wierszy. Tutaj musisz zmienić
nazwy jedynie M pierwszych kolumn. Aby uzyskać listę nazw tych kolumn, użyj
następującego kodu:
List.FirstN(
Table.ColumnNames(#"Podzielono kolumnę według ogranicznika"),
)
Aby uzyskać nowe nazwy, odwołaj się po prostu do zapytania PolaKolumn.
Jak jednak utworzyć listę list, tj. par nazw M kolumn i nazw wymienionych w zapytaniu
PolaKolumn? Użyj do tego celu funkcji List.Zip, której argumentami są dwie listy,
a zwracanym wynikiem lista list, tj. lista par elementów odczytanych z obu list.
Przykładowo poniższa funkcja:
List.Zip({"A","B","C"}, {"1", "2", "3"})
zwraca następujący wynik:
{{"A","1"}, {"B", "2"}, {"C", "3"}}
Jeżeli więc użyjesz funkcji List.Zip z listą nazw M kolumn i zapytaniem PolaKolumn,
tak jak niżej:
List.Zip(
{
List.FirstN(
),
PolaKolumn
}
)
174
4650570396d9eb2765da56c12eb840b5
4
otrzymasz żądaną listę list, tak jak w oryginalnej formule:

{"::Kolor", "Kolor"}, {"::Kategoria", "Kategoria"},
{"Kraj:Stan / region:Miasto / kategoria", "Podkategoria"}
Poniżej przedstawiony jest zmodyfikowany kod kroku Zmieniono nazwy kolumn:
= Table.RenameColumns(
#"Podzielono kolumnę według ogranicznika",
List.Zip(
{
List.FirstN(
),
PolaKolumn
}
)
)
15. Na początku tego ćwiczenia usunąłeś kroki zmieniające typ danych. Pora jawnie zmienić
typ kolumny Przychód na Liczba całkowita. Gdy zrobisz to za pomocą interfejsu edytora,
w pasku formuły pojawi się następujący kod:
= Table.TransformColumnTypes(#"Zmieniono nazwy kolumn", {{"Przychód", type number}})
Zmień wpisaną na stałe nazwę "Przychód" na identyfikator PoleWartości:
= Table.TransformColumnTypes(#"Zmieniono nazwy kolumn", {{PoleWartości, type number}})
Teraz pora odłączyć od źródła uogólnioną sekwencję przekształceń. Zauważ, że pierwsze
dwa kroki odwołują się do określonego skoroszytu lub arkusza. Abyś mógł stosować nową
sekwencję przekształceń z dowolnymi źródłami danych, musisz uogólnić te kroki.
16. W panelu Zastosowane kroki kliknij prawym przyciskiem myszy krok Wypełniono w dół
i wybierz polecenie Wyodrębnij poprzedni. W oknie Wyodrębnianie kroków, które się pojawi,
w polu Nazwa nowego zapytania wpisz Źródło i kliknij OK. Pojawi się nowe zapytanie
ładujące skoroszyt Excela. Do tego zapytania odwołuje się teraz uogólnione zapytanie.
Część V. Przekształcenie zapytania w funkcję

Doszedłeś do ostatniego etapu, w którym przekształcisz zapytanie w funkcję. Krótkie wprowadzenie
do funkcji zostało zawarte w rozdziale 4., „Łączenie niezgodnych tabel”. W Power Query można
definiować parametry i odwoływać się do nich w pasku narzędzi, a za pomocą polecenia Utwórz
funkcję dostępnego w panelu Zapytania można przekształcać zapytania w funkcje.
Dalej w tej książce poznasz więcej praktycznych przykładów przekształcania zapytań w funkcje
za pomocą polecenia Utwórz funkcję. Ponieważ jednak nie działa ono poprawnie z listami, w tym
ćwiczeniu dowiesz się, jak zamiast niego użyć zaawansowanego edytora kodu.
17. W panelu Zapytania kliknij prawym przyciskiem myszy zapytanie Przychody i wybierz
polecenie Edytor zaawansowany. Kod, który się pojawi, zawiera zmienioną wcześniej,
uogólnioną sekwencję przekształceń.
18. Aby zamienić sekwencję przekształceń na funkcję wpisz w pierwszym wierszu
(powyżej słowa kluczowego let) następujący kod:
(Źródło, PolaWierszy, PolaKolumn, PoleWartości) =>
175
4650570396d9eb2765da56c12eb840b5
4
19. Dodatkowo, usuń następujący wiersz:
Źródło = Źródło,
20. Kliknij przycisk Gotowe i zmień nazwę zapytania Przychody na FnDekomponujTabelę.
Zwróć uwagę, że w panelu Zapytania funkcja FnDekomponujTabelę jest oznaczona ikoną fx, tak
jak na rysunku 7.4. Gdy klikniesz tę funkcję, w panelu podglądu nie pojawią się dane, tylko panel
Wprowadź parametry, w którym będziesz mógł wywoływać funkcję. W tym przypadku jednak
funkcja nie będzie działała poprawnie, ponieważ w polach parametrów nie można wpisywać list.
Ponadto zwróć uwagę, że w panelu Zastosowane kroki cała sekwencja kroków została zredukowana
do pojedynczego kroku, a samej funkcji nie można już edytować za pomocą interfejsu programu.
RYSUNEK 7.4. Funkcję utworzoną za pomocą zaawansowanego edytora, a nie z wykorzystaniem polecenia
„Utwórz funkcję”, można modyfikować tylko w edytorze; po przekształceniu zapytania w funkcję w panelu
„Zastosowane kroki” widoczny jest tylko jeden krok, którego nie można edytować
Wskazówka. Funkcji utworzonej za pomocą polecenia Utwórz funkcję, a nie zaawansowanego

edytora, tak jak w krokach od 17. do 20., nie można modyfikować w edytorze, przynajmniej nie
można tego zrobić wprost. Możesz jednak utworzyć duplikat funkcji, a następnie usunąć z niego
pierwszy wiersz lub zamienić go w komentarz, umieszczając na początku znaki //. W ten sposób
przekształcisz funkcję w edytowalne zapytanie. W panelu Zastosowane kroki pojawią się kroki,
które będziesz mógł zmieniać przy użyciu interfejsu programu. Po wprowadzeniu zmian
skopiuj kod z zaawansowanego edytora, wklej go do oryginalnej funkcji i przywróć pierwszy
wiersz do oryginalnej postaci. Kod funkcji będzie zawierał zmiany wprowadzone za pomocą
interfejsu programu.
176
4650570396d9eb2765da56c12eb840b5
4
Zatrzymaj się na chwilę i przyjrzyj dokładniej, co zrobiłeś. W kroku 18. wpisałeś kod
przekształcający zapytanie w funkcję. Funkcja może być samodzielnym zapytaniem, tak jak w tym
przypadku, lub wewnętrznym elementem innego zapytania. Wywołana z argumentami tworzy
nową wartość. Funkcję wywołuje się, wpisując jej nazwę, a za nią w nawiasach ciąg parametrów
oddzielonych przecinkami. Tutaj zdefiniowałeś następujące argumenty:
 Źródło — przekształcana tabela źródłowa,
 PolaWierszy — lista pól do umieszczenia w wierszach (tutaj Kraj, Stan/region i Miasto),
 PolaKolumn — lista pól do umieszczenia w kolumnach (tutaj Kolor, Kategoria i Podkategoria),
 PoleWartości — nowa nazwa kolumny Wartość w zdekomponowanej tabeli (tutaj Przychód).
Symbol => oddziela deklarację interfejsu funkcji od jej implementacji. Część implementacyjną
ukończyłeś w chwili, gdy uogólniłeś poszczególne kroki, używając parametrów Źródło, PolaWierszy,
PolaKolumn i PoleWartości.
Zwróć uwagę, że w nagłówku funkcji można jawnie określić typ argumentów, jak również typ
zwracanego wyniku. Służy do tego celu słowo kluczowe as, po którym umieszcza się oznaczenie
typu. Poniżej przedstawiony jest silnie typowany nagłówek funkcji:
(Źródło as table, PolaWierszy as list, PolaKolumn as list, PoleWartości as text) as table =>
Możesz użyć tego kodu zamiast wiersza wpisanego w kroku 18. Jeżeli zadeklarujesz typy
argumentów, wtedy próba wywołania funkcji z argumentami niewłaściwych typów zakończy się
błędem. Jeżeli np. w argumencie PolaWierszy umieścisz ciąg "Kraj, Stan / region, Miasto",
a nie listę, wtedy pojawi się następujący komunikat:
Expression.Error: Nie możemy przekonwertować wartości "Kraj, Stan / region,..." na typ List.
Szczegóły:
Value=Kraj, Stan / region, Miasto
Type=Type
Część VI. Testowanie funkcji

Teraz możesz użyć funkcji do zdekomponowania dowolnej tabeli podsumowującej, tak jak w ćwiczeniu
7.2. Aby przetestować funkcję na tabeli źródłowej z ćwiczenia 7.1, wykonaj następujące kroki.
21. Kliknij prawym przyciskiem myszy zapytanie Źródło, które utworzyłeś w kroku 16., i wybierz
polecenie Odwołanie. Zmień nazwę nowego zapytania na Wyniki.
22. W pasku formuły pojawi się kod:
= Źródło
= FnDekomponujTabelę(Źródło, PolaWierszy, PolaKolumn, PoleWartości)
W tym momencie możesz usunąć zapytania PolaWierszy, PolaKolumn oraz PoleWartości
i wpisać następujący kod:
= FnDekomponujTabelę(Źródło, {"Kraj", "Stan / region", "Miasto"}, {"Kolor", "Kategoria",
"Podkategoria"}, "Przychód")
Co ciekawe, ale niezbyt praktyczne, powyższa funkcja poprawnie dekomponuje nawet tabelę
1×1. (Zawsze warto testować szczególne przypadki użycia funkcji i zapytań). Możesz np.
zaimportować tabelę, której użyłeś w ćwiczeniu 6.1 (skoroszyt R06-01.xlsx) i po ostatnim
kroku Zmieniono typ utworzyć niestandardowy krok z następującym kodem:
177
4650570396d9eb2765da56c12eb840b5
4
= FnDekomponujTabelę(#"Zmieniono typ", {"Klient"}, {"Kategoria"}, "Przychód")

Jak to działa? Jeżeli pole wierszy lub pole kolumny zawiera tylko jeden element, wtedy
przekształcenie Wypełnij w dół zamiast zgłosić błąd, że lista kolumn jest pusta, zwróci
po prostu tabelę źródłową. Przekształcenie Scal kolumny również działa poprawnie
w przypadkach szczególnych i można je stosować z pojedynczą kolumną, ponieważ wtedy
zwraca tabelę wejściową. Choć stosowanie funkcji FnDekomponujTabelę z tabelą 1×1 nie ma
uzasadnienia, warto upewnić się, że funkcja działa stabilnie również w przypadkach szczególnych.
Wnioski
W tym podrozdziale dowiedziałeś się, jak uogólniać sekwencję przekształceń dekomponujących
skomplikowaną tabelę podsumowującą z wielopoziomową hierarchią agregacji danych w wierszach
i kolumnach. Nauczyłeś się również tworzyć funkcje za pomocą zaawansowanego edytora. Podczas
udoskonalania kroków zapytania wykorzystywałeś funkcje ColumnNames, List.FirstN i List.Zip.
To sprawia, że zapytanie będziesz mógł wykorzystywać w innych sytuacjach i tworzyć raporty
automatycznie importujące i przekształcające różnego rodzaju tabele źródłowe. W rozdziale 9.,
„Wprowadzenie do języka M”, dowiesz się więcej na temat niestandardowych funkcji, a w rozdziale
10., „Od złych do dobrych zapytań”, poznasz przypadki, w których — wprowadzając niewielkie
modyfikacje w formułach M — można dostosowywać zapytania do zmieniających się w szerokim
zakresie formatów danych.
Przekształcenie Kolumna przestawna

W tym i w poprzednim rozdziale poznałeś różne przypadki dekomponowania tabel podsumowujących
i przekształcania ich w tabele faktów. Czasami jednak format tabeli źródłowej jest zbyt płaski, gdy
np. tabela zostanie nadmiernie zdekomponowana i zawiera wiele wierszy opisujących tę samą
wielkość. W tym podrozdziale przedstawione są takie sytuacje i zaprezentowane przekształcenie
Kolumna przestawna, odwrotne do dekompozycji tabeli.
Ćwiczenie 7.4. Przywrócenie niewłaściwie zdekomponowanej tabeli

Poniższe ćwiczenie pokazuje, jak dekompozycja tabeli może zaburzyć dane i jak w takim przypadku
można za pomocą edytora Power Query odwrócić to przekształcenie (przy założeniu, że zmiana nie
jest możliwa u źródła).
4. W panelu podglądu pojawi się tabela (patrz rysunek 7.5) zawierająca listę transakcji
w fikcyjnej firmie Fabryka Przygód.
178
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 7.5. W tym ćwiczeniu dowiesz się, jak poprawić niewłaściwie zdekomponowaną tabelę; w tym
przykładzie anulowanie przestawienia czterech kolumn liczbowych spowodowało utworzenie tabeli,
w której każda transakcja zajmuje cztery wiersze
Cztery ostatnie kolumny zawierają dane liczbowe transakcji: Wartość netto (wartość
zamówienia bez podatku i kosztów transportu), Podatek (wartość podatku), Transport
(koszt wysyłki) i Wartość całkowita (suma Wartość netto + Podatek + Transport).
Tabela ta, widoczna w górnej części rysunku 7.5, jest poprawnie zaprojektowana. Każda
transakcja jest umieszczona w osobnym wierszu, można zatem wykonywać proste operacje
na poziomie wierszy, przykładowo wyliczać procentową stawkę podatku.
W kolejnych krokach zdekomponujesz tę tabelę i poznasz skutki tej operacji.
5. Zaznacz cztery ostatnie kolumny, a następnie w karcie Przekształć kliknij ikonę Anuluj
przestawienie kolumn. Jak widać w dolnej części rysunku 7.5, zdekomponowana tabela jest
bardziej skomplikowana niż oryginalna, ponieważ każdy wiersz zawiera tylko jedną
informację kontekstową o danej transakcji.
Wyobraź sobie, że jest to tabela źródłowa i musisz odwrócić jej dekompozycję. Kolejne kroki
pokazują, jak to zrobić.
6. Zaznacz kolumnę Atrybut i w karcie Przekształć kliknij ikonę Kolumna przestawna.
7. W oknie, które się pojawi, wprowadź następujące zmiany.
a. Sprawdź, czy widoczny jest komunikat Utwórz nowe kolumny przy użyciu nazw w kolumnie
„Atrybut”. Na tym etapie nie możesz wybrać do przestawienia innej kolumny niż Atrybut.
Jeżeli w komunikacie jest wymieniona inna kolumna, oznacza to, że w kroku 6. zaznaczyłeś
niewłaściwą kolumnę. W takim przypadku kliknij przycisk Anuluj, zaznacz właściwą
kolumnę i ponownie kliknij ikonę Kolumna przestawna.
179
4650570396d9eb2765da56c12eb840b5
4
b. W rozwijanej liście Kolumna wartości wybierz pozycję Wartość.

c. Rozwiń sekcję Opcje zaawansowane i w liście Agreguj funkcję wartości wybierz pozycję
Nie agreguj, tak jak na rysunku 7.6.
RYSUNEK 7.6. Opcja „Nie agreguj” w oknie „Kolumna przestawna” pozwala przywrócić zdekomponowaną
tabelę do pierwotnej postaci
d. Kliknij OK, aby zamknąć okno.

W ten sposób przywrócisz tabelę do pierwotnej postaci.
Ćwiczenie 7.5. Agregowanie tabel z wielowierszowymi rekordami

W ćwiczeniu 7.4 zdekomponowałeś tabelę zawierającą cztery kolumny liczbowe. Kolumny kotwice
(zgodnie z nazewnictwem przyjętym w rozdziale 6. „Dekomponowanie tabel”) pozwoliły zachować
kontekst każdej transakcji, gdy zastosowałeś przekształcenie Kolumna przestawna. W tym ćwiczeniu
zobaczysz, co się stanie, gdy zostanie zdekomponowana cała tabela. Dowiesz się też, co można
w takiej sytuacji zrobić.
1. Wykonaj kroki od 1. do 3. z ćwiczenia 7.4.
2. Zaznacz pierwszą kolumnę, a następnie naciśnij klawisze Ctrl+A, aby zaznaczyć wszystkie
kolumny.
3. W karcie Przekształć kliknij ikonę Anuluj przestawienie kolumn.
W panelu podglądu pojawi się zdekomponowana tabela zawierająca tylko dwie kolumny,
czyli Atrybut i Wartość. Na tym etapie nie można użyć przekształcenia Kolumna przestawna,
ponieważ nie ma ani jednej kolumny kotwicy.
Zapisz zapytanie, wrócisz do niego za chwilę.
Zanim nauczysz się przetwarzać pary atrybut-wartość, musisz dowiedzieć się, dlaczego to taki
ważny temat. Atrybut-wartość jest to często stosowany format, szczególnie w plikach dzienników
oraz plikach JSON i XML zawierających dane bez określonej struktury.
180
4650570396d9eb2765da56c12eb840b5
4
Dlaczego ten format jest popularny? Wyobraź sobie, że musisz zaimportować dane z systemu,
w którym użytkownicy mogą ustawiać setki atrybutów. Kilka z nich jest obowiązkowych, a inne są
opcjonalne.
Eksportowanie takich danych do pliku tekstowego o określonej strukturze byłoby nieefektywną
operacją, ponieważ powstałaby tabela z setkami pustych komórek reprezentujących opcjonalne
atrybuty o nieokreślonych wartościach. Aby nie tworzyć takich rozrzedzonych tabel i plików
zawierających głównie separatory pustych wartości, można eksportować wielowierszowe rekordy,
tj. pary atrybut-wartość. Dlatego format ten jest bardzo popularny, stosowany głównie
do eksportowania plików dzienników i danych o nieokreślonej strukturze.
W następnej części ćwiczenia dowiesz się, jak przetwarzać wielowierszowe pary atrybut-wartość.
Zaczniesz od prostego zadania, w którym przyjmiesz założenie, że każdy rekord składa się ze stałej
liczby wierszy. Następnie zajmiesz się bardziej ogólnym przypadkiem, w którym na początku
każdego rekordu znajduje się taki sam atrybut.
Część I. Przetwarzanie stałej liczby atrybutów z wykorzystaniem dzielenia bez reszty

W kroku 3. tego ćwiczenia anulowałeś przestawienie wszystkich kolumn. W efekcie powstała tabela
składająca się z serii grup, z których każda zawierała siedem par atrybut-wartość. Aby przywrócić
tabeli pierwotną postać, musisz najpierw ze wszystkich grup pozyskać konteksty, a następnie każdej
grupie przypisać unikatowy numer.
4. W panelu Zapytania kliknij prawym przyciskiem myszy zapytanie Przychody i wybierz polecenie
Odwołanie. Zmień nazwę nowego zapytania na Przychody – stała liczba atrybutów.
5. W karcie Dodaj kolumnę kliknij ikonę Kolumna indeksu. Pojawi się kolumna z kolejnymi
liczbami, zaczynającymi się od zera w pierwszym wierszu.
W następnym kroku zastosujesz dzielenie przez 7 bez reszty, ponieważ każda grupa składa
się z siedmiu wierszy. Dzięki temu zamienisz indeksy wierszy na indeksy grup.
6. Zaznacz kolumnę Indeks. W karcie Przekształć kliknij ikonę Standardowy i wybierz polecenie
Podziel bez reszty. W oknie o tej samej nazwie, które się pojawi, wpisz w polu Wartość liczbę
7 i kliknij OK. Jak się przekonasz, pierwsza grupa wierszy otrzyma indeks 0, druga indeks 1,
trzecia indeks 2 itd. Teraz możesz użyć przekształcenia Kolumna przestawna.
Uwaga. W kroku 6. nie twórz nowej kolumny z wynikami dzielenia bez reszty. Zamiast tego
wykonaj dzielenie bez reszty na kolumnie indeksu.
7. Zaznacz kolumnę Atrybut, a następnie w karcie Przekształć kliknij ikonę Kolumna przestawna.
a. W rozwijanej liście Kolumna wartości wybierz pozycję Wartość.
b. Rozwiń sekcję Opcje zaawansowane.
c. W rozwijanej liście Agreguj funkcję wartości wybierz pozycję Nie agreguj.
9. Usuń kolumnę Indeks. W ten sposób pomyślnie zagregowałeś dane. Zapisz zapytanie, ponieważ
za chwilę poznasz bardziej ogólną technikę agregowania wielowierszowych rekordów.
181
4650570396d9eb2765da56c12eb840b5
4
Część II. Przetwarzanie zmiennej liczby atrybutów za pomocą kolumny

warunkowej i wypełnienia w dół
Czasami będziesz musiał przetwarzać wielowierszowe rekordy zawierające atrybuty opcjonalne.
W takich przypadkach nie możesz zakładać, że każdy rekord składa się ze stałej liczby atrybutów,
tak jak to zrobiłeś w pierwszej części tego ćwiczenia. W tej części opisana jest bardziej ogólna
technika agregowania danych, opierająca się na założeniu, że pierwszy atrybut w każdym rekordzie
jest taki sam i jest obowiązkowy, a pozostałe atrybuty są opcjonalne. Rysunek 7.7 przedstawia kroki
niezbędne do przekształcenia wielowierszowych rekordów w tabelę faktów.
RYSUNEK 7.7. Jeżeli na początku każdego rekordu znajduje się taki sam atrybut (w tym przykładzie „Kraj”),
możesz przekształcić dane w tabelę faktów o właściwej strukturze
182
4650570396d9eb2765da56c12eb840b5
4
W ćwiczeniu wykorzystaj plik, który utworzyłeś w części I ćwiczenia.

10. W panelu Zapytania kliknij prawym przyciskiem myszy zapytanie Przychody i wybierz
polecenie Odwołanie. Zmień nazwę nowego zapytania na Przychody – stały pierwszy
atrybut. Wykorzystasz je do zagregowania tabeli przy założeniu, że każdy rekord zaczyna się
od atrybutu o nazwie Kraj.
11. W karcie Dodaj kolumnę kliknij ikonę Kolumna indeksu.
Tutaj również wykorzystasz indeks numerujący każdy wiersz tabeli, ale tym razem zadanie
jest trudniejsze: musisz określić, jakie indeksy mają wiersze zawierające w kolumnie Atrybut
wartość Kraj. Do tego celu wykorzystasz kolumnę warunkową i wypełnienie w dół. Oba
przekształcenia są bardzo pomocne przy pozyskiwaniu kontekstu. Szeroko z nich korzystałeś
z rozdziale 5., „Pozyskiwanie kontekstu”, w którym wyodrębniałeś kontekst z tytułów tabel.
warunkowej, które się pojawi, wprowadź następujące zmiany.
a. W polu Nazwa nowej kolumny wpisz ID wiersza.
b. W polu Nazwa kolumny wpisz Atrybut.
c. W rozwijanej liście Operator wybierz pozycję równa się.
d. W polu Wartość wpisz Kraj.
e. W pierwszej rozwijanej liście pod etykietą Wartość wyjściowa wskaż pozycję
Wybierz kolumnę, a w drugiej liście wybierz Indeks.
f. W polu W przeciwnym razie wpisz null. (Wartość ta zostanie umieszczona w wierszach
zawierających atrybuty inne niż Kraj. W ten sposób przygotujesz tabelę do wypełnienia).
g. Kliknij OK, aby zamknąć okno.
13. Zaznacz kolumnę ID wiersza, a następnie w karcie Przekształć kliknij ikonę Wypełnij
i wybierz polecenie W dół. Teraz możesz usunąć kolumnę Indeks.
W kolumnie ID wiersza w pierwszym rekordzie znajduje się liczba 0, w drugim rekordzie
liczba 7, w trzecim 14 itd. Jeżeli zastosujesz tę technikę do przetworzenia wielowierszowych
rekordów z opcjonalnymi atrybutami, wtedy kolumna ta nie będzie zawierała wielokrotności
7 ani żadnej innej liczby. W rzeczywistości nie ma znaczenia, jakie wartości znajdą się
w kolumnie ID wiersza. Ważne jest jedynie, aby wartości te były unikatowe dla każdego
rekordu, czyli grupy wierszy.
Teraz, gdy odtworzyłeś kontekst każdego rekordu, jesteś przygotowany do zagregowania tabeli.
14. Zaznacz kolumnę Atrybut, a następnie w karcie Przekształć kliknij ikonę Kolumna przestawna.
16. Usuń kolumnę ID wiersza.
183
4650570396d9eb2765da56c12eb840b5
4
Podsumowanie
W tym rozdziale zakończyłeś przygodę z dekomponowaniem tabel podsumowujących. Dowiedziałeś
się, jak dekomponować skomplikowane tabele z hierarchią agregacji 3×3 i jak uogólnić przekształcenia
poprzez zastąpienie wpisanych na stałe nazw kolumn formułami M wykorzystującymi funkcje
Table.ColumnNames, List.FirstN i List.Count. Nauczyłeś się przekształcać uogólnione zapytanie w funkcję.
Utworzyłeś funkcję FnDekomponujTabelę, którą pomyślnie przetestowałeś na różnych tabelach.
W tym rozdziale dowiedziałeś się także, jak odwracać dekompozycję tabeli i stosować
przekształcenie Kolumna przestawna w celu poprawienia struktury danych. Poznałeś konsekwencje
dekomponowania wszystkich kolumn tabeli. Dowiedziałeś się, jak agregować dane zapisane
w popularnym formacie danych, tj. wielowierszowych rekordach zawierających pary atrybut-wartość.
Wykorzystałeś do tego celu kolumnę indeksu, kolumnę warunkową i wypełnianie kolumn w dół.
Technikę tę możesz stosować w wielu różnych sytuacjach wymagających przetwarzania
wielowierszowych rekordów.
184
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 8.
Praca grupowa
Wielkich rzeczy w biznesie nigdy nie dokonuje jedna osoba. Zawsze jest to udziałem
grupy ludzi.
— Steve Jobs

 stosować parametry zapytań zawierające ścieżki do lokalnych źródeł danych,
 tworzyć szablony Power BI z parametrami umożliwiającymi współautorom raportów
importowanie danych z lokalnych plików,
 omijać ograniczenia Excela za pomocą tabel parametrów i nazwanych zakresów komórek,
 rozwiązywać problem prywatności danych przy użyciu scalania zapytań,
 otwierać pliki zapisane w usługach OneDrive dla Firm i SharePoint,
 otwierać wybrane podfoldery w usłudze SharePoint i modyfikować zapytania odwołujące
się do lokalnych folderów tak, aby importowały dane z tej usługi,
 bezpiecznie współdzielić skoroszyty Excela i raporty Power BI z innymi użytkownikami.
Gdy nabierzesz doświadczenia w tworzeniu raportów, zaczniesz mierzyć się z problemami
związanymi z przygotowywaniem ich razem z innymi użytkownikami i udostępnianiem innym
osobom. Narzędzie Power Query nie oferuje możliwości jednoczesnego edytowania zapytania przez
kilku użytkowników ani porównywania różnych wersji raportu. Gdy zatem zaczniesz udostępniać
„kod źródłowy” raportów, napotkasz mnóstwo podstawowych problemów, z którymi będziesz
musiał sobie radzić.
Jako autor raportów zapewne pracujesz w zespole specjalistów posiadających uprawnienia
do modyfikowania tych samych skoroszytów Excela i raportów Power BI. Raporty często będziesz
poprawiał, ulepszał i udostępniał w najbardziej tradycyjny i najprostszy sposób – przekazując plik.
Ten rozdział opisuje kilka podstawowych problemów związanych z pracą grupową i sposobów ich
rozwiązywania. Celem jest ułatwienie współpracy z innymi autorami, abyś mógł uniknąć
podstawowych błędów oraz tworzyć uniwersalne zapytania i raporty w nowym kontekście.
4650570396d9eb2765da56c12eb840b5
4
Uwaga. Ten rozdział nie jest poświęcony funkcjonalnościom udostępniania raportów innym
użytkownikom. Temat ten gwałtownie się rozwija i jest traktowany zupełnie inaczej w Excelu
i Power BI. Excel ma pewne ograniczenia dotyczące współdzielenia i odświeżania skoroszytów,
natomiast jego młodszy krewny, Power BI, umożliwia publikowanie raportów w usłudze
PowerBI.com i regularne ich odświeżane. Usługa ta dodatkowo może za pośrednictwem
specjalnego oprogramowania bezpiecznie łączyć się z lokalnymi źródłami danych, dzięki
czemu odbiorcy mogą zawsze mieć dostęp do aktualnych raportów. PowerBI.com oferuje
wiele funkcjonalności współdzielenia raportów (patrz https://docs.microsoft.com/pl-pl/
power-bi/service-share-dashboards) i usprawniania współpracy w obszarze roboczym
(https://docs.microsoft.com/pl-pl/power-bi/service-collaborate-power-bi-workspace).
Pliki lokalne, parametry i szablony

Jeden z problemów, z którym jako autor raportów będziesz się mierzył najczęściej, jest związany
z korzystaniem z lokalnych skoroszytów Excela i plików tekstowych. Zilustruję ten temat na bardzo
popularnym przykładzie tworzenia raportów przez dwie osoby. Poznaj Alicję i Bartka.
Bohaterowie tego rozdziału, Alicja i Bartek, są zaawansowanymi użytkownikami Power Query.
Do niedawna pracowali w osobnych zespołach, w których byli jedynymi ekspertami Power Query
i nie musieli współdzielić swoich zapytań z innymi osobami. Ostatnio jednak połączyli siły i zaczęli
pracować nad złożonymi raportami zainicjowanymi przez Alicję.
Niewłaściwe korzystanie z lokalnych plików

W poniższym ćwiczeniu wykorzystasz pliki R08-01 - Alicja.xlsx (lub R08-01 - Alicja.pbix) oraz R08-01.xlsx.
Gdy Bartek otworzy raport Alicji i spróbuje go odświeżyć, zobaczy następujący komunikat:
DataSource.Error: Nie można odnaleźć części ścieżki „C:\Users\Alicja\Documents\R08-01.xlsx”.
Bartek zapisze najpierw plik R08-01.xlsx w swoim lokalnym folderze, a następnie, aby rozwiązać
problem, wykona poniższe kroki.
1. Otworzy skoroszyt lub raport i uruchomi edytor Power Query.
2. Zmieni każde zapytanie (Przychody, Kategorie i Kolory) w następujący sposób.
a. W panelu Zastosowane kroki zaznaczy pierwszy krok (Źródło).
b. W pasku formuły zastąpi poniższy kod:
= Excel.Workbook(File.Contents("C:\Users\Alicja\Documents\R08-01.xlsx"), null, true)

następującym kodem:
= Excel.Workbook(File.Contents("C:\Users\Bartek\Documents\R08-01.xlsx"), null, true)
Zmieniony wiersz zawiera pełną nazwę pliku R08-01.xlsx, który Bartek zapisał w lokalnym
folderze.
Po wykonaniu kroku 2. dla każdego zapytania problem zniknie i Bartek będzie mógł zacząć
pracę nad raportem. Jakiś czas później prześle raport z powrotem do Alicji, która stwierdzi, że nie
może go odświeżyć. Zgodnie ze wskazówkami, jakie otrzyma e-mailem od Bartka, zmieni ścieżki
we wszystkich trzech zapytaniach.
186
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 8.  PRACA GRUPOWA
W miarę upływu czasu i wymian raportu Alicja i Bartek będą dodawać do niego kolejne
zapytania importujące lokalne pliki. W pewnym momencie będą musieli zmieniać ścieżki z jednej
na drugą w kilkudziesięciu zapytaniach. Czynność ta, w miarę jak do zespołu będą dołączać kolejni
współautorzy, będzie coraz bardziej czasochłonna. Pewnego dnia wszyscy odkryją, że jest lepsze
rozwiązanie tego problemu, czyli zastosowanie parametru.
Ćwiczenie 8.1. Zdefiniowanie parametru z nazwą ścieżki

W edytorze Power Query można definiować parametry i stosować je w formułach M. Do tego
samego parametru może odwoływać się wiele formuł. Użytkownik zmienia wartość parametru tylko
w jednym miejscu i wpływa w ten sposób na działanie wszystkich zapytań. W tym przypadku Alicja
i Bartek mogą modyfikować wartość parametru zawierającego nazwę ścieżki do pliku i w ten sposób
oszczędzić sobie opisanych wyżej kłopotów.
W tym ćwiczeniu dowiesz się, jak zdefiniować parametr zawierający ścieżkę do pliku i rozwiązać
problem Alicji i Bartka.
W Excelu: otwórz skoroszyt C:\Dane\R08\R08-01 - Alicja.xlsx, a następnie w karcie Dane
kliknij ikonę Pobierz dane i wybierz polecenie Uruchom edytora dodatku Power Query.
W Power BI Desktop: otwórz raport C:\Dane\R08\R08-01 - Alicja.pbix, a następnie w karcie
Strona główna kliknij ikonę Edytuj zapytania.
2. W kolumnie Strona główna edytora rozwiń ikonę Zarządzaj parametrami i wybierz
polecenie Nowy parametr. W oknie Parametry, które się pojawi, wykonaj następujące
operacje (patrz rysunek 8.1).
a. W polu Nazwa wpisz Ścieżka.
b. W polu Wartość bieżąca wpisz C:\Dane\R08.
c. Kliknij OK, aby zamknąć okno.
Uwaga. W ćwiczeniu 8.2 zmodyfikujesz parametr tak, aby Alicja i Bartek mogli wybierać
predefiniowane wartości, co ułatwi im pracę. W tym ćwiczeniu będzie to prosty parametr,
któremu będzie można przypisywać dowolną wartość.
3. Dla każdego zapytania widocznego w panelu Zapytania wykonaj następujące operacje.

a. W panelu Zastosowane kroki zaznacz krok Źródło (pierwszy krok).
b. W pasku formuły pojawi się następujący kod:

Zamień fragment "C:\Users\Alicja\Documents\R08-01.xlsx" na Ścieżka & "\R08-01.xlsx".
Poniżej przedstawiony jest zmieniony kod:
= Excel.Workbook(File.Contents(Ścieżka & "\R08-01.xlsx"), null, true)
4. Aby sprawdzić, czy wszystkie zapytania działają zgodnie z oczekiwaniami, kliknij każde
z nich. W panelu podglądu nie powinien pojawiać się komunikat o błędzie.
187
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 8.1. W oknie Parametry możesz tworzyć nowe parametry lub modyfikować istniejące;
parametrów często używa się do definiowania ścieżek do plików źródłowych
Od tej chwili Alicja, Bartek i inni członkowie zespołu mogą modyfikować w jednym miejscu
wartość parametru Ścieżka i odświeżać raport.
Wskazówka. Parametry przydają się w wielu sytuacjach. Można je stosować wszędzie tam,
gdzie każdy użytkownik musi wprowadzać własne wartości. Jeden z przypadków dotyczy
przełączania się pomiędzy ćwiczebnymi, tekstowymi i produkcyjnymi źródłami danych.
W parametrze, który zdefiniowałeś w ćwiczeniu 8.1, ten sam użytkownik może wpisywać nazwy
folderów testowego lub produkcyjnego. Zatem zastosowania parametrów nie ograniczają się do
współdzielenia zapytań między użytkownikami. Za ich pomocą można również kontrolować
cykl życia raportów i zarządzać nimi.
188
4650570396d9eb2765da56c12eb840b5
4
Ćwiczenie 8.2. Tworzenie szablonów w Power BI

Parametry w programie Power BI Desktop mają wiele ciekawych zalet. W tym ćwiczeniu poznasz
szablony i dowiesz się, jak stosując je razem z parametrami, można tworzyć jeszcze łatwiejsze
w użyciu współdzielone raporty.
Szablon jest to specjalny plik programu Power BI Desktop. Można go utworzyć, eksportując
dowolny raport. Plik szablonu ma rozszerzenie .pbit i nie zawiera danych z oryginalnego raportu.
Szablon można współdzielić z innymi autorami i użytkownikami. Użytkownik, otwierając szablon
zawierający parametry, musi podać ich wartości. Zostanie wtedy załadowany raport, którego
zawartość będzie uzależniona od wartości parametrów podanych przez użytkownika.
W tym ćwiczeniu utworzysz szablon na podstawie raportu z ćwiczenia 8.1.
1. Otwórz plik R08-01 - rozwiązanie.pbix.
2. W karcie Plik kliknij polecenie Eksportuj, a następnie Szablon usługi Power BI.
3. W oknie Eksportowanie szablonu, które się pojawi, wpisz opis szablonu. Ten tekst będzie
prezentowany użytkownikowi podczas otwierania szablonu. Poniżej przedstawiony jest
przykładowy opis:
Podaj ścieżkę do pliku R08-01.xlsx, np. C:\Dane\R08.
4. Kliknij OK, aby zamknąć okno.
5. W oknie Zapisywanie jako wybierz docelowy folder i zapisz w nim szablon pod nazwą
R08-02 – rozwiązanie.pbit.
6. Ponieważ program Power BI Desktop cały czas zawiera otwarty plik .pbix raportu, a nie
szablonu, otwórz eksplorator plików i odszukaj plik R08-02 - rozwiązanie.pbit, który
utworzyłeś w poprzednim kroku. Możesz go udostępnić innym twórcom raportów, którzy
nie będą już musieli modyfikować ścieżki w edytorze Power Query w sposób opisany
w ćwiczeniu 8.1.
Jak pokazuje rysunek 8.2, gdy inny użytkownik otworzy szablon, pojawi się okno R08-
02 - rozwiązanie. Użytkownik po wpisaniu nazwy ścieżki i kliknięciu przycisku Załaduj
otworzy raport, po czym zawarte w nim zapytania zaimportują dane z lokalnego folderu.
RYSUNEK 8.2. Użytkownik po otwarciu szablonu Power BI (pliku .pbit) musi podać wartości
wszystkich parametrów
Aby ułatwić pracę Alicji i Bartkowi, którzy wiedzą, jakie ścieżki powinni wpisywać,
wykonaj pozostałą część ćwiczenia.
189
4650570396d9eb2765da56c12eb840b5
4
7. W karcie Strona główna kliknij ikonę Edytuj zapytania, aby otworzyć edytor Power Query.
8. W karcie Strona główna kliknij ikonę Zarządzaj parametrami. W oknie Parametry wybierz
w rozwijanej liście Sugerowane wartości pozycję Lista wartości.
9. W tabeli poniżej listy wpisz następujące ścieżki:
 C:\Dane\R08,
 C:\Users\Alicja\Documents\R08,
 C:\Users\Bartek\Documents\R08.
10. W rozwijanej liście Wartość domyślna wybierz pozycję C:\Users\Alicja\Documents\R08,
która będzie domyślną wartością parametru. (Ponieważ Alicja jest autorką raportu, więc
należy to uhonorować, wybierając jej ścieżkę jako domyślną). Oczywiście, możesz wybrać
dowolną z trzech ścieżek, które wprowadziłeś w kroku 9.
11. W rozwijanej liście Wartość bieżąca wybierz pozycję C:\Dane\R08, ponieważ w tym folderze
znajduje się Twoje lokalne źródło danych.
12. W polu Opis wpisz następujący tekst: Ścieżka do pliku R08-01.xlsx. Podczas otwierania
szablonu po prawej stronie etykiety Ścieżka będzie widoczna ikona informacyjna. Gdy
użytkownik umieści nad nią kursor myszy, pojawi się dymek z tekstem, który tu wpisałeś.
13. Zanim zamkniesz okno, sprawdź, czy wszystkie ustawienia są takie jak na rysunku 8.3.
RYSUNEK 8.3. Parametr Ścieżka możesz zdefiniować tak, aby można było wybierać jedną z predefiniowanych wartości
190
4650570396d9eb2765da56c12eb840b5
4
14. Wykonaj ponownie kroki od 2. do 5., aby utworzyć nowy szablon o nazwie
R08-02 - rozwiązanie 2.pbit.
Tak utworzony szablon możesz udostępnić Alicji i Bartkowi. Gdy któreś z nich otworzy
szablon, zobaczy rozwijaną listę, z której będzie mogło wybrać odpowiednią ścieżkę.
Gotowe rozwiązanie jest zapisane w plikach R08-02 - rozwiązanie.pbit oraz
R08-02 - rozwiązanie 2.pbit.
Za pomocą szablonów można tworzyć uniwersalne raporty wykorzystujące różne źródła
danych o takim samym formacie. Przykład użycia takiego raportu jest opisany na stronie
https://datachant.com/2016/04/29/power-bi-templates.
Ćwiczenie 8.3. Definiowanie parametrów w Excelu

W Excelu, inaczej niż w Power BI Desktop, nie można wyświetlić okna, w którym użytkownik
mógłby wprowadzać wartości parametrów. Szablon w Excelu (plik .xltx) funkcjonuje inaczej i nie
pozwala na wprowadzanie danych podczas otwierania go. Jeżeli więc skoroszyt zawiera parametr
z nazwą ścieżki, wtedy użytkownik musi otworzyć edytor Power Query i zmienić ten parametr.
W tym ćwiczeniu dowiesz się, jak można wykorzystać nazwane zakresy komórek lub tabele,
za pomocą których użytkownik może wprowadzać wartości parametrów bez konieczności
uruchamiania edytora Power Query. Jak się jednak przekonasz, rozwiązane to ma kilka poważnych
ograniczeń. Niemniej jednak technika ta pozwala ładować dane z zewnętrznego źródła, np.
skoroszytu lub pliku konfiguracyjnego, stanowiącego centralne źródło wartości parametrów.
Parametry mogą przykładowo definiować określone wartości progowe wykorzystywane
w przekształceniach, wskazywać źródła danych (np. testowe lub produkcyjne), ograniczać
liczbę wierszy w raporcie lub określać zakres dat danych ładowanych z bazy.
W tym ćwiczeniu wykorzystasz skoroszyt, który utworzyłeś w ćwiczeniu 8.1.
1. Otwórz skoroszyt R08-01 - rozwiązanie.xlsx.
2. Utwórz nowy arkusz i zmień jego nazwę na Zacznij tutaj.
3. W komórce A1 wpisz Ścieżka.
4. W komórce A2 wpisz C:\Dane\R08.
5. Zaznacz komórki A1 i A2, a następnie w karcie Wstawianie kliknij ikonę Tabela. W oknie
Tworzenie tabeli, które się pojawi, zaznacz opcję Moja tabela ma nagłówki i kliknij OK.
6. Zaznacz komórkę A1 lub A2, a następnie w karcie Projekt tabeli w polu Nazwa tabeli wpisz
Parametry.
Uwaga. Zamiast definiować tabelę w krokach 5. i 6., możesz zdefiniować nazwany zakres
komórek. W tym celu zaznacz komórki A1 i A2, a następnie w polu po lewej stronie paska
formuły wpisz Parametry.
Jak pokazuje rysunek 8.4, w pierwszej komórce tabeli znajduje się ścieżka, którą użytkownik
może łatwo modyfikować bez konieczności otwierania edytora Power Query i odszukiwania
w panelu Zapytania potrzebnego parametru. W ten sposób możesz mu ułatwić pracę, a dodatkowo
wskazówki, co musi zrobić (zmienić ścieżkę), będą o wiele prostsze.
191
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 8.4. Parametr Ścieżka możesz w arkuszu Excela zdefiniować w postaci tabeli
Wskazówka. Jeżeli parametrów jest kilka, zdefiniuj każdy z nich w osobnej kolumnie.
W pierwszym wierszu wpisz nazwę, a w drugim wartość parametru. W edytorze Power Query
możesz odwołać się do tak zdefiniowanych parametrów, wykorzystując przekształcenie
Wyszczególnij, opisane w kroku 10.
7. Po zdefiniowaniu tabeli Parametry musisz odwołać się do niej w zapytaniu. W tym celu
zaznacz dowolną komórkę (A1 lub A2), a następnie w karcie Dane kliknij ikonę
Z tabeli/zakresu.
8. Gdy otworzy się edytor Power Query, rozwiń panel Zapytania. Zauważ, że pojawi się w nim
nowe zapytanie o nazwie Parametry, natomiast w panelu podglądu będzie widoczna tabela
z kolumną o nazwie Ścieżka. Jeżeli w przyszłości będziesz potrzebował dodatkowych
parametrów, dodaj do tabeli Parametry w arkuszu kolejne kolumny. Aby użyć określonego
parametru, utwórz nowe zapytanie odwołujące się do powyższego zapytania.
9. W panelu Zapytania kliknij prawym przyciskiem myszy zapytanie Parametry i wybierz
polecenie Odwołanie. Zmień nazwę nowego zapytania na Ścieżka2. (Za chwilę usuniesz
stary parametr Ścieżka, który zdefiniowałeś w ćwiczeniu 8.1).
10. W panelu Zapytania zaznacz zapytanie Ścieżka2, a następnie kliknij prawym przyciskiem
myszy komórkę C:\Dane\R08 i wybierz polecenie Wyszczególnij. Tabela przekształci się
w tekst zawierający nazwę ścieżki.
Wskazówka. W rozdziale 5., „Pozyskiwanie kontekstu”, użyłeś przekształcenia Wyszczególnij

do pozyskania kontekstu z wybranej komórki i umieszczenia go w połączonej tabeli. W tym
ćwiczeniu tę samą technikę wykorzystasz do odczytania wartości parametru.
Od tej chwili możesz w dowolnym zapytaniu odwoływać się do parametru Ścieżka2. Jeżeli
czujesz się pewnie w języku M, kod, który pojawi się w pasku formuły, będzie dla Ciebie
zrozumiały i prosty w użyciu:
= Źródło{0}[Ścieżka]
192
4650570396d9eb2765da56c12eb840b5
4
Ponieważ identyfikator Źródło reprezentuje zapytanie Parametry, nie musisz wykonywać

kroków 9. i 10., tylko odwołać się do parametru Ścieżka za pomocą następującego kodu:
= Parametry{0}[Ścieżka]
Jeżeli w przyszłości zdefiniujesz więcej parametrów, ich wartości będziesz mógł odczytać,
umieszczając w powyższym kodzie nazwę kolumny w miejscu identyfikatora Ścieżka. Gdy
np. zdefiniujesz parametr NazwaPliku, możesz się do niego odwołać w następujący sposób:
= Parametry{0}[NazwaPliku]
Powyższa formuła najpierw odwołuje się do pierwszego wiersza tabeli, a następnie do
kolumny o wskazanej nazwie. Ten sam efekt osiągniesz za pomocą poniższego kodu,
który najpierw odwołuje się do zadanej kolumny, a następnie do jej pierwszej komórki
(o indeksie 0):
= Parametry[NazwaPliku]{0}
Teraz pora zmienić wszystkie zapytania tak, aby odczytywały ścieżkę z zapytania Ścieżka2,
a nie z parametru Ścieżka, który utworzyłeś w ćwiczeniu 8.1. Parametr ten jest wygodniejszy
w użyciu w szablonie Power BI Desktop, natomiast w Excelu bardziej przydaje się parametr
Ścieżka2, zawierający wartość komórki z arkusza.
11. Zaznaczaj kolejno zapytania Przychody, Kolory i Kategorie i w każdym z nich w kroku
Źródło zmień w formule identyfikator Ścieżka na Ścieżka2. Poniżej przedstawiona jest
zmodyfikowana formuła:
= Excel.Workbook(File.Contents(Ścieżka2 & "\R08-01.xlsx"), null, true)
Niestety, po zaznaczeniu innego kroku w panelu podglądu może pojawić się następujący
komunikat:
Formula.Firewall: Element Zapytanie „Przychody” (krok „Źródło”) przywołuje inne
zapytania lub kroki, dlatego nie może uzyskać bezpośredniego dostępu do źródła danych.
Utwórz ponownie tę kombinację danych.
12. Aby rozwiązać ten problem, zmień ustawienia prywatności w skoroszycie. W tym celu
a. Kliknij kartę Plik, a następnie polecenie Opcje i ustawienia/Opcje zapytania.
b. W oknie Opcje zapytania, które się pojawi, kliknij w sekcji Bieżący skoroszyt pozycję
Prywatność.
c. Zaznacz opcję Ignorowanie poziomów prywatności i potencjalne poprawianie wydajności
Uwaga. Opcji ignorowania poziomów prywatności używaj ostrożnie. Jeżeli nie ufasz autorowi
skoroszytu lub gdy zapytania łączą się z nieznanymi Ci zewnętrznymi źródłami danych, nie
wykonuj kroku 12. Istnieje kilka przypadków, w których edytor Power Query nie izoluje
poprawnie źródeł danych i wyświetla komunikat Formula.Firewall. W drugiej części tego
ćwiczenia poznasz bardziej zaawansowany sposób rozwiązania problemu bez konieczności
ignorowania poziomów prywatności.
193
4650570396d9eb2765da56c12eb840b5
4
13. Usuń parametr Ścieżka i zmień nazwę parametru Ścieżka2 na Ścieżka. Po zmianie nazwy
zapytania Przychody, Kolory i Kategorie będą odwoływać się do zapytania Ścieżka, więc nie
musisz powtarzać kroku 11. i zmieniać w formule identyfikatora Ścieżka2 na Ścieżka.
14. W karcie Strona główna rozwiń ikonę Zamknij i załaduj i wybierz polecenie Zamknij
i załaduj do.
15. W oknie Importowanie danych zaznacz opcję Utwórz tylko połączenie, aby zapytanie Ścieżka
nie ładowało się do nowej tabeli.
Od tej chwili, aby zmienić wartość parametru Ścieżka, nie musisz otwierać edytora Power Query.
Wystarczy, że wpiszesz nową ścieżkę w arkuszu i odświeżysz raport. Jeżeli jednak udostępnisz
skoroszyt innemu użytkownikowi, wtedy przy próbie odświeżenia raportu pojawi się ten sam
komunikat, co w kroku 11. Dlatego musisz powiadomić użytkownika, aby zmienił ustawienia
prywatności w sposób opisany w kroku 12. Opcję tę można również zmienić bez konieczności
otwierania edytora Power Query, klikając w kolumnie Dane ikonę Pobierz dane i polecenie Opcje
dodatku Query. Jeżeli nie chcesz dotykać newralgicznego tematu prywatności, możesz udostępniać
skoroszyt w postaci takiej, jak w ćwiczeniu 8.1, albo zastosować technikę opisaną w drugiej części
ćwiczenia, zapobiegającą wyświetlaniu komunikatu Formula.Firewall.
Gotowe rozwiązanie jest zapisane w pliku R08-03 - rozwiązanie.xlsx. Gdy go otworzysz, pojawi
się wyżej opisany komunikat (chyba że wybrałeś opcję ignorowania poziomów prywatności we
wszystkich skoroszytach). Aby rozwiązać problem, kliknij w karcie Dane ikonę Pobierz dane,
następnie wybierz polecenie Opcje dodatku Query i wykonaj kroki 12b i 12c.
Ćwiczenie 8.3. Część II. Przebudowa kombinacji danych

Komunikatu zaczynającego się od Formula.Firewall i kończącego zdaniem Utwórz ponownie tę
kombinację danych możesz się pozbyć, kiedy zignorujesz poziomy prywatności w sposób opisany
w pierwszej części ćwiczenia w kroku 12. lub gdy scalisz wszystkie zapytania odwołujące się do
zewnętrznych źródeł danych w jedno zapytanie. Dobrym miejscem, od którego można zacząć
rozwiązywać ten problem, jest widok zależności zapytań.
Otwórz skoroszyt R08-03 - rozwiązanie.xlsx, uruchom edytor Power Query i w karcie Widok
kliknij ikonę Zależności zapytań. Na podstawie diagramu, który się pojawi (patrz rysunek 8.5),
od razu stwierdzisz, że wszystkie zapytania znajdujące się w dolnej części są uzależnione od dwóch
skoroszytów — bieżącego i lokalnego o nazwie c:\dane\r08\r08-01.xlsx. Zapytania Przychody,
Kolory i Kategorie są od drugiego skoroszytu uzależnione bezpośrednio, natomiast od bieżącego
są uzależnione poprzez zapytania Ścieżka i Parametry.
Scalając odwołania do zewnętrznego źródła danych w jedno zapytanie, można zapobiegać
pojawianiu się komunikatu o błędzie. W tym przypadku należałoby zmienić zapytania Przychody,
Kolory i Kategorie tak, aby bezpośrednio odwoływały się do skoroszytów bieżącego i zapisanego
w pliku c:\dane\r08\r08-01.xlsx. W tym celu zmień każde z powyższych zapytań w następujący
sposób: otwórz zaawansowany edytor i po słowie kluczowym let wpisz poniższy kod:
Ścieżka = Excel.CurrentWorkbook(){[Name="Parametry"]}[Content]{0}[Ścieżka],
Powyższy wiersz konsoliduje wszystkie przekształcenia zapytania Parametry w jeden krok.
Teraz możesz usunąć zapytanie Parametry, ponieważ nie odwołuje się do niego żadne inne zapytanie.
Jeszcze lepszym rozwiązaniem jest utworzenie nowego zapytania Skoroszyt, odwołującego się do
skoroszytów bieżącego i zewnętrznego, a następnie zmodyfikowanie zapytań Przychody, Kolory i Kategorie
tak, aby odwoływały się do nowego zapytania. Poniżej opisane są kroki, które musisz w tym celu wykonać.
194
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 8.5. Okno Zależności zapytań pokazuje, jak poszczególne zapytania odwołują się
do zewnętrznych źródeł danych
1. Otwórz skoroszyt R08-03 - rozwiązanie.xlsx, a następnie w karcie Dane kliknij ikonę

Pobierz dane i wybierz polecenie Uruchom edytora Power Query.
2. Otwórz okno Opcja zapytania i w sekcji Bieżący skoroszyt kliknij Prywatność. Wybierz opcję
Łączenie danych zgodnie z ustawieniami poziomu prywatności dla każdego źródła.
3. W panelu Zapytania kliknij prawym przyciskiem myszy zapytanie Kolory i wybierz polecenie
Duplikuj.
4. Zmień nazwę nowego zapytania na Skoroszyt, a następnie w panelu Zastosowane kroki
usuń wszystkie kroki oprócz Źródło.
5. W kolumnie Strona główna kliknij ikonę Edytor zaawansowany i wpisz wyróżniony
niżej wiersz:
let
Ścieżka = Excel.CurrentWorkbook(){[Name="Parametry"]}[Content]{0}[Ścieżka],
Źródło = Excel.Workbook(File.Contents(Ścieżka & "\R08-01.xlsx"), null, true)
in
Źródło
6. Kliknij przycisk Gotowe, aby zamknąć edytor. Teraz zapytanie będzie zwracać tę samą
zawartość skoroszytu R08-03.xlsx, tak jak przed wykonaniem kroku 4.
195
4650570396d9eb2765da56c12eb840b5
4
7. W panelu Zapytania zmień zapytania Przychody, Kolory i Kategorie w następujący sposób:

w panelu Zastosowane kroki kliknij krok Źródło i pasku formuły wpisz następujący wiersz:
= Skoroszyt
8. W panelu Zapytania usuń zapytania Ścieżka i Parametry.
9. W karcie Strona główna rozwiń ikonę Zamknij i załaduj i wybierz polecenie
Zamknij i załaduj do.
10. W oknie Importowanie danych zaznacz opcję Utwórz tylko połączenie, aby zapytanie
Skoroszyt nie było ładowane do nowej tabeli.
W ten sposób w pojedynczym zapytaniu Skoroszyt scalisz wszystkie odwołania do zewnętrznych
źródeł danych, dzięki czemu przestanie pojawiać się komunikat Formula.Firewall. Otwórz
ponownie okno Zależności zapytań, tak jak na rysunku 8.6, i przekonaj się, że do zewnętrznych źródeł
odwołuje się jedynie zapytanie Skoroszyt, a wszystkie zależności są prostsze niż na rysunku 8.5.
RYSUNEK 8.6. Zależności między zapytaniami po scaleniu odwołań rozwiązującym problem komunikatu
Formula.Firewall
Gotowe rozwiązanie jest zapisane w pliku R08-03 - rozwiązanie 2.xlsx. Dzięki zmianom, które
wprowadziłeś, inni użytkownicy nie będą musieli zmieniać ani anulować swoich ustawień prywatności.
Wskazówka. Przebudowanie zapytań, tak aby nie pojawiał się komunikat Formula.Firewall,
nie zawsze jest proste. Scalenie kilku odwołań w jedno zapytanie utrudnia tworzenie elastycznych,
uniwersalnych zapytań. Dlatego przed wykonaniem tej operacji powinieneś rozważyć jej wszystkie
zalety i wady. Jak się przekonasz dalej w tym rozdziale, istnieją sposoby, za pomocą których nie
trzeba w ogóle odwoływać się do dwóch źródeł danych.
196
4650570396d9eb2765da56c12eb840b5
4
Zobacz też. Choć używanie lokalnych skoroszytów Excela jako źródeł danych wiąże się z pewnymi
problemami, możesz mimo to publikować raporty w usłudze Power BI i regularnie je odświeżać.
Usługa ta może odwoływać się do lokalnych plików (lub innych lokalnych źródeł) za pomocą
bram danych. Więcej informacji na ten temat znajdziesz na stronie https://docs.microsoft.com/
pl-pl/power-bi/service-gateway-onprem.
Praca nad współdzielonymi plikami i folderami

W ćwiczeniach 8.1, 8.2 i 8.3 zastosowałeś różne techniki ułatwiające wspólną pracę nad lokalnymi
plikami. Teraz nasi bohaterowie, Alicja i Bartek, mogą łatwo we współdzielonym raporcie
modyfikować ścieżkę do lokalnego skoroszytu Excela.
Na pewno podejrzewasz, że musi istnieć lepszy sposób grupowej pracy nad raportem. Czy przykładowo
Alicja i Bartek mogliby korzystać ze wspólnego pliku zapisanego w usłudze OneDrive dla Firm lub
SharePoint? Tak, jest to możliwe. Wykonując ćwiczenia, poznałeś ważne techniki wykorzystujące
parametry, szablony i zapytania scalające, przy użyciu których w większości przypadków pracy
na lokalnych plikach można zapobiec pojawianiu się komunikatu o błędzie. Jednak korzystanie
ze współdzielonych plików pozwala rozwiązać wiele innych problemów typowych dla pracy zespołowej.
W tym podrozdziale poznasz sztuczki i kruczki związane z pracą nad plikami współdzielonymi
w usługach OneDrive dla Firm i SharePoint. Będzie Ci potrzebne konto i witryna Office 365,
w której umieścisz pliki.
Importowanie danych z plików zapisanych

w usługach OneDrive dla Firm i SharePoint
Importowanie za pomocą Power Query danych z plików zapisanych w usłudze OneDrive dla Firm
lub SharePoint może być dla początkującego użytkownika nie lada wyzwaniem. W programie Power
BI Desktop nie można za pomocą eksploratora plików przeglądać folderów w tych usługach, tak jak
w lokalnym systemie. Jest to wprawdzie możliwe, gdy folder usługi jest powiązany z lokalnym
folderem, ale wtedy nie można współdzielić plików, ponieważ wykorzystywana jest lokalna ścieżka.
Aby ominąć to ograniczenie, należy określić adres URL pliku w usłudze OneDrive dla Firm lub
SharePoint, a następnie za pomocą konektora WWW zaimportować skoroszyt.
Adres URL pliku można uzyskać na kilka sposobów, z których większości nie można zastosować
w Power Query. Aby uzyskać adres skoroszytu Excela zapisanego w usłudze OneDrive dla Firm lub
SharePoint, wykonaj poniższe kroki.
1. Zaloguj się do usługi OneDrive dla Firm lub SharePoint i przejdź do folderu, w którym
znajduje się żądany skoroszyt.
2. Kliknij skoroszyt prawym przyciskiem myszy i wybierz polecenia Otwórz i Otwórz w aplikacji.
3. W karcie Plik kliknij polecenie Informacje, a następnie przycisk Kopiuj ścieżkę, tak jak na
rysunku 8.7.
Uwaga. Adres URL skoroszytu w celu otwarcia go w przeglądarce można uzyskać na kilka sposobów,
z których większość nie pozwala na otwarcie go w Power Query. Technika z użyciem przycisku
Kopiuj ścieżkę pozwala uzyskać właściwy adres i zaimportować skoroszyt do Power Query.
197
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 8.7. Aby otworzyć skoroszyt w Power Query, musisz skopiować jego adres URL do schowka
Poniżej przedstawiony jest przykładowy adres URL skoroszytu zapisanego w usłudze OneDrive
dla Firm:
https://firma-my.sharepoint.com/personal/admin_firma_com_pl/Documents/Dane/
R08/R08-01.xlsx
Fragmenty wyróżnione pogrubioną czcionką zawierają następujące informacje: nazwę firmy
(Firma), adres e-mail użytkownika (admin@firma.com.pl) i nazwę folderu, w którym znajduje się
plik (Dane/R08).
Poniżej przedstawiony jest przykładowy adres pliku zapisanego w usłudze SharePoint:
https://firma.sharepoint.com/sites/Dane/Shared%20Documents/R08/R08-01.xlsx
W tym adresie fragmenty wyróżnione pogrubioną czcionką zawierają następujące informacje:
nazwę firmy (Firma), nazwę witryny, w której znajduje się plik (Dane) oraz nazwę folderu (R08).
4. Aby zaimportować skoroszyt do Power Query, wykonaj poniższe kroki.
W Excelu: utwórz nowy skoroszyt, a następnie w karcie Dane kliknij ikonę Z sieci Web
(zwróć uwagę, że jest to inne polecenie niż Web Query dostępne w starszych wersjach Excela).
W Power BI Desktop: utwórz nowy skoroszyt, a następnie w karcie Strona główna rozwiń
ikonę Pobierz dane i wybierz polecenie Internet.
5. W oknie Z sieci Web, które się pojawi, wklej w polu Adres URL zawartość schowka
(którą umieściłeś w kroku 3.). Usuń sufiks ?web=1, ponieważ nie zamierzasz otwierać
skoroszytu w aplikacji Excel Online. Kliknij OK, aby zamknąć okno.
6. Jeżeli pierwszy raz importujesz skoroszyt z usługi OneDrive dla Firm lub SharePoint, pojawi
się okno Dostęp do zawartości sieci Web. Zaznacz w panelu po lewej stronie pozycję
Konto organizacyjne i kliknij przycisk Zaloguj się. Po pomyślnym zalogowaniu kliknij
przycisk Połącz.
7. Pojawi się dobrze znane okno Nawigator. Zaznacz arkusz, który chcesz zaimportować,
i kliknij przycisk Przekształć dane.
198
4650570396d9eb2765da56c12eb840b5
4
Wskazówka. Aby zaimportować do Power Query plik tekstowy z usługi OneDrive dla Firm
lub SharePoint, utwórz w tym samym folderze tymczasowy skoroszyt Excela i wykonaj kroki
od 1. do 3., aby uzyskać jego adres URL. Następnie wykonaj kroki od 4. do 6., aby zaimportować
plik tekstowy.
Ćwiczenie 8.4. Tworzenie zapytań łączących się z usługami

OneDrive dla Firm i SharePoint
W tym ćwiczeniu zmienisz utworzone przez Alicję zapytania tak, aby nie odwoływały się do plików
zapisanych w lokalnym systemie tylko do usługi OneDrive dla Firm lub SharePoint. (Będziesz w tym
celu potrzebował firmowego konta w jednej z tych usług).
1. Zapisz plik R08-01.xlsx w usłudze OneDrive dla Firm lub SharePoint.
2. Otwórz w Excelu skoroszyt R08-01 - Alicja.xlsx, a w programie Power BI Desktop raport
R08-01 - Alicja.pbix.
3. Wykonaj kroki opisane w poprzednim ćwiczeniu, aby uzyskać adres URL skoroszytu
w usłudze OneDrive dla Firm lub SharePoint, który zapisałeś w kroku 1.
4. Wykonaj kroki opisane w poprzednim ćwiczeniu, aby zaimportować do Excela skoroszyt
R08-01.xlsx za pomocą polecenia Z sieci Web. W oknie Nawigator zaznacz tabelę Kolory
i kliknij przycisk Przekształć dane.
5. Zmień nazwę nowego zapytania na Skoroszyt, a następnie w panelu Zastosowane kroki
usuń dwa ostatnie kroki. Pozostaw jedynie krok Źródło.
6. W sposób opisany w ćwiczeniu 8.3 zmień zapytania tak, aby odwoływały się do zapytania
Skoroszyt, a nie lokalnego pliku. W tym celu zmodyfikuj zapytania Przychody, Kolory
i Kategorie w następujący sposób.
a. W panelu Zastosowane kroki kliknij krok Źródło.
b. W pasku formuły pojawi się następujący kod:

Zmień go na poniższy:
= Skoroszyt
7. Aby zapytanie Skoroszyt nie było ładowane do tabeli, wykonaj poniższe kroki.
W Excelu: w karcie Strona główna rozwiń ikonę Zamknij i załaduj i wybierz polecenie
Zamknij i załaduj do. W oknie Importowanie danych zaznacz opcję Utwórz tylko połączenie.
W Power BI Desktop: w panelu Zapytania kliknij prawym przyciskiem myszy zapytanie
Skoroszyt, a następnie w podręcznym menu usuń zaznaczenie opcji Włącz ładowanie.
8. Aby sprawdzić, czy wszystkie kroki wykonałeś poprawnie, kliknij w karcie Widok ikonę
Zależności zapytań. Upewnij się, że diagram, który się pojawi, będzie taki sam jak na
rysunku 8.8.
Gotowe rozwiązanie jest zapisane w plikach R08-04 - rozwiązanie.xlsx oraz R08-04 - rozwiązanie.pbit.
199
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 8.8. Okno „Zależności zapytań” pokazuje, jak zapytania importują dane ze skoroszytu zapisanego
w usłudze OneDrive dla Firm
Różnica pomiędzy usługami OneDrive dla Firm a SharePoint

W przypadku usługi OneDrive dla Firm można łatwo przełączać się pomiędzy plikami lokalnymi
a współdzielonymi, jednak w pracy zespołowej zaleca się korzystanie z usługi SharePoint. Foldery
w usłudze OneDrive dla Firm są osobiste, a więc jeżeli użytkownik odejdzie z firmy, zostanie
utracony dostęp do jego plików.
Aby można było korzystać z kilku skoroszytów Excela lub plików tekstowych, trzeba je zapisać
w witrynie SharePoint i odwoływać się do nich za pomocą konektora do folderu SharePoint.
W ćwiczeniu 8.5 dowiesz się, jak podłączyć się do folderu w usłudze SharePoint i zmienić zapytania
tak, aby odwoływały się do tej usługi.
Ćwiczenie 8.5. Od lokalnych folderów do usługi SharePoint

W tym ćwiczeniu wykorzystasz gotowy skoroszyt Excela lub raport Power BI odwołujący się do
lokalnych źródeł danych. Załadujesz pliki źródłowe do witryny SharePoint i zmienisz zapytania tak,
aby importowały dane z nowych źródeł. Jak pokazuje rysunek 8.9, przeniesienie plików do usługi
SharePoint jest łatwe. Jednak jak się przekonasz, modyfikacja zapytań już nie jest taka prosta.
W ćwiczeniu wykorzystasz następujące pliki:
 R08-05.xlsx,
 R08-05.pbix,
 Folder R08-05 - folder.
200
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 8.9. Przenosząc pliki z lokalnego folderu do usługi SharePoint, można usprawnić pracę zespołu
nad raportami
1. Przejrzyj zawartość folderu R08-05 - folder. Skoroszyty zawierają katalogi produktów firmy
Fabryka Przygód wprowadzonych do sprzedaży w różnych latach.
2. Skopiuj folder R08-05 - folder do podfolderu Dokumenty w witrynie SharePoint.
3. Otwórz w Excelu skoroszyt R08-05.xlsx lub w Power BI Desktop raport R08-05.pbix
i uruchom edytor Power Query.
W Excelu: otwórz skoroszyt C:\Dane\R08\R08-05.xlsx, a następnie w karcie Dane kliknij
ikonę Pobierz dane i wybierz polecenie Uruchom edytora dodatku Power Query.
W Power BI Desktop: otwórz raport C:\Dane\R08\R08-05.pbix, a następnie w karcie
Strona główna kliknij ikonę Edytuj zapytania.
4. W panelu Zapytania zaznacz zapytanie R08-05 - folder. W panelu podglądu pojawi się lista
produktów firmy Fabryka Przygód. Zapytania widoczne w panelu Zapytania powinny
wyglądać znajomo. Są podobne do tych, które utworzyłeś w rozdziale 3., „Łączenie danych
z kilku źródeł”, w ćwiczeniu 3.3 polegającym na łączeniu skoroszytów zapisanych w folderze.
5. Połącz się z witryną SharePoint i zobacz różnice pomiędzy lokalnymi a współdzielonymi
folderami. W tym celu w edytorze Power Query rozwiń w karcie Strona główna ikonę
Nowe źródło, a następnie wykonaj poniższe kroki.
W Excelu: wybierz polecenia Plik i Folder programu SharePoint.
W Power BI Desktop: w oknie Pobierz dane zaznacz pozycję Folder programu SharePoint
i kliknij przycisk Połącz.
6. W oknie Folder programu SharePoint, które się pojawi, wpisz w polu Adres URL witryny
główny adres swojej witryny, bez podfolderów. Jeżeli np. poddomena nazywa się firma,
a witryna Dane, wtedy adres URL jest następujący:
https://firma.sharepoint.com/sites/Dane
Wskazówka. Podczas korzystania z usługi SharePoint kluczowe znaczenie ma fakt, że nie można
odwoływać się bezpośrednio do określonego podfolderu, tylko do głównego folderu. Aby
zaimportować pliki z wybranego podfolderu, należy użyć filtrów względnych ścieżek i nazw plików.
201
4650570396d9eb2765da56c12eb840b5
4
7. Jeżeli pierwszy raz łączysz się z witryną SharePoint, pojawi się okno Dostęp do zawartości
sieci Web. Zaznacz w panelu po lewej stronie pozycję Konto organizacyjne i kliknij przycisk
Zaloguj się. Po pomyślnym zalogowaniu kliknij przycisk Połącz.
8. Gdy pojawi się podgląd zawartości folderu, kliknij przycisk Przekształć dane.
9. Ponieważ połączysz się z głównym folderem, w panelu podglądu pojawi się wiele wierszy
zawierających pliki, które Cię nie interesują. Aby wyświetlić wyłącznie pliki znajdujące się
w podfolderze R08-01 - folder, kliknij ikonę filtru w nagłówku kolumny Folder Path.
10. W panelu filtru, który się pojawi, kliknij polecenia Filtry tekstu/Zawiera.
11. W oknie Filtrowanie wierszy, które się pojawi, w polu po prawej stronie rozwijanej listy
zawiera wpisz /R08-05 – folder/ i kliknij OK. W panelu podglądu pojawią się tylko
trzy pliki.
12. Zmień nazwę zapytania na Folder SharePoint i zastosuj je w istniejących zapytaniach.
W tym celu w panelu Zapytania kliknij zapytanie Przykładowy plik.
13. W panelu Zastosowane kroki zaznacz kolumna Źródło. W pasku formuły pojawi się kod
zwracający zawartość bieżącego folderu:
= Folder.Files("c:\Dane\R08\R08-05 - folder")
Zamień powyższy kod na następujący:
= #"Folder SharePoint"
14. W panelu Zapytania zaznacz zapytanie i powtórz krok 13., ponieważ nie powinno
odwoływać się do lokalnego folderu, tylko do witryny SharePoint.
15. Aby zapytanie Folder SharePoint nie było ładowane do tabeli, wykonaj poniższe kroki.
a. W Excelu: w karcie Strona główna rozwiń ikonę Zamknij i załaduj i wybierz polecenie
Zamknij i załaduj do. W oknie Importowanie danych zaznacz opcję Utwórz tylko połączenie.
b. W Power BI Desktop: w panelu Zapytania kliknij prawym przyciskiem myszy zapytanie
Folder SharePoint, a następnie w podręcznym menu usuń zaznaczenie opcji Włącz ładowanie.
Teraz zapytania będą importowały skoroszyty z witryny SharePoint, a nie z lokalnego folderu.
Alicja i Bartek będą zadowoleni.
Gotowe rozwiązanie jest zapisane w plikach R08-05 - rozwiązanie.xlsx oraz R08-05 - rozwiązanie.pbit.
Zagadnienia bezpieczeństwa
Narzędzie Power Query zostało zaprojektowane z myślą o bezpieczeństwie. Podczas tworzenia raportu
łączącego się z firmową bazą danych lub innym repozytorium wymagającym uwierzytelnienia
poświadczenia użytkownika są zapisywane w lokalnym systemie, aby nie trzeba było ich
wprowadzać przy każdorazowym odświeżaniu raportu.
Po udostępnieniu raportu innym użytkownikom poświadczenia pozostają zapisane w lokalnym
systemie. Aby inny użytkownik mógł połączyć się ze źródłem danych, musi wprowadzić swoje
poświadczenia. Dzięki temu nikt postronny nie uzyska dostępu do Twoich poświadczeń.
Czasami będziesz chciał usunąć dane z zapytań, modeli i wizualizacji przed udostępnieniem
raportu. Ten cel możesz osiągnąć za pomocą szablonów Excela lub programu Power BI Desktop.
W ćwiczeniu 8.2 utworzyłeś szablon Power BI, w którym użytkownik przed załadowaniem danych
202
4650570396d9eb2765da56c12eb840b5
4
musiał wprowadzać wartość parametru. W Power BI możesz tworzyć szablony bez parametrów.
Dane nie będą udostępniane innemu użytkownikowi, ponieważ nie będzie ich w szablonie. Jest to
szczególnie praktyczne rozwiązanie w przypadku, gdy każdy współautor raportu ma dostęp tylko do
części wierszy tej samej tabeli w źródle danych.
Excel działa w podobny sposób. Aby utworzyć szablon i usunąć dane z modelu i tabel, kliknij
kartę Plik i wybierz polecenie Zapisz jako. Zanim zapiszesz szablon, sprawdź, czy zmieniłeś typ pliku
na Szablon programu Excel (.xltx). Przed zapisaniem pliku pojawi się następujący komunikat:
Skoroszyt zawiera dane zewnętrzne. Czy chcesz, aby program Microsoft Excel wyczyścił te dane
przed zapisaniem szablonu, a następnie automatycznie odświeżał dane w chwili otwarcia szablonu?
Kliknij przycisk Tak, aby usunąć dane. Gdy inny użytkownik otworzy raport, Power Query
podejmie próbę odświeżenia go. Jeżeli będą potrzebne poświadczenia, poprosi o ich wprowadzenie.
Twoich danych jednak w raporcie nie będzie.
Usuwanie zapytań w drodze inspekcji skoroszytu Excela

Czasami będziesz chciał udostępnić przetworzone dane lub statyczne wykresy bez modelu danych.
Możesz wprawdzie ręcznie usuwać wszystkie zapytania bez naruszania tabel, ale jest szybszy sposób
— inspekcja skoroszytu. W tym celu wykonaj następujące kroki.
1. W karcie Plik kliknij sekcję Informacje, następnie przycisk Wyszukaj problemy i polecenie
Przeprowadź inspekcję dokumentu.
2. W oknie Inspektor dokumentów, które się pojawi, kliknij przycisk Inspekcja.
3. Przewiń zawartość okna w dół, aż pojawi się sekcja Niestandardowe dane XML, taka jak
na rysunku 8.10.
RYSUNEK 8.10. Aby usunąć ze skoroszytu wszystkie zapytania,

przeprowadź jego inspekcję i usuń niestandardowe dane XML
203
4650570396d9eb2765da56c12eb840b5
4
Uwaga. Narzędzie Power Query zapisuje zapytania w specjalnym miejscu skoroszytu jako
niestandardowe dane XML. Ta część pliku jest również wykorzystywana przez zewnętrzne
dodatki. Dlatego dla bezpieczeństwa powinieneś zawsze przeprowadzać inspekcję kopii
skoroszytu i usuwać z niego zapytania wraz z dodatkowymi danymi.
4. Kliknij przycisk Usuń wszystko, a następnie Zamknij.

5. W karcie Dane kliknij ikonę Zapytania i połączenia. Wszystkie zapytania powinny zostać
usunięte. Jeżeli załadowałeś zapytania do modelu danych, on również zostanie usunięty.
Podsumowanie
W tym rozdziale poznałeś nowe problemy, z jakimi przyjdzie Ci się mierzyć podczas zespołowego
tworzenia raportów i udostępniania ich innym użytkownikom w grupie.
W ćwiczeniach 8.1 i 8.2 dowiedziałeś się, jak udoskonalać zapytania za pomocą parametrów
i szablonów, aby inni współautorzy mogli ładować dane do raportów ze swoich lokalnych źródeł.
W ćwiczeniu 8.3 nauczyłeś się definiować tabelę parametrów i ładować ją jako zapytanie Parametry.
Zastosowałeś przekształcenie Wyszczególnij, aby załadować wartość parametru, oraz scalenie
wybranych zapytań, aby zapobiec pojawianiu się komunikatu Formula.Firewall.
W ćwiczeniach 8.4 i 8.5 dowiedziałeś się, jak importować dane z usług OneDrive dla Firm
i SharePoint. Zmodyfikowałeś utworzone wcześniej zapytania tak, aby ładowały dane
ze współdzielonych skoroszytów i folderów, a nie z lokalnych plików.
Na koniec zapoznałeś się z kilkoma zagadnieniami bezpieczeństwa i technikami usuwania danych
z raportów. Dowiedziałeś się, jak w drodze inspekcji skoroszytu usuwać z niego wszystkie zapytania.
Teraz, kiedy nabrałeś biegłości w posługiwaniu się narzędziem Power Query, nadszedł czas, abyś
wszedł do królestwa języka M i wzbogacił swoje umiejętności przetwarzania danych.
204
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 9.
Wprowadzenie do języka M
Ty je [dzieci] robisz, ja się z nimi bawię.

— Dr Seuss
W TYM ROZDZIALE POZNASZ:

 etapy opanowania języka M,
 materiały online i offline do nauki języka M,
 główne bloki konstrukcyjne języka M, m.in. wyrażenia let,
 najważniejsze operatory, wbudowane funkcje i typy, m.in. number, time, date, duration,
text, null i logical,
 warunki i wyrażenie if,
 sposoby definiowania i wywoływania własnych funkcji,
 techniki obsługi błędów,
 rekurencję, pętle wykonujące skomplikowane przekształcenia i funkcje operujące
na listach.
M jest językiem do tworzenia formuł w narzędziu Power Query. Gdy definiujesz za pomocą edytora
kroki przekształcające dane, generowany jest kod w języku M. Każdy krok jest zamieniany na jeden
lub kilka wierszy kodu, który pojawia się w pasku formuły i można go edytować. Wszystkie kroki
razem wzięte tworzą wyrażenie M, czyli blok kodu definiujący przekształcenia wykonywane przez
zapytanie. Kod ten można modyfikować za pomocą zaawansowanego edytora.
W zaawansowanym edytorze można wpisywać od podstaw pełny kod definiujący zapytanie,
ale większość przekształceń definiuje się za pomocą interfejsu programu. Nie trzeba wtedy używać
języka M ani edytować wyrażeń. Niemniej jednak głębsza znajomość języka M daje możliwość
rozwiązywania bardziej skomplikowanych problemów i tworzenia zapytań przetwarzających
najbardziej nieuporządkowane dane.
Jeśli nie chcesz uczyć się nowego języka programowania, ten rozdział i tak może być przydatny.
Język M, w odróżnieniu od typowych języków programowania, pozwala osiągnąć bardzo wiele przy
jego niewielkiej znajomości.
4650570396d9eb2765da56c12eb840b5
4
Nauka języka M
Po wykonaniu ćwiczeń z poprzednich rozdziałów powinieneś bez problemów przeczytać i zrozumieć
ten rozdział, w którym język M jest opisany wprost. W kolejnych podrozdziałach została przedstawiona
składnia, natomiast tematem tego podrozdziału są korzyści płynące ze znajomości języka M.
Do tej pory miałeś do czynienia z językiem M sporadycznie, gdy korzystałeś z jednego z trzech
elementów interfejsu programu. Oto one.
 Pasek formuły. Wiesz już, jak dostosowywać przekształcenia do własnych potrzeb
poprzez modyfikowanie kodu M w pasku formuły. Do tej pory robiłeś to w sytuacjach,
gdy interfejs programu nie oferował wymaganych funkcjonalności (np. filtrowania
kolumn wg zaawansowanych kryteriów).
 Kolumna niestandardowa. Kodowałeś pewne przekształcenia na poziomie wierszy,
a wyniki zapisywałeś w nowej kolumnie.
 Zaawansowany edytor. Za pomocą tego edytora można modyfikować wiele wierszy
zapytania jednocześnie, wykorzystywać kody innych zapytań i tworzyć niestandardowe
funkcje do specjalnych zastosowań.
Jeżeli nawet nie rozumiesz w pełni składni i znaczenia kodu, do pewnego stopnia możesz je
poznać, analizując kod automatycznie generowany przez interfejs użytkownika. Jest to ważna rzecz,
o której powinieneś pamiętać. Najlepszym sposobem nauczenia się języka M jest definiowanie
kroków przekształceniowych za pomocą interfejsu programu, a następnie stopniowe, coraz głębsze
analizowanie generowanego kodu.
Etapy opanowania języka M

Jeżeli dopiero zaczynasz przygodę z językiem M, przejdziesz sześć etapów jego opanowania,
przedstawionych na rysunku 9.1. W każdym kolejnym etapie będziesz mógł wykonywać coraz
trudniejsze zadania związane z przetwarzaniem danych, ale możesz też zatrzymać się w określonej
strefie komfortu. Czy jesteś gotów na wysiłek niezbędny do przejścia do następnego etapu?
Etap 1. Tylko interfejs programu

Jeżeli pierwszy raz masz do czynienia z językiem M i wykonałeś opisane do tej pory ćwiczenia,
osiągnąłeś pierwszy etap opanowania języka i możesz uważać się za adepta Power Query. Wiesz już,
że M to język, na którym opiera się Power Query, ale możesz mieć wątpliwości, czy warto się go
uczyć, ponieważ korzyści z tego płynące są niejasne. Możesz się też obawiać, czy warto nadawać
temu językowi większy priorytet niż innym językom, których jest całkiem sporo i być może już ich
używałeś; mogą to być np. formuły Excela, VBA, DAX, Python i R. Po co w takim razie miałbyś się
uczyć języka M, który tak bardzo różni się od wszystkiego, z czym miałeś do tej pory do czynienia?
Motywacja, aby przejść do kolejnego etapu, pojawi się w chwili, gdy uświadomisz sobie, że
za pomocą interfejsu programu jesteś w stanie rozwiązać ok. 40% problemów. Jeżeli zechcesz
rozwiązywać ich więcej przy użyciu narzędzia Power Query, odkryjesz, że zazwyczaj wystarczy
w tym celu nieznacznie zmodyfikować wygenerowany kod. Ponieważ tego rodzaju modyfikacje
nie wymagają głębokiej znajomości składni wyrażeń, jest to etap, do którego przejdziesz w sposób
naturalny nawet wtedy, kiedy nie jesteś zaawansowanym użytkownikiem formuł Excela, ani nie nic
wiesz o programowaniu.
206
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 9.  WPROWADZENIE DO JĘZYKA M
RYSUNEK 9.1. Na każdym kolejnym etapie opanowywania języka M będziesz rozwiązywał coraz więcej
problemów, jednak z większością poradzisz sobie już na drugim etapie
Etap 2. Nieznaczne modyfikacje kodu w pasku formuły

Drugi etap opanowania języka M obejmuje nieznaczne modyfikowanie kodu w pasku formuły.
Możesz nie rozumieć w pełni pojawiających się w nim formuł, ale na pewno będziesz kojarzył
niektóre ich elementy z wykonywanymi operacjami i potrafił je rozbudowywać odpowiednio
do swoich potrzeb. Na tym poziomie będziesz w stanie rozwiązywać 60% problemów i znacznie
poszerzysz swoje umiejętności przetwarzania danych.
Konieczność przejścia do tego etapu pojawi się wtedy, gdy będziesz musiał coraz częściej
wykonywać skomplikowanie operacje w raportach i kiedy opanujesz inne obszary, np. miary DAX
w Power BI lub tabele przestawne w Excelu. Odkryjesz wtedy siłę kolumn wyliczeniowych w DAX
i dojdziesz do wniosku, że ułatwiłoby Ci pracę zaimplementowanie podobnego rozwiązania
za pomocą kolumn niestandardowych w języku M.
Etap 3. Kolumny niestandardowe z kodem M

W trzecim etapie udoskonalisz swoje umiejętności posługiwania się niestandardowymi kolumnami
i zaczniesz w oknie Kolumna niestandardowa w polu Formuła kolumny niestandardowej pisać proste,
ale bardzo skuteczne formuły. Nauczysz się stosować wyrażenia logiczne, instrukcje if/then/else
oraz operatory logiczne and, or i not. Częściej będziesz stosował kolumny niestandardowe niż
warunkowe i rozwiązywał za ich pomocą 80% problemów.
Wielu użytkowników zatrzymuje się na tym etapie, ale też wielu innych przekonuje się o sile
języka M i chce rozwiązywać jeszcze więcej problemów. W tym momencie przekraczają granice
paska formuły, zaczynają tworzyć wyrażenia za pomocą zaawansowanego edytora i rozszerzać
zapytania, wykorzystując dotychczasową znajomość języka M.
207
4650570396d9eb2765da56c12eb840b5
4
Etap 4. Niestandardowe funkcje i zaawansowany edytor

W czwartym etapie nauczysz się tworzyć własne funkcje i wykorzystywać je w krokach
przekształceniowych. Znasz już wprawdzie polecenie Utwórz funkcję, ale docenisz możliwość
przekształcania zapytań w niestandardowe funkcje za pomocą zaawansowanego edytora.
W edytorze tym będziesz intensywnie modyfikował tworzony w ten sposób kod.
Na tym etapie będziesz w stanie rozwiązywać 99% problemów przetwarzania danych. Twoja
renoma jako analityka wykroczy poza granice zespołu i prawdopodobnie wielu innych kolegów
będzie Cię prosić o pomoc w rozwiązywaniu ich problemów.
Impuls do przejścia na następny etap nie jest związany z potrzebami biznesowymi, ponieważ
na tym etapie będziesz potrafił rozwiązywać niemal wszystkie problemy. Głównym motywatorem
będzie Twoja ciekawość i chęć profesjonalnego opanowania języka M. Zaczniesz tworzyć biblioteki
przydatnych, niestandardowych funkcji, szukać nowych sposobów skutecznego rozwiązywania
problemów i pisać uniwersalne zapytania dla najtrudniejszych przypadków.
Etap 5. Zaawansowane iteracje (funkcje List.Accumulate i List.Generate)

W piątym etapie będziesz się mierzył z najbardziej skomplikowanymi problemami i tworzył
rozwiązujący je zaawansowany kod. Będziesz do tego celu używał interfejsu Power Query, ale
znaczną część kodu samodzielnie napiszesz za pomocą zaawansowanego edytora. Z łatwością
zaczniesz stosować zagnieżdżone bloki let/in i uogólniać automatycznie generowany kod,
a wtedy osiągniesz jeszcze więcej.
Na tym etapie odkryjesz siłę funkcji List.Accumulate i List.Generate umożliwiających
kodowanie serii przekształceń. Będziesz tworzył niewielkie fragmenty kodu i umieszczał je
w argumentach tych funkcji. Choć przypadki, w których jest to naprawdę potrzebne, są rzadkie,
niemniej jednak sam fakt, że będziesz potrafił tworzyć zaawansowane formuły wykorzystujące
powyższe funkcje, będzie potwierdzeniem Twojej sprawności w posługiwaniu się językiem M.
Gdy będziesz wiedział, jak ich używać, osiągniesz etap piąty, a Twoje umiejętności żonglowania
danymi będą w firmie legendą.
Na tym etapie będziesz potrafił rozwiązywać 99% problemów. Pozostały 1% będzie wymagał
użycia innych języków programowania. Dlatego przejście do następnego etapu będzie zależało od
Twojego doświadczenia w programowaniu i gotowości do jeszcze większego wysiłku intelektualnego.
Jeżeli jednak nie jesteś programistą z wykształcenia, korzyści z tego ruchu będą niewielkie.
Etap 6. Swobodne kodowanie w zaawansowanym edytorze

Na ostatnim, najwyższym poziomie, będziesz od podstaw pisał wyrażenia w języku M, bez używania
interfejsu programu Power Query. Swobodne kodowanie będzie dla Ciebie rzeczą naturalną, aczkolwiek
wymagającą dobrej pamięci, ponieważ edytor nie jest wyposażony w funkcjonalności automatycznego
uzupełniania kodu ani IntelliSense (przynajmniej nie były one dostępne w czasie pisania tej książki).
Na tym etapie będziesz musiał zapamiętywać nazwy wielu funkcji i ich argumentów.
Szerokie doświadczenie w programowaniu bardzo Ci pomoże w osiągnięciu tego etapu. Gdy już
to zrobisz, zaczniesz szukać nowych sposobów wykorzystania swojej wiedzy, np. do tworzenia kodu
M dla szerszej grupy odbiorców, dzielenia się funkcjami ze znajomymi programistami czy nawet
społecznością użytkowników, a w kolejnym etapie tworzenia niestandardowych konektorów
w Visual Studio.
208
4650570396d9eb2765da56c12eb840b5
4
Zobacz też. Gdy osiągniesz etap szósty, będziesz programistą M przygotowanym do tworzenia
własnych konektorów dla Power BI, umożliwiających łączenie się z usługami i korzystanie
ze znajdujących się w nich danych i aplikacji, które nie są standardowo dostępne. Tworzenie
własnych konektorów nie jest opisane w tej książce. Aby się dowiedzieć, jak to robić, odwiedź
stronę https://github.com/Microsoft/DataConnectors.
Informacje online
Żeby przejść do następnego etapu opanowania języka M, zacznij od zapoznania się z oficjalnym,
wyczerpującym repozytorium Power Query dostępnym na stronie Microsoft MSDN Library
https://msdn.microsoft.com/query-bi/m/power-query-m-reference.
Na powyższej stronie często brakuje konkretnych przykładów ułatwiających głębsze poznanie
zastosowania różnych funkcji. Dlatego zachęcam do przeszukiwania blogów, na których możesz
znaleźć artykuł na interesujący Cię temat. Poniżej wymieniam kilka najpopularniejszych blogów:
 Chria Webb, analityka biznesowa: https://blog.crossjoin.co.uk/category/power-query,
 Ken Puls (Excelguru): https://www.excelguru.ca/blog,
 Matt Allington (Excelerator BI): https://exceleratorbi.com.au/category/power-query-2,
 Reza Rad’s (RADACAD): http://radacad.com/category/power-query,
 Imke Feldmann (BICCOUNTANT): http://www.thebiccountant.com,
 DataChant: https://datachant.com.
Informacje offline
Wyobraź sobie, że lecisz samolotem gdzieś daleko, nie masz połączenia z internetem, za to bardzo
potrzebujesz dokładnie dowiedzieć się, jak działa dana funkcja M. Edytor Power Query jest
wyposażony w skorowidz wszystkich dostępnych funkcji, zawierający czasami więcej informacji
i przykładów niż oficjalna strona MSDN. Dlatego zachęcam do korzystania z niego.
Aby otworzyć dokumentację wybranej funkcji, wpisz po prostu w pasku formuły znak równości,
a po nim nazwę funkcji bez nawiasów i argumentów. Gdy naciśniesz Enter, w panelu podglądu
pojawi się dostępna offline dokumentacja. Jeżeli np. używasz funkcji Table.ColumnNames(Źródło)
zwracającej listę nazw kolumn tabeli Źródło, usuń nawiasy i nazwę tabeli, tak jak niżej. Uzyskasz
dokumentację pokazaną na rysunku 9.2.
= Table.ColumnNames
Ćwiczenie 9.1. Zmienna #shared i dokumentacja wbudowanych funkcji

Aby dowiedzieć się o nowych funkcjach i przeczytać ich dokumentację offline, otwórz edytor
Power Query i w pasku formuły wpisz następujący wiersz:
= #shared
Powyższa zmienna zawiera wykaz wszystkich funkcji w Power Query, włącznie z Twoimi
zapytaniami. Sprawdźmy, jak możesz ją wykorzystać do zapoznania się z dostępnymi funkcjami
i uzyskać więcej informacji o wybranej funkcji.
209
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 9.2. Aby otworzyć dokumentację offline funkcji, wpisz w pasku formuły jej nazwę
1. Utwórz puste zapytanie w następujący sposób.

W Excelu: w karcie Dane kliknij ikonę Pobierz dane i wybierz polecenia Z innych
źródeł/Puste zapytanie.
W Power BI Desktop: w karcie Strona główna rozwiń ikonę Pobierz dane i wybierz polecenie
Puste zapytanie.
2. Jeżeli w edytorze nie będzie widoczny pasek formuły, zaznacz w kolumnie Widok opcję
Pasek formuły.
3. W pasku formuły wpisz następujący wiersz:
= #shared
W panelu podglądu pojawi się tabela. Nie będzie to jednak typowa tabela, tylko tzw. rekord,
w którym pierwsza kolumna zawiera nazwy kluczy (zwanych również polami), a druga ich
wartości.
4. Kliknij puste miejsce obok odnośnika Function. W dolnej części panelu pojawi się
dokumentacja offline wybranej funkcji. Gdy klikniesz odnośnik, pojawi się szczegółowy opis.
5. Aby za pomocą interfejsu Power Query wyświetlić listę wszystkich funkcji operujących
na listach, zamień najpierw wyświetlony rekord na tabelę, klikając w kolumnie Konwertuj
ikonę Do tabeli.
6. Następnie kliknij ikonę filtru w nagłówku kolumny Name i wybierz polecenia Filtry tekstu
i Zaczyna się od.
210
4650570396d9eb2765da56c12eb840b5
4
7. W oknie Filtrowanie wierszy, które się pojawi, w polu po prawej stronie rozwijanej listy
zaczyna się od wpisz List i kliknij OK. Pojawi się wykaz wszystkich funkcji operujących
na listach. Dokumentację do nich możesz otworzyć w sposób opisany w kroku 4.
Gotowe rozwiązanie jest zapisane w plikach R09-01- rozwiązanie.xlsx oraz R09-01 - rozwiązanie.pbix.
Bloki konstrukcyjne w języku M

Głównym blokiem konstrukcyjnym w języku M jest wyrażenie, czyli wykonywany przez silnik blok
kodu zwracający określoną wartość. Każdy krok przekształceniowy tworzony w interfejsie programu
Power Query jest zamieniany na wyrażenie M, którego wynik jest widoczny w panelu podglądu.
Krok przekształceniowy składa się z identyfikatora i związanego z nim wyrażenia. W pasku
formuły widoczne jest samo wyrażenie, a w panelu Zastosowane kroki sam identyfikator. Gdy
otworzysz zaawansowany edytor, pojawi się w nim całe wyrażenie. Widoczny tam kod jest znacznie
bardziej skomplikowany niż ten z paska formuły, jednak jest to wyrażenie zwracające pojedynczą
wartość. Poniższe ćwiczenie ilustruje ideę wyrażenia zwracającego napis „Witaj, świecie!”.
Ćwiczenie 9.2. Witaj, świecie!

W tym ćwiczeniu poznasz powiązania pomiędzy elementami interfejsu programu Power Query
a wyrażeniami M i ich wynikami.
1. Otwórz edytor Power Query i utwórz puste zapytanie. (Nie wiesz jak? Wróć do ćwiczenia 9.1
i kroku 1.).
2. W zakresie Strona główna kliknij ikonę Edytor zaawansowany i wpisz w nim poniższy kod:
let
Źródło = "Witaj, ",
Krok2 = Źródło & " ",
Krok3 = Krok2 & "świecie!"
in
Krok3
3. Kliknij przycisk Gotowe, aby zamknąć zaawansowany edytor.
W panelu podglądu pojawi się napis „Witaj, świecie!”. Gratulacje! Napisałeś swój pierwszy
program w języku M. Przeanalizujemy teraz program pod kątem terminologii stosowanej w języku
M i sprawdzimy, jak jest on powiązany z elementami interfejsu programu. Rysunek 9.3 przedstawia
główne elementy interfejsu, tj. zaawansowany edytor, pasek formuły i panel Zastosowane kroki,
powiązane z odpowiednimi blokami konstrukcyjnymi języka M.
W panelu podglądu widoczny jest napis „Witaj, świecie!”. Zazwyczaj w tym miejscu znajduje się
tabela, ale tutaj jest to tekst, ponieważ taką wartość zwraca wyrażenie, które wpisałeś w zaawansowanym
edytorze. W pasku formuły widoczny jest następujący wiersz:
= Krok2 & "świecie!"
Powyższy kod jest wyrażeniem, które przypisałeś do identyfikatora Krok3. Wyrażenie to dołącza
ciąg "świecie!" do wartości zmiennej Krok2. W pasku formuły widoczne jest wyrażenie, a w panelu
Zastosowane kroki identyfikator Krok3.
211
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 9.3. Z blokami konstrukcyjnymi języka M powiązanych jest kilka elementów interfejsu programu
Power Query: zaawansowany edytor, pasek formuły i panel Zastosowane kroki
Gdy w panelu Zastosowane kroki klikniesz Krok2, w pasku formuły pojawi się następujący kod:
= Źródło & " "
Wyrażenie to jest w zaawansowanym edytorze powiązane z identyfikatorem Krok2 w następujący

sposób:
Przecinek znajdujący się na końcu wiersza nie jest widoczny w pasku formuły, jednak jest
potrzebny, ponieważ oddziela pary identyfikator-wyrażenie składające się na wyrażenie let.
Większość zapytań jest zamieniana na jednowierszowe kroki, takie jak Źródło, Krok2
i Krok3 (pokazane na rysunku 9.2). Jednak w języku M można tworzyć złożone wyrażenia
i definiować warunki zmieniające przebieg wykonywania kodu. Więcej na ten temat dowiesz się
w tym rozdziale, w punkcie „Wyrażenie if wewnątrz wyrażenia let”. Zanim jednak zagłębimy się
w bardziej zaawansowane tematy, przyjrzyjmy się bliżej wyrażeniu let, ponieważ w większości
przypadków będzie to pierwsza instrukcja umieszczana w zaawansowanym edytorze po jego
pierwszym otwarciu.
212
4650570396d9eb2765da56c12eb840b5
4
Wyrażenie let
Za każdym razem, gdy tworzysz nowe zapytanie w edytorze Power Query, importujesz
i przekształcasz dane, tworzone jest wyrażenie let. Gdy otworzysz zaawansowany edytor,
zobaczysz wyrażenie M zaczynające się od słowa let i zazwyczaj kończące się słowem in
oraz identyfikatorem ostatniego kroku.
Wyrażenie let służy do tworzenia mniejszych wyrażeń, które są później łączone w pojedynczą
wartość. Przeanalizujmy prosty przykład z ćwiczenia 9.2. Wyrażenie let składa się tam z trzech
kroków. Krok Źródło zwraca wartość "Witaj,", Krok2 zwraca wartość kroku Krok1 z dopisaną
na jego końcu spacją, a Krok3 zwraca wartość kroku Krok2 z dołączonym słowem "świecie!".
Instrukcja in definiuje drugą fazę przekształceń, których wynik zwraca wyrażenie let. W tym
prostym przykładzie po instrukcji in umieszczony jest tylko Krok3. W efekcie zwracanym wynikiem
jest wartość identyfikatora Krok3, czyli tekst "Witaj, świecie!".
Wyrażenie let służy również do tworzenia wyrażeń, których wartości są wyliczane po słowie in.
Poniżej przedstawiony jest przykład kodu zwracającego tekst "Witaj, świecie!!!".
let
Źródło = "Witaj,",
Krok3 = Krok2 & "świecie!"
in
Krok3 & "!!"
W tym wyrażeniu po słowie in nie jest umieszczony identyfikator Krok3, tylko wyrażenie
złączające identyfikator Krok3 i tekst "!!". Poniżej przedstawiony jest podobny przykład, w którym
wewnątrz sekcji let zdefiniowany jest identyfikator Wykrzykniki, użyty dalej w sekcji in.
let
Źródło = "Witaj,",
Krok3 = Krok2 & "świecie!",
Wykrzykniki = "!!"
in
Krok3 & Wykrzykniki
Wyrażenie let można zagnieżdżać i tworzyć wyrażenia złożone. Poniżej przedstawiony jest
przykład wyrażenia zwracającego tekst "Witaj, świecie!!!".
let
PierwszeSłowo =
let
Źródło = "Witaj,"
in
Źródło,
DrugieSłowo =
let
Źródło = "świecie"
in
Źródło
in
PierwszeSłowo & " " & DrugieSłowo & "!!!"
213
4650570396d9eb2765da56c12eb840b5
4
Powyższe wyrażenie jest oczywiście poprawne, ale trudno się nim posługiwać w edytorze Power
Query. Ze względu na operacje niezbędne do wyliczenia ostatecznego wyniku całe wyrażenie jest
umieszczane w pasku formuły, ale w panelu Zastosowane kroki nie są widoczne poszczególne kroki.
Aby rozwiązać ten problem i utworzyć kroki, tak jak na rysunku 9.4, musisz w kodzie przed
ostatnim słowem in zdefiniować identyfikator Wynik, tak jak niżej:
let
PierwszeSłowo =
let
Źródło = "Witaj,"
in
Źródło,
DrugieSłowo =
let
Źródło = "świecie"
in
Źródło,
Wynik = PierwszeSłowo & " " & DrugieSłowo & "!!!"
in
Wynik
RYSUNEK 9.4. Jeżeli po ostatnim słowie „in” znajduje się wyrażenie, a nie pojedynczy identyfikator,
wtedy w panelu „Zastosowane kroki” widoczny jest tylko jeden krok; rozwiązanie problemu polega
na umieszczeniu opisanej wyżej instrukcji
Na pewno zauważyłeś, że identyfikator Źródło jest użyty dwukrotnie. Jeżeli w wyrażeniu let
dwukrotnie zdefiniuje się taki sam identyfikator, wtedy pojawi się następujący komunikat:
Zmienna o nazwie „Źródło” została już zdefiniowana w tym zakresie.
Jednak w powyższym przykładzie zostały użyte dwa różne wyrażenia let, jedno zagnieżdżone
w drugim. Wszystkie identyfikatory zdefiniowane w wewnętrznym wyrażeniu let są traktowane jak
lokalne i nie są dostępne w zewnętrznym wyrażeniu let. W części kodu, w której identyfikator
Źródło jest wykorzystywany do określenia wartości identyfikatora PierwszeSłowo, nie jest widoczny
identyfikator Źródło stosowany do określenia wartości identyfikatora DrugieSłowo, ponieważ obie
instancje identyfikatora Źródło znajdują się w różnych zakresach.
214
4650570396d9eb2765da56c12eb840b5
4
Zakresy i scalanie wyrażeń z wielu zapytań

Wiedza, czym są zakresy w języku M, i umiejętność tworzenia wyrażeń let są bardzo cenne.
Często będziesz wykorzystywał kroki jednego zapytania w innym zapytaniu. Aby właściwie
kopiować i wklejać fragmenty kodu, zazwyczaj wystarczy wykonać trzy poniższe kroki.
Przeanalizujmy przykład dwóch zapytań.
Załóżmy, że utworzyłeś zapytanie składające się z trzech następujących kroków:
let
Krok1 = …,
Krok2 = …,
Krok3 = …
in
Krok3
Utworzyłeś również inne zapytanie wykorzystujące bardzo przydatny filtr i zamierzasz
zastosować je w pierwszym zapytaniu:
let
Krok1 = …,
Krok2 = Table.SelectRows(Krok1, …)
in
Krok2
Skopiowałeś więc definicję identyfikatora Krok2 z drugiego zapytania i wkleiłeś do pierwszego,
tak jak niżej:
let
Krok1 = …,
Krok2 = …,
Krok3 = …,
in
Krok3
Oczywiście, powyższy kod jest błędny, ponieważ proste skopiowanie i wklejenie wierszy kodu to
za mało. Poniżej opisane są trzy błędy, które trzeba poprawić.
1. Identyfikator Krok2 jest już zdefiniowany w oryginalnym wyrażeniu, dlatego pojawia się
Zmienna o nazwie „Krok2” została już zdefiniowana w tym zakresie.
2. Pierwszym argumentem funkcji Table.SelectRows był oryginalny identyfikator Krok1,
ale po zmianach musi to być Krok3.
3. Po słowie in zamiast identyfikatora Krok3 powinien być użyty nowy identyfikator
zawierający wartość, która ma być zwracana przez wyrażenie.
Poniżej przedstawiony jest poprawny kod:
let
Krok1 = …,
Krok2 = …,
Krok3 = …,
in
Krok4
215
4650570396d9eb2765da56c12eb840b5
4
Pogrubioną czcionką wyróżnione są zmodyfikowane fragmenty kodu. Najpierw zmień nazwę

drugiego identyfikatora Krok2 na Krok4. Następnie zmień argument funkcji Table.SelectRows. Musi
to być identyfikator użyty tuż przed wywołaniem funkcji, czyli Krok3. Na koniec zmień identyfikator
umieszczony po słowie in. Musi to być identyfikator użyty w ostatnim kroku, czyli Krok4.
Zawsze podczas kopiowania fragmentów jednego zapytania i wklejania ich do drugiego musisz
dopasowywać kod i modyfikować kroki przekształceniowe.
Czasami będziesz musiał skopiować wiele wierszy kodu. W takim przypadku modyfikowanie
wszystkich wierszy może być trudnym zadaniem; jest tak szczególnie wtedy, gdy powtarzają się
nazwy identyfikatorów. Możesz wtedy zagnieżdżać wyrażenia, tak jak w poniższym przykładzie,
w którym zwracany wynik jest taki sam, co poprzednio:
let
Krok1 = …,
Krok2 = …,
Krok3 = …,
Krok4 =
let
in
Krok2
in
Krok4
Zwróć uwagę, że wewnątrz zakresu zagnieżdżonego wyrażenia widoczne są wartości wszystkich
identyfikatorów użytych w zewnętrznym zakresie z wyjątkiem Krok2, który jest ponownie zdefiniowany
lokalnie i nie jest traktowany jak duplikat. Podczas wyliczania wartości identyfikatora Krok4 wartość
zewnętrznego identyfikatora Krok2 nie jest zastępowana jego wewnętrznym odpowiednikiem, ponieważ
— jak wspomniałem wcześniej — oba identyfikatory Krok2 znajdują się w różnych zakresach.
Poniżej możesz zobaczyć przykład, w którym zewnętrzny identyfikator jest wykorzystany
i ponownie zdefiniowany w zagnieżdżonym wyrażeniu let:
let
A = 1,
B =
let
A = A + 1
in
A
in
B
Powyższe wyrażenie zwraca liczbę 2. Identyfikator A jest zdefiniowany dwukrotnie: najpierw
w zewnętrznym wyrażeniu let, gdzie przypisywana jest mu wartość 1, a następnie w wewnętrznym
wyrażeniu, gdzie przypisywana jest mu wartość zewnętrznego identyfikatora A powiększona o 1.
Jednak wewnętrzny identyfikator A jest czymś innym niż zewnętrzny i nie można się do niego
odwoływać w zewnętrznym wyrażeniu let. Sprawdźmy, co się stanie, gdy zostanie użyty podobny
kod jak wyżej, różniący się jedynie identyfikatorem A umieszonym po ostatnim słowie in:
let
A = 1,
B =
let
A = A + 1
in
A
in
A
216
4650570396d9eb2765da56c12eb840b5
4
Ten kod zwróci wynik 1, a nie 2, mimo że identyfikator A został powiększony o 1 w wewnętrznym
wyrażeniu let. W zewnętrznym zakresie identyfikator ten ma cały czas wartość 1. Uwzględniając
zakresy, należy ten kod interpretować w następujący sposób:
let
A_zewnętrzny_zakres = 1,
B =
let
A_wewnętrzny_zakres = A_zewnętrzny_zakres + 1
in
A_wewnętrzny_zakres
in
A_zewnętrzny_zakres
Wskazówka. Temat zakresów jest dość trudny. Pamiętaj, że możesz zapobiec generowaniu
błędnych wyników, stosując unikatowe identyfikatory.
Teraz, gdy lepiej rozumiesz wyrażenie let, czas, abyś poznał typy danych w języku M.
Typy danych, operatory i wbudowane funkcje

W języku M termin „wartość” określa dane tworzone podczas przetwarzania wyrażenia. W tym
punkcie poznasz różnego rodzaju wartości dostępne w języku M. Każdy rodzaj wartości jest
powiązany z określoną składnią, zbiorem wartości, operatorami, funkcjami i definicją typu.
Przyjrzymy się różnym elementom języka, specyficznym dla poszczególnych typów danych, na
przykładzie wartości liczbowych. Liczby w kroku M są reprezentowane za pomocą literałów, np. 0,
100, -12.5 lub 2.5e-7. Wartości te można przetwarzać przy użyciu wbudowanych funkcji o nazwach
składających się ze słowa Number, kropki i nazwy właściwej funkcji. Przykładowo funkcja Number.Abs
zwraca bezwzględną wartość liczby podanej w jej argumencie. Ponadto z liczbami są związane wbudowane
operatory, takie jak =, <, >, <=, >=, + i -. W tym punkcie rozdziału dowiesz się więcej na ten temat.
W języku M można deklarować typy argumentów funkcji i zwracanych przez nią wyników. Oprócz
tego można sprawdzać, czy dana wartość jest określonego typu. Przykładowo poniższe wyrażenie
wpisane w pasku formuły powoduje wyświetlenie napisu TRUE, tak jak pokazuje rysunek 9.5.
= 1000 is number
RYSUNEK 9.5. Wyrażenie „1000 is number” wpisane w pasku formuły zwraca wartość TRUE
217
4650570396d9eb2765da56c12eb840b5
4
Uwaga. W języku M wielkość liter ma znaczenie. Słowa TRUE lub FALSE pisane wielkimi
literami pojawiają się tylko podczas ich wyświetlania, tak jak na rysunku 9.5. W wyrażeniach
należy używać małych liter, tj. true lub false. Gdy użyje się np. wartości TRUE, wtedy pojawi się
Expression.Error: Nie można rozpoznać nazwy „TRUE”. Sprawdź, czy została wpisana poprawnie.
Typy danych są również zdefiniowane we wbudowanych funkcjach. Przykładowo funkcja

Number.Abs jest zadeklarowana w następujący sposób:
Number.Abs(number as nullable number) as nullable number
Powyższy wiersz kodu jest deklaracją funkcji. Funkcja ta ma jeden argument, którego wartością
może być liczba lub null. Wynik zwracany przez tę funkcję również jest liczbą lub wartością null.
Na podstawie tej składni wiadomo, że funkcji Number.Abs można użyć np. w następujący sposób:
= Number.Abs(-1000)
W efekcie uzyska się następujący wynik:
1000
Funkcję można również wywołać z argumentem null:
= Number.Abs(null)
Uzyska się wtedy wynik null.
Jeżeli jednak w argumencie funkcji umieści się wartość innego typu niż liczba, wtedy pojawi się
błąd. Przykładowo wywołanie funkcji z tekstem, tak jak niżej:
= Number.Abs("Witaj")
spowoduje pojawienie się następującego komunikatu:

Expression.Error: Nie możemy przekonwertować wartości "Witaj" na typ Number.
W tym rozdziale, dla uproszczenia opisu, wbudowane funkcje określonego typu będą oznaczane
jako Typ.X. Jak się przekonasz dalej w tym rozdziale, dostępnych jest m.in. wiele funkcji Number.X,
np. Number.Abs.
Teraz, gdy poznałeś najczęstsze zastosowania typów danych w języku M, możesz przejść do kolejnego
podrozdziału, poświęconego głównym typom danych, operatorom i wbudowanym funkcjom.
Podstawowe typy danych w języku M

Znajomość typów, jak również metod ich przetwarzania, jest bardzo przydatna podczas kodowania
operacji wykonywanych na kolumnach, tworzenia niestandardowych kolumn i stosowania filtrów
zawierających skomplikowane wyrażenia logiczne. Choć interfejs programu Power Query pozwala
wykonywać wiele różnych przekształceń, kiedy znasz dokładnie typy, operatory i wbudowane funkcje,
możesz jeszcze skuteczniej przetwarzać dane zapisane w kolumnach.
W tym podrozdziale poznasz przykłady kilku prostych formuł użytych poza kontekstem
przetwarzania danych. Gdy już dowiesz się, jak wykorzystuje się typy, będziesz z łatwością stosował
w pasku formuły operatory oraz wbudowane funkcje i modyfikował operacje wykonywane
na kolumnach.
218
4650570396d9eb2765da56c12eb840b5
4
Załóżmy, że chciałbyś użyć funkcji Number.X, której nie ma w interfejsie programu. Może to być
np. funkcja Number.Sqrt wyliczająca pierwiastek kwadratowy. Aby jej użyć, możesz w programie
Power Query zaznaczyć kolumnę zawierającą liczby i zastosować przekształcenie liczbowe.
Poniżej przedstawiona jest formuła utworzona w wyniku zastosowania przekształcenia
Wykładnicze/Wartość bezwzględna:
= Table.TransformColumns(Źródło,{{"Kolumna1", Number.Abs, type number}})
Aby wykonać żądane przekształcenie wartości w kolumnie Kolumna1, możesz zastąpić funkcję
Number.Abs funkcją Number.X (w tym przykładzie Number.Sqrt):
= Table.TransformColumns(Źródło,{{"Kolumna1", Number.Sqrt, type number}})
Jeżeli funkcja Number.X ma kilka argumentów, umieść słowo each, a po nim nazwę funkcji,
znak podkreślenia reprezentujący wartość liczbową oraz pozostałe argumenty. Poniżej przedstawiony
jest przykład formuły podnoszącej do trzeciej potęgi wartości zawarte w kolumnie Kolumna1:
= Table.TransformColumns(Źródło,{{"Kolumna1", each Number.Power(_,3), type number}})
Dalej w tym rozdziale opisane są podstawowe typy wartości w języku M, tj. number, time, date,
duration, text, null i logical.
Typ number
Typ number oznacza wartość liczbową wykorzystywaną w operacjach arytmetycznych, np. 1, −3.14
lub 2.0e5. Można stosować też format szesnastkowy. Przykładowo zapis 0xff oznacza liczbę 255.
Liczba w języku M zajmuje 8 bajtów pamięci i reprezentuje wartości z zakresu od 2,23 · 10-308
do 1,79 · 10308 z dokładnością do 16 cyfr po przecinku.
Poniżej wymienione są specjalne wartości typu number:
 plus nieskończoność: +#infinity
 minus nieskończoność: -#infinity
Nieskończoność może być wynikiem niektórych operacji. Przykładowo wynikiem dzielenia
1/0 jest plus nieskończoność, a wynikiem –1/0 jest minus nieskończoność.
 nie-liczba: #nan
Wartość #nan (wyświetlana jako NaN) może być wynikiem błędnych operacji
zmiennoprzecinkowych, np. dzielenia zera przez zero.
Do porównywania dwóch liczb służą operatory porównania >, >=, <, <=, = i <>. Do wykonywania
podstawowych operacji arytmetycznych wykorzystywane są operatory +, -, * i /.
Język M oferuje bogaty zestaw wbudowanych funkcji Number.X. Funkcje stałe zwracają specjalne
wartości. Przykładowo Number.PI zwraca wartość stałej . Funkcje informacyjne zwracają wartość
true lub false w zależności od tego, czy dana liczba spełnia określone kryteria. I tak Number.IsEven
sprawdza, czy liczba jest parzysta. Funkcje konwertujące służą do przekształcania wartości różnych
typów na liczby. Przykładowo poniższa funkcja przekształca ciąg "6" na liczbę 6:
= Number.From("6")
W edytorze Power Query w kartach Przekształć i Dodaj kolumnę dostępnych jest wiele funkcji
matematycznych, np. Number.Power (potęga) lub Number.Sin (sinus). Wszystkie funkcje Number.X
są opisane na stronie https://msdn.microsoft.com/query-bi/m/number-functions.
219
4650570396d9eb2765da56c12eb840b5
4
Typ time
Typ time (czas) oznacza liczbę 100-nanosekundowych interwałów, jakie upłynęły od ostatniej
północy. Największa wartość tego typu odpowiada godzinie 23:59:59,9999999. Wartości typu time
można definiować za pomocą wyrażenia #time(godzina, minuty, sekundy). Przykładowo wartość
oznaczającą godzinę 14:54 uzyskuje się, wpisując w pasku formuły następujący kod:
= #time(14, 53, 0)
W panelu podglądu pojawi się następujący wynik:
14:53:00
Z wartościami typu time można używać operatorów porównania >, >=, <, <=, = i <>. Ponadto
za pomocą operatorów +, - i & można wykonywać działania na wartościach typu time i duration
(okres). Aby np. do godziny 14:53 dodać 7 minut, należy użyć następującego wyrażenia:
= #time(14,53,00) + #duration(0,0,7,0)
W panelu podglądu pojawi się wynik:
15:00:00
Za pomocą funkcji Time.X można wyodrębniać poszczególne elementy czasu.
Przykładowo poniższa funkcja:
= Time.Hour(#time(14, 53, 0))
zwraca wartość typu number reprezentującą godzinę:

14
Więcej informacji na temat funkcji czasu znajdziesz w odpowiednich przekształceniach
zawartych w edytorze Power Query w kartach Przekształć i Dodaj kolumnę. Opis funkcji jest
również dostępny na stronie https://msdn.microsoft.com/query-bi/m/time-functions.
Typ date
Typ date oznacza liczbę dni, jakie upłynęły od 1 stycznia 1 roku (w kalendarzu gregoriańskim).
Największa wartość typu date reprezentuje datę 31 grudnia 9999 r., czyli 3 652 058 dni od początku
epoki. Wartości typu time można definiować za pomocą wyrażenia #date(rok, miesiąc, dzień).
Przykładowo wartość oznaczającą datę 26 sierpnia 2019 r. można uzyskać, wpisując w pasku
formuły następujący kod:
= #date(2019, 8, 26)
W panelu podglądu pojawi się wynik (jeżeli w systemie wybrane są polskie ustawienia regionalne):
2019-08-26
Z wartościami typu date można używać operatorów porównania >, >=, <, <=, = i <>, a za pomocą
operatorów +, - i & można wykonywać działania na wartościach typu date i duration.
W rozdziale 2., „Podstawowe operacje przygotowywania danych”, dowiedziałeś się, jak w edytorze
Power Query można wyodrębniać i przetwarzać daty. W poszczególnych krokach przekształceniowych
były stosowane odpowiednie funkcje Date.X. Język M oferuje bardzo wiele tego rodzaju funkcji.
Przykładowo Date.AddDays dodaje do daty podanej w pierwszym argumencie liczbę dni podanych
w drugim argumencie. Poniższe wyrażenie dodaje 5 dni do daty 26 sierpnia 2019:
= Date.AddDays(#date(2019, 8, 26), 5)
220
4650570396d9eb2765da56c12eb840b5
4
W panelu podglądu pojawi się następujący wynik (jeżeli w systemie wybrane są polskie
ustawienia regionalne):
2019-08-31
Pełna lista wbudowanych funkcji Date.X znajduje się na stronie https://msdn.microsoft.com/
query-bi/m/date-functions. Język M, oprócz funkcji Date.X i Time.X, oferuje funkcje DateTime.X
i DateTimeZone.X zwracające odpowiednio wartości typu datetime i datetimezone. Funkcje te są
automatycznie generowane przez edytor Power Query podczas stosowania przekształceń
dostępnych w kartach Przekształć i Dodaj kolumnę. Funkcja DateTime.LocalNow zwraca bieżącą
datę i godzinę. Można ją stosować do wyliczania czasu, jaki upłynął od dokonania transakcji,
jak również wykorzystywać w filtrach.
Typ duration
Typ duration oznacza okres pomiędzy dwoma punktami w czasie, wyrażony jako liczba
100-nanosekudowych interwałów. Wartość tego typu może być dodatnia (przesunięcie w przód)
lub ujemna (przesunięcie wstecz). Największa wartość reprezentuje okres 10 675 199 dni, 2 godzin,
48 minut i 5,4775808 sekund.
Wartości typu duration można definiować za pomocą wyrażenia #duration. Przykładowo okres
5 dni i 10 minut uzyskuje się, wpisując w pasku formuły następujący kod:
= #duration(5, 0, 10, 0)
W panelu podglądu pojawi się wynik:
5.00:10:00
Wartości typu duration najczęściej stosuje się z operatorami + i – oraz wartościami typów date,
time, datetime i datetimezone. Przykładowo poniższe wyrażenie dodaje 5 dni do daty 26 sierpnia 2019:
= #date(2019, 8, 26) + #duration(5, 0, 0, 0)
2019-08-31
Wynikiem dodawania lub odejmowania dwóch wartości typu date jest wartość typu duration.
Przykładowo poniższe wyrażenie:
= #date(2019, 8, 26) - #date(2019, 1, 1)
zwraca wynik:
237.00:00:00
Wbudowanych funkcji Duration.X można używać do wyodrębniania z daty liczby dni, godzin,
minut i sekund. Ponadto funkcje Duration.TotalX służą do wyliczania liczby jednostek czasu
w zadanym okresie. Poniższe wyrażenie zwraca liczbę sekund w 5-dniowym okresie:
= Duration.TotalSeconds(#duration(5, 0, 0, 0))
432000
Pełna lista wbudowanych funkcji Date.X znajduje się na stronie https://msdn.microsoft.com/
query-bi/m/duration-functions.
221
4650570396d9eb2765da56c12eb840b5
4
Typ text
Wartość typu text oznacza dowolny ciąg znaków Unicode. Dwie wartości tego typu można łączyć
za pomocą operatora &, tak jak w ćwiczeniu 9.1.
Dostępnych jest wiele funkcji Text.X umożliwiających przetwarzanie wartości tekstowych.
Przykładowo funkcja Text.From przekształca wartość typu number na text. Poniższe wyrażenie
zamienia liczbę na tekst, a później uzyskany wynik łączy z innym tekstem:
= "Test, " & Text.From(123)
Test, 123
W odróżnieniu od typów złożonych, do wyodrębniania znaków z wartości tekstowej nie można
używać nawiasów [] ani {}. Aby wyodrębnić określony znak, należy użyć funkcji Text.At, której
pierwszym argumentem jest zadany tekst, a drugim indeks znaku. Pierwszy znak ma indeks 0.
Przykładowo poniższe wyrażenie:
= Text.At("ABCD", 0)
zwraca wynik:
A
Natomiast wyrażenie:
= Text.At("ABCD", 1)
zwraca wynik:
B
Pełna lista funkcji tekstowych znajduje się na stronie https://msdn.microsoft.com/
query-bi/m/text-functions.
Typ null
Typ null oznacza brak wartości. Można z nim używać operatorów porównania i operatorów
arytmetycznych, przy czym wynik takiego wyrażenia będzie zawsze typu null. Jeżeli np. zmienna A
jest typu null, wtedy wyniki wszystkich poniższych wyrażeń są również typu null:
= A < 5
= A >= 5
= A + 1
= A * 5
Specjalnym przypadkiem jest użycie wartości typu null z operatorami porównania = lub <>.
Wynikiem takiego wyrażenia jest wartość true lub false w zależności od tego, czy użyta zmienna
jest typu null, czy nie. Jeżeli np. zmienna A jest typu null, wtedy po wpisaniu w pasku formuły
następującego wyrażenia:
= A = null
w panelu podglądu pojawi się wynik:

TRUE
222
4650570396d9eb2765da56c12eb840b5
4
Po wpisaniu wyrażenia:
= A <> 5
pojawi się wynik:

FALSE
= A <> null
pojawi się wynik:

FALSE
= A is null
pojawi się wynik:

TRUE
Zwróć uwagę, że słowo null oznacza zarówno typ, jak i wartość. Dlatego do sprawdzania,
czy wartość jest typu null, można używać operatora is lub operatora równości =.
Typ logical
Typ logical oznacza wartość logiczną true lub false. Wartości tego typu są wynikami operacji
porównania, np.:
 A > B
 A >= B
 A < B
 A <= B
 A = B
 A <> B
 A or B
 A and B
 not A
Do sprawdzania, czy dana wartość jest typu logicznego, służy konstrukcja is logical. Jeżeli np.
zmienna A zawiera wartość false, wtedy poniższe wyrażenie:
= A is logical
zwróci wartość true, a w panelu podglądu pojawi się napis TRUE.

Typy logiczne są powszechnie stosowane w wyrażeniach if opisanych dalej w tym rozdziale.
223
4650570396d9eb2765da56c12eb840b5
4
Typy złożone
Czas oficjalnie przedstawić Ci typy złożone w języku M, tj. listy, rekordy i tabele, oraz relacje
pomiędzy nimi. Typ prosty definiuje pojedynczą (atomiczną) wartość, natomiast typ złożony
ma określoną strukturę reprezentującą wiele wartości typów prostych lub złożonych.
Dane zaimportowane do programu Power Query zazwyczaj mają postać tabeli. Jednak
w tabelach mogą być zagnieżdżone rekordy, listy i inne tabele (jeżeli dane nie mają określonej
struktury, np. JSON lub XML). Tego rodzaju dane można przekształcać w listy (poprzez
wyszczególnienie kolumny) lub listy rekordów. Zajmijmy się na początek typem list,
najprostszym z trzech typów złożonych.
Typ list
Wartość typu list zawiera ciąg wartości, które można wyliczać. Wartości te mogą być np. listami,
rekordami i tabelami, jak również każda wartość może być innego typu. Listy definiuje się za
pomocą wyrażeń inicjujących, składających się z nawiasów klamrowych, i wartości oddzielonych
przecinkami. Poniżej przedstawiony jest przykład listy zawierającej liczby, wartości logiczne i tekst:
= {1, 3, true, false, "Witaj, świecie!"}
Poniższe wyrażenie, jak pokazuje rysunek 9.6, definiuje listę zawierająca liczby 1, 2 i 3.
= {1, 2, 3}
RYSUNEK 9.6. Listę definiuje się, wpisując w pasku formuły nawiasy klamrowe {}
Powyższą listę można zdefiniować za pomocą następującego wyrażenia:

= {1:3}
Aby zdefiniować listę zawierającą kolejne liczby od 1 do 100, należy użyć następującego
wyrażenia:
= {1:100}
Ten sposób bardzo przydaje się podczas kodowania iteracji opisanych dalej w tym rozdziale.
224
4650570396d9eb2765da56c12eb840b5
4
Aby zdefiniować listę zawierającą kolejne liczby od 1 do N (gdzie N jest wartością zwróconą
przez inne zapytanie, np. przetwarzające dane z innego źródła), należy użyć następującego wyrażenia:
= {1:N}
Ten sam wynik można uzyskać za pomocą funkcji List.Numbers:
= List.Numbers(1, N)
Zakres liczb wewnątrz listy definiuje się za pomocą dwóch kropek (..). Przykładowo poniższe
wyrażenie zwraca listę liczb 1, 4, 5, 6, 7, 8, 9, 10, 15:
= { 1, 4..10, 15 }
Liczbę elementów listy określa się za pomocą funkcji List.Count. Poniższe wyrażenie:
= List.Count( { 1..10} )
zwraca następujący wynik:

10
Pustą listę definiuje się, wpisując jedynie nawiasy klamrowe bez elementów. Funkcja List.Count
użyta z pustą listą, tak jak niżej:
= List.Count( {} )
zwraca liczbę 0.
Operatory stosowane z listami

Dwie listy można ze sobą połączyć za pomocą operatora &. Poniższe wyrażenie zwraca listę {1, 2,
3, 4, 5}:
= {1, 2} & {3, 4, 5}
Aby sprawdzić, czy dwie listy są takie same lub różne, należy odpowiednio użyć operatora = lub <>.
Poniższe wyrażenie wpisane w pasku formuły spowoduje wyświetlenie w panelu podglądu wartości TRUE:
= {1, 2} = {1, 2}
Poniższe wyrażenie również spowoduje wyświetlenie wartości TRUE:
= {2, 1} <> {1, 2}
Listy zawierające takie same elementy, ale umieszczone w innej kolejności, są traktowane jak różne.
Aby odwołać się do elementu znajdującego się w liście na określonym miejscu, należy użyć
nawiasów klamrowych i indeksu (numerowanego od zera). Przykładowo wyrażenie:
= {"A", "B", "C"}{0}
zwraca wynik:
A
= {"A", "B", "C"}{2}
zwraca wynik:
C
225
4650570396d9eb2765da56c12eb840b5
4
Próba odwołania się do elementu spoza listy zakończy się błędem. Poniższe wyrażenie odwołuje
się do czwartego elementu listy składającej się z trzech ciągów "A", "B" i "C":
= {"A", "B", "C"}{3}
Wyrażenie to spowoduje pojawienie się następującego komunikatu:
Expression.Error: Jest za mało elementów w wyliczeniu, aby można było zakończyć operację.
Do pierwszego i ostatniego elementu listy można odwoływać się za pomocą wbudowanych
funkcji odpowiednio List.First i List.Last. Poniższe wyrażenie:
= List.First({"A", "B", "C"})
zwraca wynik:
A
= List.Last({"A", "B", "C"})
zwraca wynik:
C
Funkcje List.X
Znajomość wbudowanych funkcji operujących na listach bardzo się przydaje podczas przekształcania
zawartości kolumn, np. wyliczania średniej arytmetycznej lub filtrowania wartości. Aby wykonywać
operację na kolumnie, należy kliknąć jej nagłówek prawym przyciskiem myszy i z podręcznego
menu wybrać polecenie Wyszczególnij. W panelu podglądu pojawi się lista, którą można przetwarzać
za pomocą wbudowanych funkcji. Rysunek 9.6 przedstawia narzędzia do obsługi list dostępne
w karcie Przekształć. Jak się przekonasz, język M oferuje znacznie więcej funkcji niż te, które możesz
zobaczyć w tej karcie.
Biblioteka funkcji operujących na listach jest bardzo bogata. Poniżej wymienione są kategorie
i przykłady najczęściej stosowanych funkcji.
 Funkcje informacyjne: do tej kategorii należą opisana wcześniej funkcja List.Count oraz
List.IsEmpty zwracająca wartość true, jeżeli lista jest pusta, lub false w przeciwnym
przypadku.
 Funkcje wybierające: funkcje z tej kategorii zwracają określone elementy lub podlisty.
Przykładowo funkcja List.Select zwraca elementy spełniające zadane kryteria, natomiast
funkcje FirstN i LastN zwracają listy składające się odpowiednio z N pierwszych lub
ostatnich elementów oryginalnej listy.
 Funkcje przekształcające: tego rodzaju funkcje służą do modyfikowania list. Do najczęściej
używanych należy funkcja List.Transform wykonująca zadaną operację na każdym
elemencie, oraz List.Combine, działająca podobnie jak operator złączania &. Do tej
kategorii należy również funkcja List.Accumulate, wspomniana w opisie piątego etapu
opanowania języka M i przedstawiona dalej w tym rozdziale.
 Funkcje członkowskie: funkcje te wykorzystują operatory porównania do sprawdzania,
czy elementy listy spełniają określone kryteria. Przykładowo funkcja List.Contains zwraca
wartość true, jeżeli lista zawiera zadaną wartość.
226
4650570396d9eb2765da56c12eb840b5
4
 Funkcje przypisania: funkcje z tej kategorii wykonują operacje na dwóch listach lub
większej ich liczbie. Przykładowo funkcja List.Intersect zwraca elementy znajdujące się
w dwóch listach, a List.Union zwraca elementy dwóch list bez duplikatów. W rozdziale
10., „Od złych do dobrych zapytań”, opisana jest bardzo przydatna funkcja List.Difference
zwracająca wszystkie elementy pierwszej listy, których nie ma w drugiej liście. Funkcji tej
używa się np. do odwoływania się do innych kolumn tabeli niż o wskazanych nazwach.
 Funkcje porządkowe: do tej kategorii należy funkcja List.Sort sortująca liczby lub
wartości dowolnego innego typu, które można ze sobą porównywać. Ponadto dostępne są
funkcje umożliwiające wyodrębnianie określonych elementów na podstawie ich wartości,
a nie pozycji w liście. Przykładowo funkcje List.Min i List.Max zwracają odpowiednio
najmniejszy i największy element, a funkcje List.MinN i List.MaxN odpowiednio n-ty
najmniejszy i największy element.
 Funkcje arytmetyczne: funkcje z tej kategorii wykonują na elementach listy operacje
arytmetyczne, takie jak uśrednianie lub sumowanie. Przykładowo funkcje List.Average
i List.StandardDeviation operują na listach składających się z wartości typu number,
datetime i duration, przy czym wszystkie elementy muszą być tego samego typu. Funkcja
List.Sum zwraca sumę elementów typu number lub duration.
 Funkcje generujące: funkcje należące do tej kategorii służą do tworzenia list. Wśród nich
są bardzo proste, np. List.Numbers (opisana wcześniej) oraz List.Dates tworząca listę dat
od początkowej do końcowej z zadanymi odstępami, jak również bardziej zaawansowane,
jak funkcja List.Generate tworząca listę na podstawie zadanych danych początkowych,
opisana na końcu tego rozdziału.
Więcej informacji o funkcjach operujących na listach jest dostępnych na stronie
https://msdn.microsoft.com/query-bi/m/list-functions.
Typ record
W Power Query z rekordami ma się do czynienia w dwóch sytuacjach, czyli podczas importowania
danych bez określonej struktury, np. JSON, oraz przekształcania wierszy tabeli. Rekord jest to zestaw
par klucz-wartość. Klucze (zwane również nazwami pól) są to unikatowe identyfikatory tekstowe,
a wartości (zwane wartościami pól) są to dane prostych lub złożonych typów.
Aby zdefiniować rekord, należy wpisać kwadratowe nawiasy, a wewnątrz nich oddzielone
przecinkami pary w formacie klucz=wartość. Przykładowo formuła:
= [ID=123, Imię="Alicja", Miasto="Kraina Czarów"]
definiuje rekord składający się z trzech kluczy i trzech wartości: ID=123, Imię="Alicja"
i Miasto="Kraina Czarów".
W edytorze Power Query rekord jest wyświetlany, tak jak na rysunku 9.7.
Rekord można uzyskać po odwołaniu się za pomocą nawiasów klamrowych do określonego
wiersza tabeli. Załóżmy, że mamy tabelę o nazwie Pracownicy. Czwarty wiersz tej tabeli zawiera
informacje o Alicji, której identyfikator równa się 123 i miejscem zamieszkania jest Kraina Czarów.
Aby odwołać się do czwartego wiersza, należy użyć wyrażenia z indeksem 3, tak jak niżej:
= Pracownicy{3}
227
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 9.7. Rekord definiuje się, wpisując w pasku formuły nawiasy kwadratowe []
Jeżeli nie wiadomo, w którym wierszu znajdują się dane Alicji, można przeszukać tabelę pod
kątem imienia „Alicja” lub identyfikatora 123. Poniżej przedstawione są odpowiednie wyrażenia
zwracające ten sam rekord (pokazany na rysunku 9.7):
= Pracownicy{[Imię="Alicja"]}
= Pracownicy{[ID=123]}
Uwaga. Odwołanie do określonego wiersza tabeli w pokazany wyżej sposób nie powiedzie się,
jeżeli przeszukiwana kolumna zawiera wiele takich samych wartości. Jeżeli np. tabela zawiera
dwa wiersze z imieniem „Alicja” lub dwa identyfikatory 123, wtedy pojawi się następujący
komunikat:
Expression.Error: Klucz pasował do co najmniej dwóch wierszy w tabeli.
Wiesz już, jak tworzyć i wyszukiwać rekordy oraz odwoływać się do nich, zatem
prawdopodobnie chciałbyś się dowiedzieć, jak odwoływać się do poszczególnych pól rekordu.
W tym celu umieść nazwę pola wewnątrz nawiasów kwadratowych. Aby np. odwołać się do pola
Alicja z poprzedniego przykładu, użyj następującej formuły:
= [ID=123, Imię="Alicja", Miasto="Kraina Czarów"][Imię]
Poniżej przedstawiony jest przykład typowego wyrażenia M automatycznie tworzonego przez
edytor Power Query po zastosowaniu filtru w określonej kolumnie. Wyrażenie to wybiera z tabeli
Pracownicy wszystkie wiersze, które w kolumnie Imię zawierają wartość Alicja. Zwróć uwagę,
że nazwa kolumny jest umieszczona wewnątrz nawiasów kwadratowych:
= Table.SelectRows(Pracownicy, each ([Imię] = "Alicja"))
Kod ten nie odwołuje się bezpośrednio do kolumny, tylko do pola rekordu. Każdy wiersz tabeli
jest traktowany przez funkcję Table.SelectRows jak rekord. Słowo each jest skrótem funkcji, który
sprawia, że wyrażenie jest prostsze. W tym przykładzie jest to funkcja, której argumentem jest
rekord, a zwracanym wynikiem wartość true, jeżeli pole Imię zawiera wartość "Alicja". Więcej
o słowie each dowiesz się dalej w tym rozdziale.
228
4650570396d9eb2765da56c12eb840b5
4
Operatory stosowane z rekordami

Aby złączyć dwa rekordy w jeden lub zmienić wartości pól rekordu, należy użyć operatora &.
Poniżej przedstawiony jest przykład wyrażenia scalającego dwa rekordy i zwracającego rekord
[ID=123, Imię="Alicja", Miasto="Kraina Czarów"]:
= [ID=123, Imię="Alicja"] & [Miasto="Kraina Czarów"]
Tworzenie nowego rekordu zawierającego zmodyfikowaną wartość istniejącego pola innego
rekordu jest jedną z najczęściej wykonywanych operacji. Poniższe wyrażenie zmienia wartość pola
ID z 123 na 456:
= [ID=123, Imię="Alice"] & [ID=456]
Przekształcenie Wyszczególnij wykonane na wierszu tabeli powoduje utworzenie rekordu
będącego kopią wiersza. Zatem modyfikacja rekordu nie powoduje zmiany wiersza. Aby zmienić
określoną wartość w tabeli, należy użyć odpowiedniej funkcji Table.X opisanej dalej w tym rozdziale.
Zwróć uwagę, że w języku M nie można modyfikować istniejącej wartości, niezależnie od jej typu.
Zmieniać można jedynie jej kopię. Przykładowo poniższe wyrażenie pozornie zmienia identyfikator
Alicji z 123 na 456. Jednak podczas wykonywania kodu pojawia się komunikat, taki jak na rysunku 9.8.
let
Źródło = [ID=123, Imię="Alicja"] & [Miasto="Kraina Czarów"],
Źródło[ID]=456
in
Niestandardowe1
RYSUNEK 9.8. Nie można zmieniać rekordu, bezpośrednio odwołując się do jego pola
Aby zmienić identyfikator Alicji na 456, należy użyć następującego wyrażenia:

let
Źródło = [ID=123, Imię="Alicja"] & [Miasto="Kraina Czarów"],
Wynik = Źródło & [ID=456]
in
Wynik
229
4650570396d9eb2765da56c12eb840b5
4
Aby sprawdzić, czy dwa rekordy są sobie równe, czy nie, należy użyć odpowiednio operatora
= lub <>. Poniższe wyrażenie wpisane w pasku formuły powoduje wyświetlenie w panelu podglądu
wartości TRUE:
= [ID=123, Imię="Alicja"] = [Imię="Alicja", ID=123]
Kolejność rozmieszczenia pól w rekordzie nie ma znaczenia.
Funkcje Record.X
Zapewne zauważyłeś, że na rysunku 9.7 we wstążce widoczna jest tylko jedna ikona — Do tabeli.
Przekształcenie to jest odpowiednikiem funkcji Record.ToTable. Choć we wstążce nie ma więcej
przekształceń, język M oferuje kilka przydatnych, wbudowanych funkcji Record.X.
Funkcja Record.FieldCount zwraca liczbę pól rekordu. Funkcja Record.HasFields zwraca
wartość true, jeżeli rekord zawiera pole, lub false w przeciwnym przypadku. Zwróć uwagę,
że pusty rekord ma postać samych nawiasów kwadratowych:
[]
Za pomocą funkcji Record.AddField można dodawać do rekordu pary klucz-wartość. Aby
utworzyć nowy rekord zawierający zmienioną wartość pola istniejącego rekordu lub scalić dwa
rekordy, należy użyć funkcji Record.Combine, tak jak niżej:
= Record.Combine( { [ID=123, Imię="Alicja"], [ID=456] } )
Więcej informacji na temat funkcji Record.X znajdziesz na stronie https://msdn.microsoft.com/
en-us/query-bi/m/record-functions.
Typ table
Najczęściej stosowanym typem w Power Query jest table. Po połączeniu się ze źródłem danych
w edytorze Power Query zazwyczaj pojawia się widok tabeli. Większość przekształceń wykonywanych
za pomocą wstążki jest zamieniana na odpowiednie wbudowane funkcje Table.X. W narzędziu
Power Query tabele odgrywają główną rolę. Jeżeli dokładnie poznasz powyższe funkcje, będziesz
mógł mierzyć się z najtrudniejszymi problemami przygotowywania danych.
Jak wspomniałem wcześniej w tym rozdziale, do kolumny tabeli możesz odwołać się za pomocą
jej nazwy umieszczonej w nawiasach kwadratowych. Przykładowo poniższe wyrażenie zwraca
zawartość (w postaci listy) kolumny Kolumna1 tabeli MojaTabela:
= MojaTabela[Kolumna1]
Aby odwołać się do pierwszego wiersza tej tabeli, należy użyć następującej formuły:
= MojaTabela{0}
Aby odwołać się do wartości w wierszu X i kolumnie Y, należy użyć jednego z poniższych
wyrażeń:
= MojaTabela{X-1}[KolumnaY]
= MojaTabela[KolumnaY]{X-1}
Pierwsze wyrażenie odwołuje się najpierw do x-tego rekordu (indeksy wierszy zaczynają się
od 0), a następnie do pola KolumnaY. Drugie wyrażenie odwołuje się najpierw do listy zawierającej
wartości kolumny KolumnaY, a następnie do x-tego elementu tej listy.
230
4650570396d9eb2765da56c12eb840b5
4
Aby zdefiniować tabelę, należy użyć wyrażenia #table, tak jak na rysunku 9.9 i w poniższym
przykładzie:
= #table({"ID", "Imię", "Miasto"}, {{123, "Alicja", "Kraina Czarów"},
{234, "Bartek", "Kraina Czarów"}})
RYSUNEK 9.9. W języku M tabelę definiuje się za pomocą wyrażenia #table; jest to wygodny sposób tworzenia
niewielkich, wewnętrznych tabel
Język M oferuje wiele wbudowanych funkcji do przetwarzania tabel. We wstążce dostępne są

najczęściej stosowane. Więcej informacji na ich temat znajdziesz na stronie https://msdn.microsoft.com/
en-us/query-bi/m/table-functions.
Przyjrzyjmy się pokrótce kilku funkcjom i przypadkom, w których są stosowane.
 Table.RowCount, Table.ColumnCount i Table.IsEmpty to przydatne funkcje umożliwiające
sprawdzanie, jaka jest wielkość tabeli i czy jest ona pusta. Bardzo często stosuje się je
w wyrażeniach if opisanych dalej w tym rozdziale.
 Funkcja Table.FirstValue zwraca wartość umieszczoną w pierwszym wierszu i pierwszej
kolumnie tabeli.
 Funkcja Table.Profile to prawdziwa tajna broń w przetwarzaniu danych. Zwraca nową
tabelę zawierającą wskaźniki statystyczne kolumn liczbowych (wartości minimalną,
maksymalną i średnią, odchylenie standardowe, liczbę wszystkich i unikatowych wartości
oraz liczbę pustych komórek).
 Funkcja Table.ColumnNames zwraca listę zawierającą nazwy kolumn. Ta bardzo przydatna
funkcja jest wykorzystana w rozdziale 10. „Od złych do dobrych zapytań”, do dynamicznego
odwoływania się do kolumn i zapobiegania błędom odświeżania raportu w przypadku
zmiany nazw kolumn.
 Table.FromColumns, Table.FromList, Table.FromRecords i Table.FromRows to
zaawansowane funkcje umożliwiające tworzenie tabel na podstawie złożonych struktur
danych, np. listy list lub listy rekordów.
 Funkcje Table.ToColumns, Table.ToList, Table.ToRecords i Table.ToRows przekształcają
tabele w złożone struktury danych.
231
4650570396d9eb2765da56c12eb840b5
4
Warunki i wyrażenia „if”

Znajomość warunków i wyrażeń if jest niezbędna w skomplikowanych przypadkach
przygotowywania danych. Pierwszy raz do czynienia z warunkami miałeś prawdopodobnie
w edytorze Power Query podczas stosowania filtrów w wybranych kolumnach. Jeżeli w pewnym
momencie uznasz, że sam edytor nie wystarczy do zastosowania skomplikowanych kryteriów
filtrowania, będzie to dobry moment, abyś spróbował szczęścia i warunki filtrowania zmienił
w pasku formuły.
Wcześniej w rozdziale, kiedy pisałem o podstawowych typach wartości, poznałeś operatory =, <>,
<, <=, >=, >, and, or i not. Wyrażenia logiczne tworzy się za pomocą powyższych operatorów i wartości
odpowiednich typów. W bardziej skomplikowanych przypadkach dodatkowo stosuje się nawiasy.
Poniżej przedstawiony jest prosty, utworzony za pomocą edytora Power Query warunek
wybierający wiersze zawierające w kolumnie Imię wartość Alicja:
= Table.SelectRows(Pracownicy, each ([Imię] = "Alicja"))
Poniższe wyrażenia wybierają wiersze, które w kolumnie Imię zawierają wartości inne niż Bartek:
= Table.SelectRows(Pracownicy, each ([Imię] <> "Bartek"))
= Table.SelectRows(Pracownicy, each not ([Imię] = "Bartek"))
Drugie wyrażenie jest przykładem użycia operatora not zamiast operatora nierówności (<>)
w celu uzyskania tego samego wyniku.
W powyższych wyrażeniach pogrubioną czcionką są wyróżnione fragmenty reprezentujące
wartość true lub false. Przekształcenie ich w bardziej skomplikowane warunki jest dość proste.
Poniżej jest pokazany przykład, jak wybierać wiersze, które w kolumnie Imię mają wartość Alicja,
a w kolumnie ID wartość 123 lub 456:
= Table.SelectRows(Pracownicy, each ([Imię] = "Alicja" and ([ID]=123 or [ID]=456)))
Zwróć uwagę, że warunek ([ID]=123 or [ID]=456) został umieszczony wewnątrz osobnej
pary nawiasów. Gdyby ich nie było, tak jak w poniższym przykładzie, w wynikach pojawiłyby się
dodatkowe wiersze zawierające w kolumnie ID wartość 456:
= Table.SelectRows(Employees, each ([Imię] = "Alicja" and [ID]=123 or [ID]=456))
Jak widać, w języku M warunki logiczne tworzy się tak samo jak w innych językach
programowania.
Innym przypadkiem, w którym może być niezbędna modyfikacja wyrażenia logicznego, jest
użycie kolumny warunkowej. Przykładowo w rozdziale 5., „Pozyskiwanie kontekstu”, w ćwiczeniu
5.4 zastosowałeś kolumnę warunkową do pozyskania dodatkowego kontekstu uzależnionego od
obecności określonej wartości w innej kolumnie. Jeżeli okaże się, że w oknie Kolumna warunkowa
nie można zastosować zaawansowanych kryteriów, prawdopodobnie zaczniesz dostosowywać
wyrażenie w pasku formuły do własnych potrzeb.
Wkrótce po tym, jak zaczniesz korzystać z kolumn warunkowych, odkryjesz wyrażenia if
tworzone automatycznie przez edytor Power Query. Gdy poznasz ich składnię, będziesz potrafił
z łatwością tworzyć skomplikowane wyrażenia bezpośrednio w polu formuły, w oknie
Kolumna warunkowa.
232
4650570396d9eb2765da56c12eb840b5
4
Wyrażenie „if-then-else”
Składnia wyrażenia if jest następująca:
= if (warunek) then A else B
Dobrą praktyką poprawiającą czytelność kodu jest wpisywanie wyrażenia w kilku wierszach,
tak jak niżej:
= if (warunek) then
A
else
B
Wyrażenia if można zagnieżdżać, tak jak w poniższym przykładzie:
= if (warunek_1) then
A
else if (warunek_2) then
B
else
C
Jeżeli jesteś zaawansowanym użytkownikiem Excela, zauważysz, że składnia wyrażenia if
znacząco różni się od składni formuł. Poniżej przedstawione są te same operacje zapisane
w postaci formuł:
JEŻELI(warunek; A; B)
JEŻELI(warunek_1; A; JEŻELI(warunek_2; B; C))
Wyrażenie if wewnątrz wyrażenia let

Często popełnianym błędem jest wpisywanie wyrażenia if w taki sam sposób jak w innych językach
programowania. Poniższe wyrażenie powinno zwracać wartość null, jeżeli Zapytanie1 jest puste,
albo pierwszy wiersz tego zapytania (w postaci rekordu) w przeciwnym przypadku. Poniższy kod
zawiera często popełniany błąd:
let
if (Table.IsEmpty(Zapytanie1) then
Wynik = null
else
Wynik = Zapytanie1{0}
in
Wynik
To wyrażenie nie działa. Wewnątrz wyrażenia let trzeba zawsze wpisywać identyfikator,
następnie znak równości, a po nim właściwe wyrażenie. Poprawny kod jest następujący:
let
Wynik =
if (Table.IsEmpty(Zapytanie1) then
null
else
Zapytanie1{0}
in
Wynik
233
4650570396d9eb2765da56c12eb840b5
4
Wskazówka. W zaawansowanym edytorze nie jest możliwe wpisanie w pierwszym wierszu

wyrażenia if. Zawsze na początku musi być identyfikator, po nim musi następować znak
równości, a dalej wyrażenie.
Wyrażenia if można umieszczać wewnątrz funkcji (o czym wkrótce się dowiesz dalej w tym
rozdziale), tak jak w poniższym przykładzie:
(imięPracownika) =>
if imięPracownika = "Alicja" then
"Kraina Czarów"
else
"prawdziwy świat"
W przekształceniach kolumn można umieszczać wyrażenia if, odpowiednio modyfikując kod
w pasku formuły. Przeanalizujmy typowy przypadek. Załóżmy, że zaimportowałeś dane zawierające
kolumnę Kraj, w której nie jest jednolicie stosowana wielkość liter (niektóre nazwy są wpisane
wielkimi, inne małymi literami). Postanowiłeś zastosować w edytorze Power Query przekształcenie
Zmień pierwszą literę każdego wyrazu na wielką. Poniżej przedstawione jest wygenerowane
wyrażenie M:
= Table.TransformColumns(Źródło,{{"Kraj", Text.Proper, type text}})
Następnie odkryłeś, że wielkości liter w niektórych nazwach są błędne (np. nazwy US i UK
zostały zamienione na Us i Uk). Aby rozwiązać problem, możesz zmienić powyższą formułę,
wprowadzając do niej wyrażenie if:
= Table.TransformColumns(Źródło,{{"Kraj", each if _ = "US" or _ = "UK" then _ else
Text.Proper(_), type text}})
Uwaga. Początkujący użytkownicy Power Query prawdopodobnie wykonają w celu rozwiązania

problemu wielkości liter kilka niepotrzebnych kroków, np. utworzą duplikat zapytania, w pierwszym
pozostawią wiersze z nazwami US i UK, a z drugiego usuną te wiersze. Następnie w drugim
zapytaniu zmienią pierwsze litery wszystkich wyrazów na wielkie, po czym scalą oba zapytania,
tak jak w rozdziale 3., „Łączenie danych z kilku źródeł”.
Innym, nieporęcznym rozwiązaniem jest utworzenie duplikatu kolumny Kraj i zmiana
pierwszych liter każdego wyrazu w oryginalnej kolumnie na wielkie. Następnym krokiem byłoby
utworzenie kolumny warunkowej zawierającej wartości oryginalnej kolumny, pod warunkiem
że w duplikacie kolumny wartości są inne niż US i UK. W takim przypadku do nowej kolumny
należałoby skopiować wartości z duplikatu. Na koniec trzeba usunąć oryginalną kolumnę i jej
duplikat, a nową kolumnę przemianować na Kraj. Widać więc, że niewielka modyfikacja
formuły M pozwala zaoszczędzić mnóstwo czasu i uniknąć wykonania niepotrzebnych kroków,
a dodatkowo zwiększyć wydajność zapytań.
W poprzednim przykładzie udoskonaliłeś krok przekształcenia, tworząc za pomocą słowa each

własną funkcję, która nie zmieniała wielkości liter w niektórych nazwach krajów. W następnym
podrozdziale dowiesz się więcej o niestandardowych funkcjach i dokładniej poznasz ich składnię.
234
4650570396d9eb2765da56c12eb840b5
4
Funkcje niestandardowe
W miarę przechodzenia do kolejnych etapów opanowania języka M przełomem w rozwiązywaniu
skomplikowanych problemów będzie rozpoczęcie pisania własnych funkcji. Złożone funkcje można
wprawdzie tworzyć w edytorze Power Query za pomocą polecenia Utwórz funkcję dostępnego
w podręcznym menu panelu Zapytania, ale jeszcze bardzie przydatna jest umiejętność swobodnego
wpisywania niestandardowych funkcji w zaawansowanym edytorze. Przykładowo w rozdziale 7.
„Zaawansowane metody dekomponowania i agregowania tabel”, utworzyłeś niestandardową funkcję
wykonującą sekwencję przekształceń dekomponujących tabelę. Bez możliwości swobodnego
modyfikowania kodu w zaawansowanym edytorze utworzenie takiej funkcji nie byłoby możliwe.
Niestandardową funkcję można utworzyć, nie tylko wykorzystując polecenie Utwórz funkcję,
ale również zaawansowany edytor i puste zapytanie lub istniejące wyrażenie. Poniżej przedstawiony
jest prosty przykład funkcji zwiększającej liczbę o 1:
(X) => X + 1
Uwaga. Wynik X+1 jest kopią argumentu, ponieważ wszystkie wartości w języku M
są niemutowalne (niezmienne).
Za pomocą wyrażenia let możesz w funkcji umieścić kilka kroków. Poniżej przedstawiony jest
nieco sztuczny przykład funkcji, której argumentem jest liczba X, a zwracanym wynikiem wartość
X+2. Funkcja składa się z dwóch kroków.
(X) =>
let
Krok1 = X + 1,
Krok2 = Krok1 + 1
in
Krok2
Gdy będziesz wpisywał w zaawansowanym edytorze wyrażenia, takie jak powyższe, często będzie
się zdarzać, że edytor Power Query będzie umieszczał kod wewnątrz wyrażenia let. Poniższe
wyrażenie, zmienione przez edytor Power Query, jest odpowiednikiem poprzedniego:
let
Źródło =
(X) =>
let
Krok1 = X + 1,
Krok2 = Krok1 + 1
in
Krok2
in
Źródło
Można tworzyć funkcje z wieloma argumentami. Poniżej przedstawiony jest przykład funkcji
dodającej dwie liczby:
(X, Y) => X + Y
Podczas tworzenia funkcji niestandardowej można jawnie określać typy argumentów i zwracanego
wyniku. Przykładowo w poniższym kodzie konstrukcja as number oznacza, że wynikiem zwracanym
przez funkcję jest liczba.
235
4650570396d9eb2765da56c12eb840b5
4
(X as number, Y as number) as number => X + Y

Oczywiście, funkcje niestandardowe mogą mieć argumenty różnych typów. W następnym
przykładzie argumenty są typu text i number, a zwracany wynik jest typu text:
(X as text, Y as number) as text => X & Text.From(Y)
Funkcje mogą mieć argumenty opcjonalne. W poniższym kodzie takim argumentem jest Y. Jeżeli
funkcja ta zostanie wywołana bez podania wartości tego argumentu, wtedy przyjmie on wartość null.
(X, optional Y) => if (Y = null) then X else X + Y
Zwróć uwagę, że jeżeli poniższa funkcja zostanie wywołana bez argumentu Y, wtedy zwróci
wartość null, a nie X, ponieważ wynikiem działania X = null jest null.
(X, optional Y) => X + Y
Oprócz tego można deklarować funkcje bez argumentów. Tego rodzaju funkcje są stosowane
w bardziej skomplikowanych przypadkach, np. razem z funkcją List.Generate opisaną pod koniec
rozdziału. Poniżej przedstawiony jest przykład funkcji bez argumentów, zwracającej wartość 0.
() => 0
Wywoływanie funkcji
Funkcje można definiować wewnątrz wyrażenia let lub jako osobne zapytania. Wywołuje się je tak
samo jak wbudowane funkcje, tj. wpisując nazwę funkcji, nawias otwierający, wartości argumentów
i nawias zamykający. W poniższym przykładzie w pierwszym wierszu zdefiniowana jest funkcja
funkcja, wywołana następnie w trzecim wierszu:
let
funkcja = (X) => X+1,
Liczba1 = 1000,
Wynik = funkcja(Liczba1)
in
Wynik
Funkcje mogą być argumentami innych funkcji. Jeżeli w argumencie funkcji trzeba umieścić inną
funkcję z jednym argumentem, wtedy można wpisać tylko jej nazwę bez nawiasów i argumentu.
Demonstruje to poniższy przykład zapytania odczytującego tabelę cen z zapytania TabelaCen
i mnożącego w kolumnie Cena wartości większe od 10 przez 0,98 (upust 2%).
let
FnCenyPoUpuście =
(cena) =>
if cena > 10 then
cena * 0.98
else
cena,
Źródło = TabelaCen,
CenyPoUpuście = Table.TransformColumns(
Źródło,
{{"Cena", FnCenyPoUpuście, type number}}
)
in
CenyPoUpuście
236
4650570396d9eb2765da56c12eb840b5
4
W tym wyrażeniu niestandardowa funkcja FnCenyPoUpuście jest wywoływana wewnątrz funkcji

Table.TransformColumns. Ponieważ funkcja niestandardowa ma jeden argument, można ją
wywoływać bez nawiasów i jawnego wskazywania argumentu. I tak poniższe wyrażenie:
= Table.TransformColumns(Źródło,{{"Cena", FnCenyPoUpuście, type number}})
jest równoważne następującemu:

= Table.TransformColumns(Źródło,{{"Cena", each FnCenyPoUpuście(_), type number}})
Wyrażenie each
Wyrażenie each służy do definiowana prostych funkcji w przyjazny dla użytkownika sposób.
Przykładowo poniższe wyrażenie zwiększa o 1 liczbę podaną w argumencie:
(X) => X + 1
Tę samą funkcję można zapisać w następujący sposób:
(_) => _ + 1
Argumentem wyrażenia jest znak podkreślenia. Poniżej przedstawiona jest skrócona wersja kodu:
each _ + 1
W niektórych przypadkach, jeżeli argument ma pola (np. jest to rekord lub tabela), można
całkowicie pominąć znak podkreślenia w wyrażeniu each. Przeanalizujmy poniższe wyrażenie
często stosowane do filtrowania wartości kolumny:
Table.SelectRows(Źródło, each [Cena] > 5)
Dłuższy zapis tej funkcji wygląda tak:
Table.SelectRows(Źródło, (_) => _[Cena] > 5 )
Pierwsze wyrażenie można uprościć, stosując słowo each:
Table.SelectRows(Źródło, each _[Cena] > 5 )
Ponieważ wyrażenie zawiera odwołanie do pola (wewnątrz nawiasów kwadratowych),
można pominąć znak podkreślenia. W pasku formuły pojawi się więc następujący kod:
Table.SelectRows(Źródło, each [Cena] > 5)
Ostatnie wyrażenie jest najbardziej czytelne ze wszystkich. Warto pamiętać, że jest to po
prostu skrót zwykłej funkcji. W przyszłości będziesz potrafił ją zmieniać i dostosowywać do
własnych potrzeb.
Zaawansowane tematy
W jednym rozdziale, a nawet w całej książce, nie da się szczegółowo opisać języka programowania
M. Jest wiele zaawansowanych tematów, które nie zostały opisane w tej książce. Niemniej jednak,
w ostatniej części tego rozdziału pobieżnie zapoznasz się z kilkoma zaawansowanymi
zagadnieniami, które szczególnie Ci się przydadzą, jeżeli w przyszłości zamierzasz biegle
programować w języku M.
237
4650570396d9eb2765da56c12eb840b5
4
Obsługa błędów
Edytor Power Query oferuje funkcjonalności do diagnozowania i korygowania błędów. Za ich
pomocą można modyfikować błędne wartości, a nawet całkowicie je usuwać. Ponadto błędy
w kodzie można obsługiwać nie tylko za pomocą interfejsu narzędzia, ale też programowo.
Błąd w języku M jest to informacja, że nie można określić wartości wyrażenia. Gdy pojawi się błąd,
zapytanie zwraca rekord Expression.Error. Standardowo, jeżeli nie jest jawnie zaimplementowana
obsługa błędów, zapytanie jest przerywane i wyświetlany komunikat. Aby „przechwycić” błąd
bez wstrzymywania wykonywania zapytania, należy użyć wyrażenia try/otherwise. Poniżej
przedstawiony jest przykład:
let
Wynik = try Źródło[Kolumna1] otherwise null
in
Wynik
W powyższym wyrażeniu konstrukcja try/otherwise jest wykorzystana do wyszczególnienia
kolumny Kolumna1 w tabeli Źródło. Jeżeli w tabeli nie ma kolumny o tej nazwie, wtedy wyrażenie
nie kończy się błędem i wyświetleniem komunikatu, tylko zwraca wartość null. To samo wyrażenie
można zapisać bez użycia części otherwise:
let
Wynik = try Źródło[Kolumna1]
in
Wynik
Powyższe wyrażenie zwraca rekord błędu, jeżeli tabela nie zawiera kolumny Kolumna1.
Rekord ten, pokazany na rysunku 9.10, można przetwarzać w edytorze Power Query tak samo
jak każdy inny krok.
RYSUNEK 9.10. Wyrażenie „try” zwraca rekord błędu, gdy zapytanie nie może być wykonane
Jeżeli wyrażenie try zostanie wykonane pomyślnie, zwracany wynik zawiera rekord, którego
pole HasError ma wartość false, a pole Value zawiera wynik wyrażenia. Poniższa formuła pokazuje,
jak można programowo obsługiwać błędy bez użycia słowa otherwise:
238
4650570396d9eb2765da56c12eb840b5
4
let
Próba = try Źródło[Kolumna1],
Wynik =
if Próba[HasError] then
null
else
Próba[Value]
in
Wynik
Wyrażenie to zwraca wartość null, jeżeli w tabeli Źródło nie ma kolumny Kolumna1. Jest ono
równoważne poniższemu, zawierającemu konstrukcję try/otherwise:
let
Wynik = try Źródło[Kolumna1] otherwise null
in
Wynik
W języku M można zgłaszać niestandardowe błędy. Poniższy przykład pokazuje, jak zmienić
wartość pola Message:
= try Źródło[Kolumna1] otherwise error "W tabeli FabrykaPrzygód nie ma kolumny Kolumna1."
Aby dowiedzieć się więcej o obsłudze błędów, odwiedź stronę https://msdn.microsoft.com/
en-us/query-bi/m/errors.
Leniwe i zachłanne przetwarzanie wyrażeń

Wyrażenia w języku M nie są przetwarzane sekwencyjnie. Stosowane jest tzw. „leniwe podejście”,
co znaczy, że wartość identyfikatora jest określana tylko wtedy, gdy jest to konieczne.
Przykładowo w poniższym przykładzie nie jest określana wartość identyfikatora Krok2:
let
Krok1 = 1,
Krok2 = 10000000,
Krok3 = Krok1 + 1
in
Krok3
Leniwe podejście jest stosowane nie tylko w wyrażeniu let, ale również w listach i rekordach.
Wszystkie pozostałe wyrażenia są przetwarzane „zachłannie”, tj. natychmiast po ich napotkaniu
w procesie wykonywania kodu.
Pętle
Jeżeli masz doświadczenie programistyczne, na pewno dziwi Cię to, że język M nie zawiera
wbudowanych pętli. Odpowiedź na to pytanie nie jest prosta. Język M został zaprojektowany pod
kątem kodowania sekwencji przekształceń, a iteracje są wbudowane w strukturze danych. Aby np.
zmienić wartość w kolumnie, nie trzeba pisać kodu odwołującego się do kolejnych wierszy tabeli.
Iteracje są wykonywane automatycznie w chwili zastosowania funkcji przetwarzającej tabelę.
Jednak jest kilka szczególnych przypadków, w których niezbędne jest jawne zaimplementowanie
pętli i sekwencyjne odwoływanie się do danych. Jednym z najczęstszych jest importowanie danych
ze strony WWW, gdy do załadowania niewielkiej ilości danych trzeba użyć numeru strony lub
wielkości przesunięcia. Aby można było odwoływać się do poszczególnych stron danych, trzeba
239
4650570396d9eb2765da56c12eb840b5
4
zaimplementować pętlę odliczającą numery stron z zadanego zakresu. W takim przypadku należy
utworzyć niestandardową funkcję importującą stronę o określonym numerze. Załóżmy, że
utworzyłeś własną funkcję o nazwie FnŁadowanieStronyOZadanymNumerze odczytującą wyniki
wyszukiwania. Poniższy kod jest przykładem iteracji listy liczb:
= {1..10}
Powyższą listę można przekształcić w tabelę, tak jak na rysunku 9.6, klikając w karcie Przekształć
ikonę Do tabeli. Po zmianie nazwy kolumny z Kolumna1 na NumerStrony należy zmienić jej typ na
Tekst, a następnie w karcie Dodaj kolumnę kliknąć ikonę Wywołaj funkcję niestandardową i wskazać
kolumnę NumerStrony. Na koniec trzeba rozwinąć nową kolumnę, która będzie zawierała połączone
wszystkie obiekty tabel.
Rekurencja
Innym sposobem powtarzania sekwencji przekształceń jest rekurencja. Dzięki niej w wielu językach
programowania można wykonywać skomplikowane obliczenia metodą „dziel i rządź”. Klasycznym
przykładem jest wyliczanie wyrazów ciągu Fibonacciego.
W ciągu Fibonacciego każdy wyraz, z wyjątkiem dwóch pierwszych, równych 0 i 1, jest sumą
dwóch poprzednich wyrazów. Zatem trzeci wyraz ma wartość 1 (0 + 1), czwarty wartość 2 (1 + 1),
a kolejne 3 (1 + 2), 5 (2 + 3), 8 (3 + 5), 13 (5 + 8) itd.
W języku M rekurencję implementuje się za pomocą znaku @ umożliwiającego wywoływanie
funkcji z wnętrza tej samej funkcji. Omija się wtedy ograniczenia zakresu widoczności zmiennych.
Poniżej przedstawiony jest kod wyliczający rekurencyjnie kolejne wyrazy ciągu Fibonacciego:
let
Fibonacci =
(n)=>
if (n = 0) then
0
else if (n = 1) then
1
else
@Fibonacci(n-1) + @Fibonacci(n-2)
in
Fibonacci
Nie zaleca się jednak stosowania rekurencji w języku M. Rekurencja jest kosztowną techniką
w każdym języku programowania, zajmującą mnóstwo pamięci w systemie operacyjnym, szczególnie
stosu. Jeżeli danych jest dużo albo trzeba wyliczyć dużo wyrazów ciągu Fibonacciego, wtedy szybko
nastąpi przepełnienie pamięci.
Funkcja List.Generate
Za pomocą funkcji List.Generate można implementować najprzeróżniejsze rodzaje iteracji,
włącznie z zagnieżdżonymi pętlami. Funkcja ta na podstawie zestawu funkcji wejściowych tworzy
listę wartości. Poniżej przedstawiona jest jej deklaracja:
List.Generate(initial as function, condition as function, next as function, optional selector
as nullable function) as list
240
4650570396d9eb2765da56c12eb840b5
4
Przyjrzyjmy się wewnętrznym szczegółom działania tej funkcji. Poniższy prosty kod, wpisany
w pasku formuły, generuje wyrazy ciągu Fibonacciego mniejsze od 100 (tj. {1, 2, 3, 5, 8, 13, 21,
34, 55, 89}).
= List.Generate(
() => [Poprzedni = 0, Bieżący = 1],
each [Poprzedni] + [Bieżący] < 100,
each [
Bieżący = [Poprzedni] + [Bieżący],
Poprzedni = [Bieżący]
],
each [Poprzedni] + [Bieżący]
)
W tym przykładzie argumentem initial funkcji List.Generate jest funkcja bez argumentów,
zwracająca rekord składający się z pól liczbowych Poprzedni i Bieżący o wartościach odpowiednio 0
i 1. Drugi argument, condition, jest funkcją each [Poprzedni] + [Bieżący] < 100. Dopóki funkcja
ta zwraca wynik true, generowane są elementy listy. Generowanie kończy się, gdy suma pól
Poprzedni i Bieżący jest większa od 100. Trzeci argument, next, jest funkcją przechodzącą do
następnego stanu iteracji, tj. generującą kolejne wartości pól Poprzedni i Bieżący. Polu Bieżący
przypisuje wynik [Poprzedni] + [Bieżący], tj. 1 (0 + 1 = 1), a polu Poprzedni wartość pola Bieżący,
czyli 1. W kolejnej iteracji funkcja przypisuje polu Bieżący liczbę 2 (1 + 1 = 2), a polu Poprzedni
liczbę 1. W trzeciej iteracji polu Bieżący jest przypisywana liczba 3 (2 + 1 = 3), a polu Poprzedni
liczba 2 itd. Czwartym argumentem funkcji List.Generate jest funkcja dopisująca kolejny wyraz
ciągu Fibonacciego do listy. Lista ta jest wynikiem zwracanym po zakończeniu wykonywania iteracji.
Funkcja List.Generate zastępuje pętle i umożliwia rozwiązywanie skomplikowanych problemów.
Zanim jednak jej użyjesz, spróbuj wykorzystać wbudowane funkcje operujące na tabelach. Funkcja
ta, ze względu na wykorzystywane w niej leniwe przetwarzanie wyrażeń, może działać wolniej niż inne
funkcje i zajmować więcej pamięci. W przypadku niewielkich ilości danych możesz jej z powodzeniem
używać. Więcej przykładów zastosowania, m.in. tworzenie zagnieżdżonych pętli, dzielenie danych
na strony i mnożenie macierzy, opisano na stronie https://datachant.com/tag/list-generate.
Funkcja List.Accumulate
Funkcja List.Accumulate agreguje elementy listy. Na podstawie wartości początkowej i funkcji
agregującej generuje zwracany wynik. Można jej używać do przetwarzania elementów listy
i stopniowego agregowania ich do żądanego wyniku. Poniżej przedstawiona jest deklaracja funkcji:
List.Accumulate(list as list, seed as any, accumulator as function) as any
Przyjrzyjmy się poszczególnym argumentom. Wykorzystamy w tym celu proste wyrażenie
sumujące kolejne liczby umieszczone w liście:
= List.Accumulate({1, 2, 3, 4}, 0, (stan, bieżący) => stan + bieżący)
Wynikiem powyższego wyrażenia jest liczba 10. Przeanalizujmy wyrażenie krok po kroku.
Danymi wejściowymi funkcji jest lista {1, 2, 3, 4} (argument list) i liczba 0 (argument seed).
W pierwszej iteracji w argumencie funkcji podanej w argumencie accumulator jest umieszczana
początkowa liczba 0 (podana w drugim argumencie funkcji List.Accumulate). Argument bieżący
uzyskuje wartość 1 (równą pierwszemu elementowi w liście), po czym obie wartości są sumowane.
Wynik, czyli liczba 1, staje się nowym stanem iteracji.
241
4650570396d9eb2765da56c12eb840b5
4
W drugiej iteracji w argumencie stan jest umieszczana wartość 1, a w argumencie bieżący

wartość 2 (drugi element listy), a ich suma staje się nową wartością argumentu stan.
W trzeciej iteracji argument stan uzyskuje wartość 3, a bieżący również wartość 3 (trzeci
element listy). Ich suma, liczba 6, staje się nową wartością argumentu stan.
W czwartej, ostatniej iteracji, argument stan uzyskuje wartość 6, a bieżący wartość 4 (czwarty
element listy). Ich suma staje się ostatecznym wynikiem zwracanym przez funkcję. Iteracje kończą
się z chwilą przetworzenia przez funkcję accumulator ostatniego elementu listy. Wynik tej funkcji
uzyskany w ostatniej iteracji jest zwracany przez funkcję List.Accumulate.
Poniżej przedstawiony jest przykład użycia funkcji List.Accumulate do wygenerowania
dziesiątego wyrazu ciągu Fibonacciego. W tej funkcji, inaczej niż w List.Generate, nie ma
możliwości zdefiniowania dynamicznego warunku zakończenia iteracji. Funkcja List.Accumulate
przetwarza po prostu wszystkie elementy listy. W tym przykładzie wykorzystana jest lista liczb od 0
do 9, ale wartości te nie są używane w obliczeniach.
let
Fibonacci =
List.Accumulate(
{0..9},
[PoprzedniWyraz = 0, BieżącyWyraz = 1],
(stan, bieżący) =>
[
PoprzedniWyraz = stan[BieżącyWyraz],
BieżącyWyraz = stan [BieżącyWyraz] + stan[PoprzedniWyraz]
]
),
Wynik = Fibonacci[BieżącyWyraz]
in
Wynik
W tym przykładzie argument seed jest rekordem złożonym z dwóch pól liczbowych
PoprzedniWyraz i BieżącyWyraz. Funkcja accumulator zwraca zaktualizowaną wersję rekordu,
w którym pole PoprzedniWyraz zawiera poprzednią wartość pola BieżącyWyraz, a pole BieżącyWyraz
zawiera sumę poprzednich wartości pól PoprzedniWyraz i BieżącyWyraz.
W rozdziale 11., „Podstawy analizy tekstu”, wykorzystasz funkcję List.Accumulate do
iteracyjnego zmieniania tekstu w kolumnie. Więcej informacji o zastosowaniach tej funkcji
znajdziesz na stronie https://datachant.com/2016/06/02/power-query-list-accumulate-unleashed.
Podsumowanie
Jeżeli chcesz zostać mistrzem w przetwarzaniu danych, powinieneś nauczyć się języka M. Aby biegle
posługiwać się edytorem Power Query i mierzyć się z różnymi praktycznymi problemami, nie musisz
osiągać mistrzowskiego poziomu. W tym rozdziale poznałeś najważniejsze elementy języka M. Od tej
chwili będziesz czuł się pewniej, modyfikując kod w pasku formuły i w zaawansowanym edytorze.
Poznałeś sześć etapów opanowania języka M. Określenie etapu, na którym się znajdujesz,
pozwoli Ci wybrać następny cel i obszary, na jakich powinieneś się skupić. Dowiedziałeś się, jakie
bloki konstrukcyjne są stosowane w języku M. Wśród nich jest wyrażenie let, różne typy danych
(number, time, date, duration, text, logical, record, list i table), operatory i wbudowane funkcje.
242
4650570396d9eb2765da56c12eb840b5
4
Za pomocą warunków i wyrażeń if wpisywanych w pasku formuły, w oknie Kolumna warunkowa

i w zaawansowanym edytorze, możesz rozbudowywać swoje zapytania o funkcjonalności niedostępne
w interfejsie programu. Dowiedziałeś się, jak za pomocą operatorów and, or i not oraz nawiasów
tworzyć sekwencje wyrażeń logicznych. Nauczyłeś się, jak i gdzie należy stosować wyrażenia
if/then/else.
Wiesz już, jak wywoływać wbudowane funkcje i tworzyć własne. Na koniec poznałeś obsługę
błędów, rekurencję i zaawansowane funkcje operujące na listach, z pomocą których można
implementować pętle i skomplikowane operacje na danych.
Zachęcam, abyś wrócił do tego rozdziału, gdy rozszerzysz swoją wiedzę o języku M i zaczniesz
mierzyć się z trudniejszymi problemami. W rozdziale 10. „Od złych do dobrych zapytań”, dowiesz
się, jak nieznaczne modyfikując wyrażenia w pasku formuły, można tworzyć przydatne, uniwersalne
i skalowalne zapytania.
243
4650570396d9eb2765da56c12eb840b5
4
244
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 10.
Od złych do dobrych zapytań
Dane są cennym dobrem, które będzie trwać dłużej niż systemy.

— Tim Berners-Lee
W TYM ROZDZIALE DOWIESZ SIĘ:

 jakie są typowe pułapki powodujące, że zapytania działają źle, a raporty nie odświeżają się
lub zawierają błędne dane,
 jakie dobre praktyki i modyfikacje pozwalają uniknąć błędów,
 jak zapobiegać problemom z odświeżaniem raportów, spowodowanym automatycznym
wykrywaniem typów danych,
 jak unikać tworzenia niebezpiecznych filtrów powodujących umieszczanie w raporcie
tylko części danych,
 kiedy warto zmieniać kolejność kolumn i jak poprawnie to robić,
 jak usuwać i zaznaczać kolumny, aby nie powodować błędów odświeżania raportu,
 jak zmieniać nazwy kolumn znajdujących się w określonych miejscach tabeli lub
zawierających w nagłówkach określone ciągi znaków,
 jakie niebezpieczeństwa wiążą się z dzieleniem kolumn na kolumny zamiast na wiersze,
 jak ulepszać formuły scalające kolumny.
Interfejsy graficzne edytora Power Query i Power BI są wyjątkowo użyteczne, ponieważ z ich
pomocą można zamienić żmudne, ręczne przygotowywanie danych w zautomatyzowany proces.
Niestety, w miarę czynienia postępów w przetwarzaniu danych będziesz popełniał błędy typowe dla
wielu użytkowników edytora Power Query. Błędy te powodują, że zapytania działają niestabilnie,
raporty nie odświeżają się po zmianie danych lub — co gorsza — pojawiają się w nich błędne
informacje. W tym rozdziale poznasz najczęściej spotykane pułapki, nauczysz się je omijać
i tworzyć stabilne zapytania.
Techniki opisane w tym rozdziale pozwolą Ci tworzyć wydajne zapytania, patrzeć
dalekowzrocznie i zwyciężać w niekończących się zmaganiach z systemem raportowym.
4650570396d9eb2765da56c12eb840b5
4
Zobacz też. Na moim blogu pod adresem https://datachant.com/tag/pitfalls dokładnie opisałem

dziesięć pułapek. W tym rozdziale pokazałem na przykładach i w ćwiczeniach najważniejsze kwestie,
na które powinieneś zwrócić uwagę. Dziesiąta pułapka, związana z usuwaniem duplikatów,
została już opisana w rozdziale 2., „Podstawowe operacje przygotowywania danych”.
Źródła pułapek i ich skutki

Edytor Power Query ma dwie ważne cechy:
 oferuje prosty w użyciu interfejs zamieniający wykonywane przez użytkownika kroki
na wyrażenia programistyczne,
 prezentuje podgląd (fragment) danych ułatwiający tworzenie ciągu przekształceń.
Powyższe cechy mają kluczowe znaczenie dla skutecznego przetwarzania danych, ale są też
źródłem zasadniczych, nieumyślnych pomyłek, z powodu których raporty nie odświeżają się
lub pojawiają się w nich niekompletne albo błędne dane. Problem ten ilustruje rysunek 10.1.
RYSUNEK 10.1. Czynniki powodujące powstawanie błędnych zapytań, uniemożliwiających odświeżanie

raportów i powodujących umieszczanie w nich niespójnych informacji
246
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 10.  OD ZŁYCH DO DOBRYCH ZAPYTAŃ
Każda czynność, którą wykonujesz w edytorze Power Query, jest rejestrowana w panelu
Zastosowane kroki, a w pasku formuły generowany jest kod tworzący większą sekwencję
przekształceń. Edytor musi nieustannie podejmować decyzje, w jaki sposób kolejne kroki, które
wykonujesz, powinny być zamienione na kod. Przykładowo krok Anulowano przestawienie kolumn
opisany w rozdziale 6., „Dekomponowanie tabel”, jest zamieniany na formułę M odwołującą się do
niezaznaczonych kolumn zamiast do zaznaczonych. Innym przykładem jest importowanie arkusza
Excela, w którym formuła M wykorzystuje nazwę arkusza, a nie jego położenie w skoroszycie.
Należy wyraźnie podkreślić, że decyzje edytora dotyczące przekształcania kroków na kod, nie są
przypadkowe. Edytor został przez jego twórców zaprojektowany tak, aby użytkownik mógł łatwo
tworzyć zapytania pozwalające osiągać zamierzone cele. Przekształcenia te są poprawne w momencie
utworzenia zapytania, ale mogą okazać się błędne w przyszłości. Niektóre decyzje edytora opierają
się wyłącznie na danych widocznych w podglądzie. Jeżeli dane te się zmienią, niektóre zapytania,
nieprzygotowane na takie sytuacje, mogą przestać działać poprawnie.
Typowym efektem zmiany danych źródłowych jest błąd pojawiający się podczas odświeżania
raportu. Często błędy pojawiają się regularnie, gdy dane wielokrotnie zmieniają format.
Przystosowanie zapytania do zmian, które zaszły w danych dzisiaj, nie oznacza, że będzie ono
odporne na zmiany w przyszłości.
Najczęstszą przyczyną problemów z odświeżaniem raportów są zmiany nazw kolumn w tabelach
źródłowych. Większość pułapek opisanych w tym rozdziale wynika z niewłaściwego odwoływania
się do kolumn za pomocą ich nazw. Może Ci się w tym momencie wydawać, że nie jest to duży
problem, ponieważ dostosowanie zapytania do nowych nazw jest prostym zadaniem, zajmującym
kilka minut. To prawda, edycja zapytania i przystosowanie go jest proste. Jednak teraz jesteś już
zaawansowanym użytkownikiem edytora Power Query i możesz tworzyć bardzo skomplikowane
zapytania. Jeżeli takie zapytanie nie powiedzie się z powodu zmienionej nazwy kolumny, możesz
spędzić mnóstwo cennego czasu na poprawianiu nazwy w wielu krokach. Czy uważasz za właściwe
poprawianie zapytań za każdym razem, gdy zmieni się nazwa kolumny? Tworzone przez Ciebie
raporty mogą być bardzo ważne dla setek osób w Twojej firmie, a problemy z ich odświeżaniem
mogą pojawiać się w najmniej oczekiwanych momentach.
Nie zawsze zmiany danych skutkują problemami z odświeżaniem raportów. Zapytania mogą
np. pomijać część danych, co może być przyczyną błędnych obliczeń, zniekształconych wykresów
i zafałszowanych wskaźników w raportach. Wykrywanie tego rodzaju problemów po fakcie nie jest
proste. Zapobieganie im jest za to dość łatwe i temu tematowi jest poświęcony rozdział.
Zanim przyjrzymy się bliżej najczęściej spotykanym pułapkom i sposobom ich unikania,
poznasz kilka podstawowych zasad, których powinieneś przestrzegać. Są one podzielone na trzy
grupy: świadome działanie, dobre praktyki i modyfikacje formuł M.
Świadome działanie
Aby działać bardziej świadomie i zmniejszyć prawdopodobieństwo wystąpienia kłopotów
z odświeżaniem raportów, podczas tworzenia kroków w edytorze Power Query przestrzegaj
poniższych zaleceń.
 Przeglądaj w panelu podglądu wyniki przekształceń i sprawdzaj, czy są prawidłowe.
Przewijaj podgląd w dół i w prawo, aby zobaczyć więcej wierszy i kolumn. Jeżeli zauważysz
coś podejrzanego, upewnij się, że wykonałeś poprawny krok, albo zastanów, czy możesz go
wykonać inaczej.
247
4650570396d9eb2765da56c12eb840b5
4
 Zawsze wyświetlaj pasek formuły (domyślnie jest ukryty) i poradź kolegom, by też tak
robili. Aby wyświetlić pasek, zaznacz w karcie Widok opcję Pasek formuły. Ma on
krytyczne znaczenie w unikaniu pułapek.
 Sprawdzaj kod pojawiający się w pasku formuły. Aby to robić skutecznie, nie musisz znać
dokładnie języka M. Zwracaj uwagę na wpisywane na stałe nazwy kolumn i inne wartości
szczególnie wtedy, gdy wprowadziłeś je wcześniej za pomocą interfejsu programu lub
w oknie dialogowym. Jeżeli np. usuniesz kolumnę o nazwie Kolumna1, w formule
prawdopodobnie pojawi się ta nazwa. Z dużym prawdopodobieństwem autor danych
zmieni ją w przyszłości na inną i zapytanie nie zostanie poprawnie wykonane. Częste
sprawdzanie kodu pojawiającego się w pasku formuły poskutkuje tym, że będziesz bardziej
świadomy takich zagrożeń i zapobiegniesz im w przyszłości.
Dobre praktyki
Pułapek opisanych w tym rozdziale można często uniknąć, przestrzegając kilku dobrych praktyk.
 Uzgadniaj format zewnętrznych danych źródłowych z ich autorami. Komunikuj się z nimi
często i omawiaj przyjmowane założenia. Wspólnie opracujcie proces kontroli zmian,
który pozwoli Ci przygotować się na nadchodzące modyfikacje. Informuj kolegów
o tworzonych raportach i uświadamiaj ich, że uczestniczą w procesie raportowania i są
odpowiedzialni za jego powodzenie.
 Zapisuj raporty przed ich odświeżaniem, abyś mógł identyfikować zachodzące zmiany.
Raport, który pomyślnie odświeżyłeś dzisiaj, może jutro się nie odświeżyć lub pokazać
błędne dane. Porównując różne wersje raportu, będziesz w stanie określić przyczyny
niepowodzenia.
 Jak się dowiesz w tym rozdziale, niektórych pułapek można całkowicie uniknąć, dokonując
odpowiednich wyborów (np. przez usunięcie kolumny) lub unikając wykonywania
niepotrzebnych operacji (np. zmiany typów lub kolejności kolumn).
Modyfikacje formuł M
Aby tworzyć stabilne zapytania, powinieneś w formułach wprowadzać kilka prostych modyfikacji.
Wprawdzie aby uniknąć określonej pułapki, trzeba odpowiednio do niej zmieniać formuły, jednak
większość zmian dotyczy funkcji Table.ColumnNames, w której statyczne odwołania do kolumn
należy zastępować odwołaniami dynamicznymi. Taki przypadek poznałeś już w rozdziale 3.,
„Łączenie danych z kilku źródeł”, w ćwiczeniu 3.4, w którym połączyłeś dane z kilku arkuszy,
uzupełniłeś je o kolumnę z informacjami kontekstowymi i zmieniłeś nazwę kolumny z 2015 na Rok.
Następnie zmodyfikowałeś funkcję Table.ColumnNames tak, aby zmieniała nazwę pierwszej kolumny,
a nie kolumny o nazwie 2015. W ten sposób utworzyłeś bardziej stabilne zapytanie i zapobiegłeś
problemom z odświeżaniem raportu w przyszłości.
W tym rozdziale poznasz różne modyfikacje kodu zawierającego funkcję Table.ColumnNames,
pozwalające uniknąć najczęściej spotykanych pułapek, tworzyć stabilne zapytania i minimalizować
prawdopodobieństwo wystąpienia problemu z odświeżaniem raportu.
248
4650570396d9eb2765da56c12eb840b5
4
Pułapka 1. Ignorowanie paska formuły

Wykonując ćwiczenia opisane w poprzednich rozdziałach, często musiałeś korzystać z paska
formuły, aby lepiej zrozumieć wykonywane przekształcenia i modyfikować formuły w celu
osiągnięcia określonych celów. W rozdziale 9., „Wprowadzenie do języka M”, poznałeś podstawy
języka M i teraz powinieneś już poradzić sobie z określeniem, w jakim stopniu chcesz go używać.
Niektórzy użytkownicy z entuzjazmem stosują ten język do realizacji swoich celów, inni uważają,
że jest dziwny i niełatwo się go nauczyć.
Jeżeli należysz do pierwszej grupy użytkowników, pierwszej pułapki unikniesz z łatwością. Jeśli
jednak identyfikujesz się z drugą grupą i język M wydaje Ci się obcy, z zadowoleniem przyjmiesz
wiadomość, że 90% problemów będziesz mógł rozwiązać bez jego użycia. Większość swoich celów,
jeżeli nie wszystkie, osiągniesz, nieznacznie modyfikując formuły. Jeżeli jednak używasz edytora
Power Query do tworzenia ważnych dla swojej firmy raportów, wtedy pasek formuły będzie Twoim
sprzymierzeńcem na drodze do sukcesu.
Włącz pasek formuły i sprawdzaj często jego zawartość. Naucz się wyszukiwać w nim statyczne
elementy, takie jak nazwy kolumn (umieszczone wewnątrz nawiasów kwadratowych) i stałe wartości
(w cudzysłowach). Sprawdzaj, czy elementy te są stosowane właściwie, i przestrzegaj opisanych
wcześniej dobrych praktyk, które pozwolą uniknąć większości pułapek.
Jeżeli lekturę książki zacząłeś od tego rozdziału, włącz pasek formuły w następujący sposób:
w edytorze Power Query kliknij kartę Widok, a następnie zaznacz opcję Pasek formuły, tak jak
na rysunku 10.2.
RYSUNEK 10.2. W pasku formuły widać, jak w poszczególnych krokach, np. „Zmieniono typ”,
wykorzystywane są nazwy kolumn
Ćwiczenie 10.1. Wyszukiwanie w pasku formuły

statycznych odwołań do nazw kolumn
Poniższe krótkie ćwiczenie pokazuje, jak w pasku formuły wyszukiwać statyczne odwołania do
kolumn i przygotować się do uniknięcia drugiej pułapki. W ćwiczeniu wykorzystasz załączony do
książki plik R10-01.xlsx zawierający podsumowanie zamówień fikcyjnej firmy Światowi Importerzy.
249
4650570396d9eb2765da56c12eb840b5
4

3. W oknie Nawigator zaznacz Arkusz1 i kliknij przycisk Przekształć dane.
4. Jeżeli pasek formuły nie jest widoczny, zaznacz w karcie Widok opcję Pasek formuły.
5. Zwróć uwagę, że ostatni krok w panelu Zastosowane kroki nosi nazwę Zmieniono typ,
a w pasku formuły widoczny jest następujący kod (patrz rysunek 10.2):
= Table.TransformColumnTypes(#"Nagłówki o podwyższonym poziomie",{{"Data", type date},
{"Kolor", type text}, {"Kategoria dostawcy", type text}, {"Nazwa dostawcy", type
text}, {"Kategoria klienta", type text}, {"Miasto", type text}, {"Losowa kolumna 1",
type number}, {"Losowa kolumna 2", type number}, {"Przychód", type number}})
Bez wnikania w przekształcenia wykonywane w tym kroku widać, że formuła zawiera wiele
nazw umieszczonych w cudzysłowach. Jeżeli chcesz uniknąć licznych pułapek podczas
tworzenia własnych zapytań, tego rodzaju wartości powinieneś zawsze szukać w pasku
formuły. Często ciągi znaków zawarte w cudzysłowach reprezentują nazwy kolumn
wprowadzanych w różnych oknach dialogowych.
Tutaj widać m.in. kolumny Losowa kolumna 1 i Losowa kolumna 2. Załóżmy, że kolumny te
zawierają nic nieznaczące dane, które nie powinny być umieszczone w raporcie. W praktyce
będziesz miał do czynienia z najróżniejszymi nazwami kolumn zawierającymi tymczasowe
informacje kontekstowe. Niezależnie od tego, czy kolumny te powinny znaleźć się w raporcie,
czy nie, w kroku Zmieniono typ nazwy tych kolumn są wymieniane jawnie. Jeżeli kolumny te
nie zawierają istotnych informacji, z dużym prawdopodobieństwem zostaną usunięte
ze źródłowej tabeli przez jej autora. Poniższe kroki pokazują, co się wtedy stanie.
6. Zamknij edytor Power Query i załaduj zapytanie do arkusza Excela lub raportu Power BI.
7. Wyobraź sobie teraz, że jesteś innym użytkownikiem i jednocześnie autorem danych.
Otwórz skoroszyt R10-01.xlsx, usuń z niego kolumny Losowa kolumna 1 i Losowa kolumna 2
i zapisz go. Wróć do swojej poprzedniej roli, aby sprawdzić skutki tej zmiany.
8. Odśwież raport. Pojawi się spodziewany komunikat:
[Expression.Error] Nie można znaleźć kolumny „Losowa kolumna 1” w tabeli.

Zauważ, że nie wskazałeś jawnie, jakie kolumny powinny znaleźć się w raporcie.
Zadecydował o tym edytor, umieszczając w raporcie odwołania do nich. Dowiesz się o tym
więcej w opisie pułapki 2., ale na razie sprawdźmy, co można zrobić w tej sytuacji zgodnie
ze wspomnianymi wcześniej zasadami, takimi jak świadome działanie, dobre praktyki
i modyfikacje kodu.
Analizując kod zawarty w pasku formuły, stwierdziłeś zagrożenie wynikające z jawnie
wpisanych nazw kolumn zawierających nieistotne informacje. Możesz powiadomić o tym
autora danych i umówić się, że w przyszłości będzie Cię powiadamiał o zamiarach usunięcia
kolumn lub zmiany ich nazw. Jeżeli uznasz, że kolumny te zawierają jednak jakieś informacje
biznesowe, możesz postanowić, że wykorzystasz je w raporcie.
9. Ostatecznie, modyfikując formułę, możesz usunąć odwołania do niepotrzebnych kolumn:
{"Losowa kolumna 1", type number}, {"Losowa kolumna 2", type number},
250
4650570396d9eb2765da56c12eb840b5
4
Poniżej przedstawiona jest stabilna wersja formuły, pomijająca kolumny z niepotrzebnymi

danymi:
{"Kolor", type text}, {"Kategoria dostawcy", type text}, {"Nazwa dostawcy", type text},
{"Kategoria klienta", type text}, {"Miasto", type text}, {"Przychód", type number}})
Nowa formuła wciąż jednak zawiera wiele kolumn, które mogą być w przyszłości usunięte
lub przemianowane. Czy rzeczywiście odwołania do nich są w tym kroku potrzebne?
Odpowiedź na to pytanie znajdziesz w opisie 2. pułapki.
Pułapka 2. Zmiana typów danych

W ćwiczeniu 10.1 poznałeś jedną z najpopularniejszych pułapek, będącą główną przyczyną
problemów z odświeżaniem raportów w przypadku zmian nazw kolumn. Na rysunku 10.2 w panelu
Zastosowane kroki jest widoczny krok Zmieniono typ, automatycznie tworzony podczas importowania
danych do edytora Power Query. Aby uniknąć pułapki 2., sprawdzaj, czy w panelu znajdują się inne
kroki tego rodzaju. Najczęściej są one tworzone podczas ładowania plików tekstowych i arkuszy
oraz w czasie stosowania pierwszego wiersza jako nagłówków kolumn. Zawsze usunięcie kolumny
lub choćby najmniejsza zmiana jej nazwy powodują problemy z odświeżaniem raportu.
Najprostszym i najczęściej stosowanym sposobem uniknięcia tej pułapki jest usunięcie kroku
Zmieniono typ, tak jak na rysunku 10.3.
RYSUNEK 10.3. Usunięcie kroku „Zmieniono typ” w celu uniknięcia pułapki
Gwoli wyjaśnienia, niektóre kolumny wymagają określenia właściwego typu danych. Jeżeli tego
nie zrobisz, nie będziesz mógł wykonywać pewnych operacji, np. sumowania lub uśredniania
wartości, ani przetwarzać wartości czasowych w tabelach przestawnych w Excelu lub elementach
wizualizacyjnych w Power BI. Edytor Power Query został zaprojektowany tak, aby niejawnie
określał typy danych we wszystkich kolumnach tabeli. Gdyby ten krok nie był wykonywany
automatycznie, a Ty zapomniałbyś zrobić to ręcznie, nie mógłbyś umieszczać pól liczbowych
w obszarze Wartości w tabeli przestawnej w Excelu i w elemencie wizualnym w Power BI.
251
4650570396d9eb2765da56c12eb840b5
4
Zamiast zdawać się na automatyczne określanie typów danych, lepiej usunąć krok Zmieniono typ
i ręcznie wybrać typy. Operację należy wykonywać jak najpóźniej w całym procesie przetwarzania
danych, z niżej opisanych powodów.
Wskazówka. Podczas zmieniania typów danych w edytorze Power Query warto przestrzegać
zasady „im później, tym lepiej”. Dobrą praktyką jest ręczne zmienianie typów kolumn
i niezdawanie się na ustalanie automatyczne. Im później jawnie określi się typy, tym lepiej.
Zmienianie typów w ostatnim kroku ma następujące zalety.

 Szybsze generowanie (odświeżanie) raportu. Zmiana typu danych (np. z tekstu na datę
i czas) wymaga wykonania pewnych obliczeń przez silnik języka M. Jeżeli zamierzasz
zastosować filtr, który istotnie zmniejszy liczbę wierszy, zrób to przed ręczną zmianą typu
kolumn, a wtedy skrócisz czas wykonywania zapytania.
 Obsługa błędów. Jeżeli zmiana typu wartości w określonych kolumnach nie jest możliwa,
pojawiają się błędy. Jeżeli zdarzy się to na początku sekwencji przekształceń, ich
diagnostyka może być czasami bardzo trudna.
Zobacz też. Przykład trudnego do wykrycia błędu spowodowanego zmianą typu danych
na wczesnym etapie przekształceń jest opisany w artykule na stronie https://datachant.com/
2017/01/11/10-common-mistakes-powerbi-powerquery-pitfall-2.
 Trwałość zmian. W niektórych przypadkach zmiana typu danych na początku procesu nie jest
trwała. Przykładowo podczas łączenia skoroszytów zapisanych w folderze zmiana typu danych
wykonana w przykładowym zapytaniu nie jest przenoszona do wynikowego zapytania.
Zapewne zastanawiasz się, czy możesz skonfigurować edytor Power Query tak, aby nie wykrywał
i nie określał typów danych, żebyś nie musiał ręcznie usuwać kroku, tak jak na rysunku 10.3. Jest to
możliwe, ale indywidualnie dla każdego skoroszytu i raportu Power BI. Nie można tego zrobić dla
wszystkich przyszłych raportów.
Aby wyłączyć w edytorze Power Query automatyczne wykrywanie i określanie typów kolumn,
otwórz okno Opcje zapytania w Excelu (w tym celu w karcie Dane kliknij ikonę Pobierze dane i wybierz
polecenie Opcje dodatku Query) lub Opcje w programie Power BI Desktop (w karcie Plik kliknij polecenie
Opcje i ustawienia, a następnie Opcje). Następnie w Excelu w sekcji Bieżący skoroszyt lub w Power BI
Desktop w sekcji Bieżący plik kliknij polecenie Ładowanie danych i usuń zaznaczenie opcji
Automatycznie wykrywaj nagłówki i typy kolumn dla źródeł bez struktury (patrz rysunek 10.4).
Niestety, nie ma analogicznej opcji w sekcji Globalne, Ładowanie danych. Dlatego powyższy
proces trzeba powtarzać w każdym nowym raporcie.
Na koniec, po usunięciu kroku Zmieniono typ lub wyłączeniu opcji jego automatycznego
tworzenia jawnie określaj typy kolumn, które zawierają daty i liczby potrzebne do analizy.
Ewentualnie możesz modyfikować krok Zmieniono typ w sposób opisany w ćwiczeniu 10.1, w kroku
9. Zwróć uwagę, że użyta tam formuła odwołuje się do wielu kolumn tekstowych. Odwołania te
możesz usunąć, a wtedy unikniesz problemów z odświeżaniem raportów, gdyby w przyszłości
zmieniły się nazwy kolumn. Kolumny te są w poniższej formule wyróżnione pogrubioną czcionką:
{"Kolor", type text}, {"Kategoria dostawcy", type text}, {"Nazwa dostawcy", type text},
{"Kategoria klienta", type text}, {"Miasto", type text}, {"Przychód", type number}})
252
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 10.4. Wyłączenie automatycznego wykrywania i określania typów danych
Aby dodatkowo usprawnić zapytanie, usuń z panelu Zastosowane kroki krok Zmieniono typ
i ręcznie zmień typy kolumn Data i Przychód albo zmień istniejącą formułę w następujący sposób:
{"Przychód", type number}})
Wskazówka. Jeżeli przetwarzasz tabele, które mają zbyt wiele kolumn, aby ręcznie zmieniać ich
typy, i szukasz sposobu automatycznego określenia ich typów bez jawnego odwoływania się do
nazw, bardzo Ci się przyda formuła opisana w artykule pod adresem: http://datachant.com/
2018/05/14/automatic-detection-of-column-types-in-powerquery.
Pułapka 3. Niebezpieczne filtrowanie

Pułapka 3. jest jedną z najniebezpieczniejszych, ponieważ jest niemal niewidoczna, możesz ją łatwo
przeoczyć, tworząc zapytanie, i nie zauważyć skutków podczas odświeżania raportu. Powoduje ona,
że w raporcie nie są uwzględniane wszystkie dane, a kiedy już ją wykryjesz, może się okazać, że jest
za późno, ponieważ na podstawie zafałszowanych raportów zostały podjęte decyzje biznesowe.
Wszystko zaczyna się od filtru i tworzonego na jego podstawie kroku. Jest to na tyle trywialny
i popularny krok, że zawiera go niemal każde zapytanie.
253
4650570396d9eb2765da56c12eb840b5
4
Ćwiczenie 10.2. Część I. Filtrowanie czarnych produktów

Zanim dokładnie poznasz zagrożenie spowodowane pułapką 3., przeanalizujmy prosty przykład
demonstrujący błąd filtrowania i sposób jego uniknięcia. W tym ćwiczeniu wykorzystasz te same
dane, co w ćwiczeniu 10.1. Wyobraź sobie, że jesteś szefem działu analiz w firmie Światowi Importerzy
i dostałeś zadanie przeanalizowania skutków biznesowych wstrzymania importu czarnych produktów.
Postanowiłeś więc odfiltrować w swoich zapytaniach wszystkie czarne produkty.
5. Sprawdź, czy widoczny jest pasek formuły.
6. Zmień typ danych w kolumnie Data na Data, a kolumny Przychód na Liczba dziesiętna.
(W krokach od 4. do 6. bezpiecznie ominąłeś pułapki 1. i 2.).
7. Ponieważ produkty są dostępne w różnych kolorach, odrzuć wszystkie czarne. W tym celu
kliknij w nagłówku kolumny Kolor ikonę filtru i usuń zaznaczenie koloru czarny, tak jak
na rysunku 10.5.
RYSUNEK 10.5. Usunięcie koloru czarnego grozi uzyskaniem błędnych wyników
254
4650570396d9eb2765da56c12eb840b5
4
Po wykonaniu tego kroku prawdopodobnie oczekujesz, że lista będzie zawierała produkty

w kolorach innych niż czarny.
8. Zwróć uwagę na kod, który pojawi się w pasku formuły:
= Table.SelectRows(#"Zmieniono typ", each ([Kolor] = "niebieski"))

Nauczony doświadczeniem z pułapką 1. sprawdzasz teraz zawartość paska formuły częściej
niż poprzednio, zwracając szczególną uwagę na teksty w cudzysłowach. W tym przypadku
problem jest oczywisty i łatwo go zauważysz. Gdy usunąłeś zaznaczenie koloru czarnego,
edytor Power Query przyjął błędne założenie, że zaznaczyłeś kolor niebieski. W efekcie po
przefiltrowaniu tabeli zostaną w niej tylko niebieskie produkty. Gdybyś nie zwrócił uwagi
na pasek formuły, analizowałbyś tylko niebieskie produkty, a nie wszystkie oprócz czarnych.
Poprawienie formuły na tym etapie jest proste. Zastąp warunek = "niebieski" warunkiem
<> "czarny", tak jak niżej:
= Table.SelectRows(#"Zmieniono typ", each ([Kolor] <> "czarny"))
Zamiast modyfikować formułę, możesz błędny warunek poprawić, wykonując kroki 9. i 10.
9. Usuń z panelu Zastosowane kroki krok Przefiltrowano wiersze, a następnie kliknij ikonę filtru
w nagłówku kolumny Kolor. Zdefiniujesz filtr w inny sposób.
10. W panelu filtru kliknij polecenia Filtry tekstu i Nie równa się. W oknie Filtrowanie wierszy,
które się pojawi, wpisz w polu obok listy nie równa się tekst czarny i kliknij OK.
Wskazówka. Jeżeli nie lubisz wyrażeń warunkowych, opisanych w kroku 8., użyj polecenia
Filtry tekstu, tak jak w krokach 9. i 10. W ten sposób całkowicie unikniesz pułapki. Zawsze
lepiej używać tego polecenia, niż zaznaczać wartości w panelu filtru.
Działanie warunków w filtrach

W tym momencie zapewne przestałeś ufać filtrom w edytorze Power Query i ogarnęły Cię obawy,
czy w licznych utworzonych do tej pory zapytaniach niechcący nie wpadłeś w 3. pułapkę. Jak często
stosowałeś ikonę filtru użytą w tym przykładzie? Na szczęście w większości przypadków, gdy usuwa
się zaznaczenia wartości w panelu filtru, tworzone warunki są zgodne z oczekiwaniami i nie trzeba
obawiać się pomyłek, takich jak w ćwiczeniu 10.2.
Poniżej opisane są dwie zasady, według których edytor Power Query generuje warunki podczas
zaznaczania wartości w panelu filtru.
 Jeżeli liczba zaznaczonych wartości jest mniejsza lub równa liczbie niezaznaczonych
wartości, wtedy edytor generuje warunki zawierające znaki równości i zaznaczone
wartości.
 Jeżeli liczba zaznaczonych wartości jest większa od liczby niezaznaczonych wartości, wtedy
edytor generuje warunki zawierające znaki nierówności i niezaznaczone wartości.
255
4650570396d9eb2765da56c12eb840b5
4
Sprawdźmy powyższe reguły na przykładzie prostej kolumny zawierającej liczby od 1 do 6.

1. Utwórz w Excelu nowy arkusz lub w Power BI nowy raport, uruchom edytor Power Query
i utwórz puste zapytanie,
2. W pasku formuły wpisz następujący kod:
= {1..6}
3. W karcie Przekształć kliknij ikonę Do tabeli. W oknie, które się pojawi, kliknij przycisk OK.
4. W nagłówku kolumny Column1 kliknij ikonę filtru. Pojawi się panel filtru.
5. Usuń zaznaczenie wartości 1 i kliknij OK. Wartość ta zostanie poprawnie usunięta z tabeli.
Zwróć uwagę, że w pasku formuły pojawi się następujący kod:
= Table.SelectRows(#"Przekonwertowane na tabelę", each ([Column1] <> 1))
6. Ponownie kliknij ikonę filtru i usuń zaznaczenie wartości 1 i 2. Efekt będzie zgodny
z oczekiwaniami. Pasek formuły będzie zawierał poniższy kod:
= Table.SelectRows(#"Przekonwertowane na tabelę", each ([Column1] <> 1 and [Column1]
<> 2))
7. Jeszcze raz kliknij ikonę filtru i usuń zaznaczenie wartości 1, 2 i 3. Efekt dalej będzie
poprawny. W panelu podglądu będą widoczne tylko wartości 4, 5 i 6. Natomiast w formule
będą użyte znaki równości i wartości, których nie zaznaczyłeś w panelu filtru:
= Table.SelectRows(#"Przekonwertowane na tabelę", each ([Column1] = 4 or [Column1] = 5
or [Column1] = 6))
Jednak poprawny jest kod zawierający znaki nierówności i wartości, których nie zaznaczyłeś.
Zatem formuła powinna wyglądać tak:
= Table.SelectRows(#"Przekonwertowane na tabelę", each ([Column1] <> 1 and [Column1] <>
2 and [Column1] <> 3))
Dlaczego warunki zawierające znaki równości i zaznaczone wartości są takie niebezpieczne?
Wyobraź sobie, że w przyszłości w kolumnie pojawią się dodatkowo liczby 7, 8, 9 i 10. W kroku 7.
utworzyłeś filtr odrzucający liczby 1, 2 i 3. Jeżeli w filtrze będą użyte znaki równości i zaznaczone
wartości, po odświeżeniu raportu liczby 7, 8, 9 i 10 zostaną odrzucone.
Powyższy przykład jest bardzo prosty, ale daje wyobrażenie, co się może stać, kiedy danych
będzie dużo. Taka jest istota pułapki 3.: w panelu podglądu widoczny jest tylko fragment danych.
Przykładowo w arkuszu użytym w ćwiczeniu 10.2 w kolumnie Kolor znajdowały się również inne
kolory oprócz czarnego i niebieskiego, ale w panelu podglądu były widoczne tylko te dwa. Gdy
usunąłeś zaznaczenie koloru czarnego, liczby wartości zaznaczonych i niezaznaczonych były sobie
równe i w warunkach filtru zostały użyte znaki równości.
Jedną z najczęściej wykonywanych operacji narażonych na pułapkę 3. jest wyszukiwanie
wartości w panelu filtru. Zazwyczaj wyszukiwanie stosuje się, gdy lista wartości jest długa. Zamiast ją
przewijać, można wyszukać pożądane wartości, wpisując ich nazwy w polu wyszukiwania. Usunięcie
zaznaczeń przy wyszukiwanych wartościach zawsze powoduje utworzenie warunków zawierających
znaki równości, co w przyszłości może być źródłem problemów.
256
4650570396d9eb2765da56c12eb840b5
4
Ćwiczenie 10.2. Część II. Wyszukiwanie wartości w panelu filtru

W tym ćwiczeniu wykorzystasz plik R10-01.xlsx, ten sam co w ćwiczeniu 10.1 i części I ćwiczenia 10.2.
1. Utwórz w Excelu nowy arkusz lub w Power BI nowy raport.
4. Aby uniknąć 2. pułapki, usuń z panelu Zastosowane kroki krok Zmieniono typ, następnie
w kolumnie Data ustaw typ danych Data, a w kolumnie Przychód typ Liczba dziesiętna.
Załóżmy, że chcesz odrzucić wszystkie wiersze zawierające w kolumnie Miasto wartość Bochnia.
5. Kliknij ikonę filtru w nagłówku kolumny Miasto. Pojawi się panel filtru. Ponieważ lista miast
jest długa i zaczyna się od litery A, musiałbyś ją przewinąć do litery B. Zamiast tego jednak
możesz użyć pola wyszukiwania. Ogranicz więc listę miast do tych, które zawierają litery
„bo”. W tym celu wpisz je w polu wyszukiwania. W panelu pojawi się kilka miast, wśród
nich, blisko początku listy, będzie widoczna Bochnia, zatem możesz łatwo usunąć jej
zaznaczenie. Niestety, w pasku formuły pojawi się następujący kod:
= Table.SelectRows(#"Zmieniono typ", each ([Miasto] = "Bobolice" or [Miasto] =
"Boguchwała" or [Miasto] = "Bolesławiec" or [Miasto] = "Kluczbork" or [Miasto] =
"Luboń" or [Miasto] = "Lębork" or [Miasto] = "Malbork" or [Miasto] = "Oborniki" or
[Miasto] = "Oborniki Śląskie" or [Miasto] = "Więcbork" or [Miasto] = "Świebodzice"))
W efekcie wpadniesz w pułapkę 3., ponieważ raport będzie obejmował miasta z wyjątkiem
Bochni oraz innych miast zawierających litery bo w nazwie.
6. Aby rozwiązać problem, wpisz następującą formułę:
= Table.SelectRows(#"Zmieniono typ", each ([Miasto] <> "Bochnia"))

Jak widzisz, opisane tu operacje są bardzo popularne, więc możesz się spodziewać, że często
będziesz wpadał w pułapkę 3. Najlepszym sposobem jej uniknięcia jest korzystanie z polecenia Filtry
tekstu zamiast z pola wyszukiwania. Jeżeli jednak musisz korzystać z tego pola, sprawdzaj zawartość
paska formuły i koryguj kod odpowiednio do potrzeb.
Pułapka 4. Zmiana kolejności kolumn

Pułapka 4. pojawia się podczas zmieniania kolejności kolumn. Zazwyczaj kolejność większości
kolumn nie jest istotna i przestawia się tylko kilka z nich, np. zamienia się miejscami dwie wybrane
kolumny lub nową niestandardową kolumnę przynosi się z prawego brzegu tabeli w określone miejsce.
Podczas zmieniania kolejności kolumn w pasku formuły tworzony jest kod zawierający funkcję
Table.ReorderColumns i nazwy wszystkich kolumn. Z tego powodu zapytanie jest bardziej podatne
na błędy i może w przyszłości uniemożliwiać odświeżanie raportu, np. po przemianowaniu lub
usunięciu kliku kolumn z danych źródłowych.
Często z panelu Zastosowane kroki można całkowicie usunąć krok zmieniający kolejność
kolumn. Przykładowo po utworzeniu kolumny niestandardowej wykonującej obliczenia na danych
zawartych w innej kolumnie obie kolumny trzeba umieszczać obok siebie, aby zweryfikować
257
4650570396d9eb2765da56c12eb840b5
4
poprawność kodu. W takich sytuacjach, po utwierdzeniu się, że kod jest dobry, zaleca się usunięcie
kroku zmieniającego kolejność kolumn, aby zmniejszyć prawdopodobieństwo wystąpienia błędu
podczas odświeżania raportu w przyszłości.
Czasami jednak zmiana kolejności kolumn jest ważna, gdy np. trzeba kontrolować kolejność pól
pokazywanych w tabeli przestawnej w Excelu lub kolumn zapytania załadowanego do arkusza.
Oprócz tego jest kilka specyficznych przypadków wymagających umieszczenia kolumn w zapytaniu
w określonej kolejności. Przykładowo w rozdziale 4., „Łączenie niezgodnych tabel”, w ćwiczeniu 4.4
umieściłeś kolumnę wyliczeniową na początku tabeli, abyś ją potem przetransponować i zamienić
na nagłówki kolumn.
Jeżeli kolejność kolumn jest ważna, zmieniaj ją dopiero wtedy, gdy zapytanie będzie zawierało
wyłącznie kolumny wykorzystywane w raporcie. (Więcej o wybieraniu kolumn dowiesz się
w podrozdziale poświęconym pułapce 5.). Złą praktyką jest ładowanie tabeli zawierającej setki
kolumn, zmienianie ich kolejności, a następnie usuwanie tych, które są niepotrzebne. Zapytanie
będzie bardziej stabilne, jeżeli najpierw wybierzesz kilkanaście kolumn, a potem zmienisz ich kolejność.
W ćwiczeniu 10.3 dowiesz się, jak można zmieniać kolejność kolumn bez odwoływania się do ich nazw.
Ćwiczenie 10.3. Część I. Zmiana kolejności wybranych kolumn

W tym ćwiczeniu wykorzystasz ten sam arkusz, co w ćwiczeniu 10.1, zawierający przychody firmy
Światowi Importerzy. Wykonasz prostą zmianę kolejności kolumn Miasto i Przychód.
4. Usuń z panelu Zastosowane kroki krok Zmieniono typ.
RYSUNEK 10.6. Przemieszczenie kolumn Miasto i Przychód w edytorze Power Query
258
4650570396d9eb2765da56c12eb840b5
4

= Table.ReorderColumns(#"Nagłówki o podwyższonym poziomie",{"Data", "Miasto",
"Przychód", "Kolor", "Kategoria dostawcy", "Nazwa dostawcy", "Kategoria klienta",
"Losowa kolumna 1", "Losowa kolumna 2"})
Oczywiście, jeżeli zostaną zmienione nazwy kolumn Losowa kolumna 1 i Losowa kolumna 2,
wtedy takie zapytanie nie wykona się. Czy można zmienić formułę tak, aby odwoływała się
tylko do kolumn Miasto i Przychód? Tak, jest to możliwe.
6. Usuń z formuły następujący fragment:
{"Data", "Miasto", "Przychód", "Kolor", "Kategoria dostawcy", "Nazwa dostawcy",
"Kategoria klienta", "Losowa kolumna 1", "Losowa kolumna 2"}
i zastąp go poniższą funkcją zwracającą tę samą listę nazw kolumn:
List.InsertRange(List.Difference(Table.ColumnNames(#"Nagłówki o podwyższonym poziomie"),
{"Miasto", "Przychód"}), 1, {"Miasto", "Przychód"})
Ostateczna formuła przyjmie następującą postać:
= Table.ReorderColumns(#"Nagłówki o podwyższonym poziomie", List.InsertRange(List.
Difference(Table.ColumnNames(#"Nagłówki o podwyższonym poziomie"), {"Miasto",
"Przychód"}), 1, {"Miasto", "Przychód"}))
Przyjrzyjmy się teraz, jak za pomocą kombinacji funkcji List.InsertRange, List.Difference
i Table.ColumnNames można osiągnąć zamierzony cel i uzyskać tę samą, co poprzednio, listę kolumn,
ale odwołując się tylko do nazw Miasto i Przychód.
Funkcja List.InsertRange umieszcza podaną w argumencie listę wewnątrz innej listy na
określonym miejscu numerowanym od zera. Przykładowo poniższa formuła umieszcza kolumny
o nazwach Miasto i Przychód na drugim i trzecim miejscu listy A:
List.InsertRange(A, 1, {"Miasto", "Przychód"}
W poprzedniej formule funkcja List.InsertRange jest umieszczona w argumencie funkcji
Table.ReorderColumns. Jeżeli lista A zawiera nazwy wszystkich kolumn oprócz Miasto i Przychód,
wtedy za pomocą funkcji List.InsertRange można utworzyć listę nazw ułożonych w żądanej
kolejności. W tym momencie do akcji wkracza funkcja List.Difference zwracająca listę elementów,
które znajdują się w liście podanej w pierwszym argumencie, ale nie ma ich w liście podanej
w drugim argumencie (jest to tzw. łączenie left anti join dwóch list). Jeżeli B jest listą zawierającą
nazwy wszystkich kolumn, wtedy poniższa funkcja zwróci wszystkie nazwy oprócz Miasto i Przychód:
A = List.Difference(B, {"Miasto", "Przychód"})
Jeżeli teraz zamiast listy B użyjesz funkcji Table.ColumnNames, tj.:
B = Table.ColumnNames(#"Nagłówki o podwyższonym poziomie")
będziesz mógł zebrać wszystkie fragmenty w jedną pokazaną niżej formułę (zapisaną w kilku
wierszach, aby była bardziej czytelna):
= Table.ReorderColumns(
List.InsertRange(
List.Difference(
Table.ColumnNames(#"Nagłówki o podwyższonym poziomie"),
{"Miasto", "Przychód"}
),
1,
{"Miasto", "Przychód"}
)
)
259
4650570396d9eb2765da56c12eb840b5
4
Ćwiczenie 10.3.
Część II. Niestandardowa funkcja FnZmianaKolejnościKolumn
Technika opisana w części I ćwiczenia przydaje się bardzo często. Aby ułatwić sobie pracę, możesz
utworzyć funkcję niestandardową wykonującą przekształcenia opisane w kroku 7. W tym celu
wykonaj następujące kroki.
1. Utwórz puste zapytanie, a następnie w zaawansowanym edytorze wpisz następujący kod:
= (tabela as table, przemieszczaneKolumny as list, miejsce as number) as table =>

Table.ReorderColumns(
tabela,
List.InsertRange(
List.Difference(
Table.ColumnNames(tabela),
przemieszczaneKolumny
),
miejsce,
przemieszczaneKolumny
)
)
2. Zmień nazwę niestandardowej funkcji na FnZmianaKolejnościKolumn.
3. W panelu Zastosowane kroki usuń krok Zmieniono kolejność kolumn. Następnie utwórz
nowy krok, klikając ikonę fx obok paska formuły, i wpisz następujący kod:
= FnZmianaKolejnościKolumn(#"Nagłówki o podwyższonym poziomie", {"Miasto", "Przychód"}, 1)
Uzyskany efekt będzie taki sam jak w kroku 5. Jak widzisz, funkcja FnZmianaKolejnościKolumn
jest prosta w użyciu. Jej argumentami są tabela, lista kolumn przeznaczonych do przemieszczenia
oraz numerowane od zera miejsce docelowe. Funkcja działa stabilnie, ponieważ nie odwołuje się
do żadnych innych kolumn.
Zobacz też. Istnieją inne sposoby użycia funkcji Table.ReorderColumns pozwalające uniknąć
problemów z odświeżaniem raportów. Możesz wykorzystać trzeci argument funkcji, aby nie
uwzględniała brakujących pól lub zamiast nich stosowała wartości null. Unika się w ten
sposób problemów z odświeżaniem raportów, ale mogą pojawiać się nieoczekiwane efekty.
Więcej informacji na ten temat znajdziesz na stronie https://datachant.com/2017/01/18/
power-bi-pitfall-4.
Pułapka 5. Usuwanie i wybieranie kolumn

Pułapka 5. dotyczy bardzo popularnej operacji usuwania kolumn. Choć usunięcie niepotrzebnych
kolumn ma kluczowe znaczenie w skutecznym tworzeniu raportów (mniejsza liczba kolumn
oznacza mniej zajętej pamięci i mniejszy plik), to każdorazowe usunięcie kolumny zmniejsza
stabilność zapytania i naraża raporty na problemy z odświeżaniem w przyszłości.
260
4650570396d9eb2765da56c12eb840b5
4
Za każdym razem, gdy usuwasz kolumnę, narażasz się na ryzyko problemów z odświeżaniem
raportów, gdyby kolumna ta znikła z danych źródłowych. Czy porozumiałeś się z autorem danych
źródłowych? Z tych samych powodów, co Ty, może on uznać, że niektóre kolumny nie są ważne
i postanowi usunąć je ze źródła.
Aby zmniejszyć zagrożenie problemami z odświeżaniem, stosuj prostą praktykę: skupiaj się na
kolumnach, które mają pozostać, a nie tych, które mają być usunięte. Edytor Power Query oferuje
przekształcenia do usuwania i zachowywania kolumn. Choć prościej zaznaczyć kolumnę i nacisnąć
klawisz Delete, zazwyczaj lepiej wybrać kolumny, która mają być zachowane. Ćwiczenie 10.4
ilustruje ten proces na przykładzie kolumn Losowa kolumna 1 i Losowa kolumna 2 zawierających
dane firmy Światowi Importerzy, wykorzystanie w ćwiczeniu 10.1.
Ćwiczenie 10.4. Usunięcie niepotrzebnych kolumn

4. Usuń z panelu Zastosowane kroki krok Zmieniono typ.
5. Usuń kolumny Losowa kolumna 1 i Losowa kolumna 2. W tym celu zaznacz je, a następnie
naciśnij klawisz Delete.
6. Zwróć uwagę, że w pasku formuły pojawi się następujący kod:
= Table.RemoveColumns(#"Nagłówki o podwyższonym poziomie",{"Losowa kolumna 1", "Losowa

kolumna 2"})
Jeżeli z tabeli źródłowej zostaną usunięte powyższe kolumny, raport się nie odświeży.
W kolejnym kroku usuniesz te kolumny w inny sposób, dzięki czemu zapytanie będzie
bardziej stabilne.
7. W panelu Zastosowane kroki usuń ostatni krok, a następnie w karcie Strona główna kliknij
ikonę Wybieranie kolumn. W oknie, które się pojawi, usuń zaznaczenia Losowa kolumna 1
i Losowa kolumna 2 i zamknij okno. Zwróć uwagę, że w pasku formuły pojawi się
następujący kod:
= Table.SelectColumns(#"Nagłówki o podwyższonym poziomie",{"Data", "Kolor", "Kategoria
dostawcy", "Nazwa dostawcy", "Kategoria klienta", "Miasto", "Przychód"})
Pomijanie brakujących kolumn

Czasami zdarza się, że liczba kolumn, które należy zachować, jest bardzo duża i ryzyko usunięcia
kilku z nich jest mniejsze niż wybranie pozostałych. Często nie ma znaczenia, czy korzysta się
z przekształcenia usuwania, czy wybierania kolumn; dzieje się tak szczególnie wtedy, gdy zewnętrzne
źródło danych często się zmienia. Aby uniknąć błędów z odświeżaniem raportów, można wykorzystać
funkcje RemoveColumns lub Table.SelectColumns z opcjonalnym trzecim argumentem, przy użyciu
którego błędy będą ignorowane i raporty odświeżane. W tym argumencie można umieścić wartość
MissingField.Ignore lub MissingField.UseNull.
261
4650570396d9eb2765da56c12eb840b5
4
Wartość MissingField.Ignore powoduje, że funkcja pomija brakujące kolumny, a Missing

Field.UseNull, że pojawiają się kolumny o żądanych nazwach, ale zawierające wartości null.
Bardziej praktyczne jest stosowanie funkcji Table.SelectColumns z wartością MissingField.UseNull,
ponieważ daje ona pewność, że w raporcie zostaną uwzględnione wskazane kolumny. Jednak użycie
każdej z tych wartości może spowodować pojawienie się trudnych do wykrycia błędów. Dlatego
mniejszym złem są problemy z odświeżaniem raportu niż umieszczanie w nim nieoczekiwanych
wyników będącym efektem użycia trzeciego argumentu funkcji.
Wybieranie i usuwanie kolumn znajdujących się w określonych miejscach

Zazwyczaj bezpieczniejszą operacją jest usuwanie i wybieranie kolumn znajdujących się na
ustalonych pozycjach w tabeli, a nie o określonych nazwach. Za pomocą funkcji Table.ColumnNames
zwracającej listę nazw wszystkich kolumn oraz funkcji List.Range zwracającej fragment listy można
uzyskać zestaw nazw kolumn znajdujących się w określonych miejscach.
Obie poniższe formuły usuwają pierwszą kolumnę tabeli:
= Table.RemoveColumns(Źródło, List.First(Table.ColumnNames(Źródło)))
= Table.RemoveColumns(Źródło, Table.ColumnNames(Źródło){0})
Za pomocą funkcji List.FirstN można usuwać pierwsze dwie kolumny:
= Table.RemoveColumns(Źródło, List.FirstN(Table.ColumnNames(Źródło), 2))
Poniższa formuła usuwa ostatnią kolumnę:
= Table.RemoveColumns(Źródło, List.Last(Table.ColumnNames(Źródło), 1))
Natomiast ta formuła usuwa wszystkie kolumny oprócz drugiej i trzeciej:
= Table.SelectColumns(Źródło, List.Range(Table.ColumnNames(Źródło), 1, 2))
Funkcja List.Range zwraca fragment listy podanej w argumencie, rozpoczynający się od podanej
pozycji (numerowanej od zera) i o określonej długości. Formuła List.Range(Table.ColumnNames
(Źródło), 1, 2) zwraca nazwy dwóch kolejnych kolumn tabeli Źródło, przy czym pierwsza ma
indeks 1, tj. znajduje się na drugim miejscu.
Można również wybierać każdą kolumnę osobno. Poniższa formuła jest równoważna pokazanej
wcześniej:
= Table.SelectColumns(Źródło, {Table.ColumnNames(Źródło){0}, Table.ColumnNames(Źródło){1}})
Kod ten przydaje się w sytuacji, gdy trzeba wybierać kolumny, które nie sąsiadują ze sobą.
Poniższa formuła usuwa z tabeli danych firmy Światowi Importerzy kolumny Losowa kolumna 1
i Losowa kolumna 2 przy założeniu, że są to kolumny siódma i ósma (tj. o indeksach 6 i 7).
= Table.RemoveColumns(#"Nagłówki o podwyższonym poziomie", {Table.ColumnNames(#"Nagłówki
o podwyższonym poziomie"){6}, Table.ColumnNames(#"Nagłówki o podwyższonym poziomie"){7}})
Wybieranie i usuwanie kolumn o określonych nazwach

W języku M można wybierać i usuwać kolumny na mnóstwo sposobów. Poniżej przedstawione są
dwa najprostsze przykłady. Poniższa formuła wykorzystuje funkcję List.Select do usunięcia
kolumn zawierających w nazwach słowo „Losowa”:
= Table.RemoveColumns(#"Nagłówki o podwyższonym poziomie", List.Select(Table.ColumnNames
(#"Nagłówki o podwyższonym poziomie"), each Text.Contains(_, "Losowa")))
262
4650570396d9eb2765da56c12eb840b5
4
Następna formuła wykorzystuje funkcję Table.SelectColumns i odwrotną logikę (tj. wybiera

kolumny, których nazwy nie zawierają zadanego ciągu) do osiągnięcia tego samego celu:
= Table.SelectColumns(#"Nagłówki o podwyższonym poziomie", List.Select(Table.ColumnNames
(#"Nagłówki o podwyższonym poziomie"), each not Text.Contains(_, "Losowa")))
Pułapka 6. Zmiana nazw kolumn

Innym często wykonywanym krokiem jest zmiana nazw kolumn. Nazwy zmienia się, aby raporty
były bardziej czytelne. Jednak każda taka modyfikacja zwiększa ryzyko wystąpienia problemów
z odświeżaniem raportów. Stosując techniki opisane w podrozdziale „Pułapka 5. Usuwanie i wybieranie
kolumn”, możesz tworzyć bardziej stabilne zapytania, których formuły nie odwołują się do kolumn
za pomocą ich nazw.
Przyjrzyjmy się temu problemowi na przykładzie danych firmy Światowi Importerzy i przeanalizujmy
różne sposoby zmieniania nazw kolumn. Przyjmijmy, że nazwy wszystkich kolumn zaczynające się
od „Losowa kolumna” zmienią się w przyszłości w samym źródle. Zadanie polega na zmianie nazw
tych kolumn na Czynnik 1, Czynnik 2 itd., tak jak na rysunku 10.7.
RYSUNEK 10.7. Zadanie polega na zmianie nazw kolumn bez odwoływania się do nich za pomocą nazw
Ćwiczenie 10.5. Zmiana nazw losowych kolumn

W tym ćwiczeniu wykorzystasz skoroszyt R10-05.xlsx zawierający podsumowanie zamówień
fikcyjnej firmy Światowi Importerzy.
263
4650570396d9eb2765da56c12eb840b5
4
4. W panelu Zastosowane kroki usuń krok Zmieniono typ. W panelu podglądu pojawi się
tabela zawierająca siedem losowych kolumn. W tym ćwiczeniu poznasz kilka zasobów
zmiany ich nazw.
Ręcznie zmień nazwy Losowa kolumna 1 i Losowa kolumna 2 odpowiednio na Czynnik 1
i Czynnik 2. W pasku formuły pojawi się następujący kod:
= Table.RenameColumns(#"Nagłówki o podwyższonym poziomie",{{"Losowa kolumna 1",
"Czynnik 1"}, {"Losowa kolumna 2", "Czynnik 2"}})
Gdy w przyszłości w tabeli źródłowej nie będzie jednej z powyższych kolumn, raport się
nie odświeży.
Załóżmy, że autor danych powiadomił Cię, że zamierza w przyszłości zmienić nazwy kolumn,
ale będą one umieszczone w tabeli tej samej kolejności, co dotychczas. Możesz się zatem odwoływać
do tych kolumn, wykorzystując ich pozycje w tabeli. Poniżej przedstawiony jest przykład, jak można
zmienić nazwy pierwszych dwóch kolumn:
= Table.RenameColumns(#"Nagłówki o podwyższonym poziomie", {{Table.ColumnNames(#"Nagłówki
o podwyższonym poziomie"){6}, "Czynnik 1"}, {Table.ColumnNames(#"Nagłówki o podwyższonym
poziomie"){7}, "Czynnik 2"}})
Niestandardowa funkcja FnZmianaNazwWedługIndeksów

Aby zmienić nazwy kolumn, odwołując się do ich miejsc w tabeli, musisz napisać niestandardową
funkcję. Za jej pomocą będziesz mógł zmieniać nazwy wielu kolumn bez konieczności podawania
starych i nowych nazw. W tym podpunkcie rozdziału dowiesz się, jak napisać taką funkcję.
Załóżmy, że funkcja jest już gotowa i nazywa się FnZmianaNazwWedługIndeksów. Aby zmienić
nazwy kolumn, tak jak w kroku 4., wystarczy wpisać następujący kod:
= FnZmianaNazwWedługIndeksów(#"Nagłówki o podwyższonym poziomie", {"Czynnik 1", "Czynnik 2"}, {6, 7})
Sposób wykorzystujący funkcję niestandardową jest skalowalny, ponieważ pozwala zmieniać
nazwy wielu kolumn jednocześnie, a nawet odczytywać stare i nowe nazwy z zewnętrznych list.
Ponadto w argumencie funkcji można umieścić zakres indeksów. Aby np. zmienić bez użycia funkcji
nazwy kolumn od czwartej do dziesiątej na Czynnik 1, Czynnik 2, …, Czynnik 7, musiałbyś zastosować
skomplikowane przekształcenia.
Zacznijmy od nieefektywnej metody polegającej na wpisaniu mnóstwa kodu zawierającego
indeksy i nowe nazwy kolumn, takiego jak niżej.
= Table.RenameColumns(
{
{Table.ColumnNames(#"Nagłówki o podwyższonym poziomie"){6}, "Czynnik 1"},
{Table.ColumnNames(#"Nagłówki o podwyższonym poziomie"){12}, "Czynnik 7"}
}
)
264
4650570396d9eb2765da56c12eb840b5
4
Aby kod nie był tak skomplikowany, wykorzystaj inteligentną funkcję, taką jak niżej:
= FnZmianaNazwWedługIndeksów(
List.Transform(
{1..7},
each "Czynnik " & Text.From(_)
),
{6..12}
)
Drugim argumentem funkcji jest lista tworzona dynamicznie za pomocą funkcji List.Transform,
której pierwszym argumentem jest lista indeksów od 1 do 7, a zwracanym wynikiem przekształcona
lista tekstów składających się z prefiksu "Czynnik " i wartości indeksu. Trzecim argumentem funkcji
FnZmianaNazwWedługIndeksów jest lista indeksów kolumn (od 6 do 12), których nazwy mają być
zmienione. Kod funkcji FnZmianaNazwWedługIndeksów jest następujący:
(Źródło as table, NoweNazwyKolumn as list, Indeksy as list) =>
let
StareNazwyKolumn = List.Transform(Indeksy, each Table.ColumnNames(Źródło){_}),
NowaLista = List.Zip({ StareNazwyKolumn, NoweNazwyKolumn}),
#"Zmieniono nazwy kolumn" = Table.RenameColumns(Źródło, NowaLista)
in
#"Zmieniono nazwy kolumn"
Przeanalizujmy powyższą funkcję krok po kroku. Argument Źródło jest tabelą, której kolumny
mają być przemianowane. NoweNazwyKolumn jest listą nowych nazw, a Indeksy listą indeksów
kolumn. W pierwszym wierszu wyrażenia let odczytywana jest lista aktualnych nazw kolumn
o zadanych indeksach:
StareNazwyKolumn = List.Transform(Indeksy, each Table.ColumnNames(Źródło){_}),
W następnym wierszu za pomocą funkcji List.Zip jest tworzona lista zagnieżdżonych list,
z których każda zawiera dwa elementy: starą i nową nazwę kolumny o zadanym indeksie:
NowaLista = List.Zip({StareNazwyKolumn, NoweNazwyKolumn}),
I tak poniższa formuła:
List.Zip({"a","b","c"}, {"A", "B", "C"}}
zwraca następującą listę zagnieżdżonych list:

{{"a", "A"}, {"b", "B"}, {"c", "C"}}
Listę w powyższej postaci należy umieścić w drugim argumencie funkcji Table.RenameColumns
umieszczonej w trzecim wierszu wyrażenia let:
#"Zmieniono nazwy kolumn" = Table.RenameColumns(Źródło, NowaLista)
Funkcja Table.TransformColumnNames
Nazwy kolumn można zmienić w jeszcze inny sposób. Jak pamiętasz, w rozdziale 4. zmieniłeś nazwy
wszystkich kolumn za pomocą funkcji Table.TransformColumnNames. Wszystkie znaki podkreślenia
zastąpiłeś spacjami, a ponadto zamieniłeś pierwsze litery słów na wielkie. Tę funkcję możesz również
wykorzystać w tym przypadku w następującej ogólnej formule:
= Table.TransformColumnNames(#"Nagłówki o podwyższonym poziomie", each Text.Replace(_, "Losowa
kolumna", "Czynnik"))
265
4650570396d9eb2765da56c12eb840b5
4
Sposób ma tę zaletę, że poprawnie zmienia nazwy kolumn nawet wtedy, gdy zostaną umieszczone
w tabeli źródłowej w innej kolejności. Jednak zachowaj ostrożność, stosując tę metodę, abyś niechcący
nie przemianował kolumn, które nie powinny być zmienione.
Wskazówka. W większości przypadków wystarczy prosta zmiana nazw kolumn, tak jak to
robiłeś do tej pory. Nie komplikuj tego, co jest proste.
Pułapka 7. Dzielenie kolumn

Pułapka 7. jest równie niebezpieczna jak 3. (filtrowanie danych), ponieważ może skutkować
uzyskaniem błędnych wyników w raportach. Niebezpieczeństwo pojawia się podczas stosowania
przekształcenia Podziel kolumny według ogranicznika w sytuacji, gdy liczba wartości oddzielonych
ogranicznikami jest zmienna.
Przekształcenie Podziel kolumny według ogranicznika stosuje się zazwyczaj do wykonania dwóch
rodzajów operacji.
 Prostej, polegającej na podzieleniu jednej kolumny na kilka nowych kolumn. Przykładowo
często dzieli się kolumnę zawierającą daty i godziny na osobne kolumny, z których jedna
zawiera tylko daty, a druga tylko godziny. Innym przypadkiem jest dzielenie kolumny
z imieniem i nazwiskiem na kolumny zawierające tylko imiona i tylko nazwiska.
Domyślnie za pomocą tej funkcjonalności kolumny dzieli się na nowe kolumny.
 Zaawansowanej, polegającej na podzieleniu kolumny zawierającej liczne wartości
oddzielone przecinkami lub innymi ogranicznikami, na wiersze. Jest to niezwykle
przydatna operacja umożliwiającą tworzenie tabel, w których każda wartość jest
skojarzona z odpowiednim atrybutem. Jak pokazuje rysunek 10.8, można w ten sposób
utworzyć tabelę zawierającą kody produktów i ich kolory, aby następnie zliczyć, ile jest
produktów poszczególnych kolorów.
RYSUNEK 10.8. Po podzieleniu wartości oddzielonych przecinkami w kolumnie Kolor można określić,
ile jest produktów w poszczególnych kolorach
266
4650570396d9eb2765da56c12eb840b5
4
W rozdziale 2, w ćwiczeniu 2.8 przekształcałeś tabelę produktów Fabryka Przygód. Podzieliłeś

kolumnę Kolory, aby policzyć, ile jest produktów w poszczególnych kolorach. Jak pamiętasz,
kolumnę podzieliłeś na wiersze. W następnym ćwiczeniu zobaczysz, co się może stać, gdy kolumnę
podzielisz na kolumny, a nie na wiersze.
Pułapka 7., o czym przekonasz się w ćwiczeniu 10.6, pojawia się podczas dzielenia wartości
odseparowanych ogranicznikami bez użycia zaawansowanej (i do tego ukrytej) opcji podziału
na wiersze. Jeżeli nie wybierzesz tej opcji, kolumna zostanie domyślnie podzielona na kolumny,
przez co po załadowaniu nowych danych do raportu mogą zostać utracone cenne informacje.
Ćwiczenie 10.6. Niewłaściwy podział kolumny

Wykonasz ćwiczenie 2.8, ale tym razem sprawdzisz, co się stanie, gdy użyjesz niewłaściwej opcji
podziału kolumny na kolumny. Ćwiczenie to demonstruje wynikające stąd ryzyko i pokazuje,
jak łatwo można nieświadomie wpaść w pułapkę. Wykorzystasz w nim skoroszyt R10-06.xlsx
zawierający kody produktów, ich średnie koszty, średnie ceny oraz kolory (oddzielone przecinkami).
Utworzysz raport pokazujący, ile jest produktów w poszczególnych kolorach (patrz rysunek 10.8).
3. W oknie Nawigator zaznacz Produkty i kliknij przycisk Przekształć dane.
5. W panelu Zapytania kliknij prawym przyciskiem myszy zapytanie Produkty i wybierz
polecenie Odwołanie. Twoim celem jest utworzenie nowej tabeli zawierającej kody
produktów i ich kolory.
6. Zmień nazwę nowego zapytania na Produkty i kolory.
7. W karcie Strona główna kliknij ikonę Wybieranie kolumn. W oknie o tej samej nazwie, które
się pojawi, zaznacz kolumny Kod produktu i Kolory. Gdy klikniesz OK, z tabeli zostaną
usunięte wszystkie kolumny oprócz powyższych.
8. Zaznacz kolumnę Kolory, a następnie w karcie Przekształć kliknij ikonę Podziel kolumny
i wybierz polecenie Według ogranicznika. Zwróć uwagę, że w oknie Dzielenie kolumny
według ogranicznika, które się pojawi, domyślnie jako ogranicznik jest wybrany przecinek
i zaznaczona opcja Każde wystąpienie ogranicznika, tak jak na rysunku 10.9. Niestety,
domyślnie po zamknięciu okna kolumny zostaną podzielone na kolumny, a nie na wiersze.
Aby podzielić kolumny na wiersze, musiałbyś rozwinąć sekcję Opcje zaawansowane
i zaznaczyć opcję Podziel na wiersze, tak jak w ćwiczeniu 2.8.
W tym ćwiczeniu pozostaw domyślne ustawienie, żeby przekonać się o jego skutkach.
9. Zwróć uwagę, że kolumna Kolory zostanie podzielona na Kolory.1 i Kolory.2. W panelu
Zastosowane kroki kliknij krok Podzielono kolumnę według ogranicznika. W pasku formuły
= Table.SplitColumn(#"Usunięto inne kolumny", "Kolory", Splitter.SplitTextBy
Delimiter(",", QuoteStyle.Csv), {"Kolory.1", "Kolory.2"})
267
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 10.9. W oknie Dzielenie kolumny według ogranicznika w sekcji Opcje zaawansowane
ukryta jest opcja dzielenia kolumny na wiersze
Formuła ta powoduje podzielenie kolumny Kolory na dokładnie dwie kolumny, o czym się
za chwilę przekonasz.
10. Ponieważ Twoim celem jest utworzenie tabeli kodów produktów i ich kolorów,
musisz zdekomponować tabelę. Zaznacz kolumnę Kod produktu.
11. W karcie Przekształć rozwiń ikonę Anuluj przestawienie kolumn i wybierz polecenie Anuluj
przestawienie innych kolumn. Kolumny Kolory.1 i Kolory.2 zostaną przekształcone
odpowiednio w Atrybut i Wartość. Ta ostatnia zawiera kolory produktów poprawnie
przypisane do ich kodów. Zauważ, że przed niektórymi nazwami kolorów pojawią się spacje.
Aby je usunąć, wykonaj na kolumnie Wartość przekształcenie Przycięcie lub w panelu
Zastosowane kroki kliknij krok Podzielono kolumnę według ogranicznika, a następnie kliknij
ikonę ustawień. W oknie, które się pojawi, w liście Wybierz lub wprowadź ogranicznik wskaż
pozycję --Niestandardowe--, po czym w polu niżej wpisz przecinek i spację (, ). Poniżej
przedstawiona jest poprawiona formuła kroku Podzielono kolumnę według ogranicznika:
= Table.SplitColumn(#"Usunięto inne kolumny", "Kolory", Splitter.SplitTextByDelimiter(",
", QuoteStyle.Csv), {"Kolory.1", "Kolory.2"})
12. Usuń kolumnę Atrybut i załaduj zapytanie do arkusza lub raportu. W dalszej analizie możesz
utworzyć wykres słupkowy, tak jak na rysunku 10.8.
13. Aby sprawdzić, co się stanie, gdy pojawi się produkt w więcej niż dwóch kolorach, zapisz
raport i otwórz plik R10-06.xlsx.
14. W kolumnie D3 dopisz dodatkowe kolory, np. czarny i czerwony. Zapisz skoroszyt i zamknij go.
Wróć do utworzonego wcześniej raportu i odśwież go. Nowe kolory nie pojawią się w raporcie.
Aby rozwiązać problem, powinieneś wykonać operacje opisane w ćwiczeniu 2.8, tj. podzielić
kolumnę na wiersze. Jeżeli jednak z jakiegoś powodu musisz podzielić kolumny na kolumny, określ
właściwą liczbę nowych kolumn. Załóżmy, że wiesz z góry, iż liczba kolorów nie będzie większa niż 20.
W kroku Podzielono kolumnę według ogranicznika wpisz następującą formułę:
= Table.SplitColumn(#"Usunięto inne kolumny", "Kolory", Splitter.SplitTextByDelimiter(", ",
QuoteStyle.Csv), 20)
268
4650570396d9eb2765da56c12eb840b5
4
Po zamianie fragmentu {"Kolory.1", "Kolory.2"} na liczbę 20, tj. przewidywaną maksymalną

liczbę kolorów, zapytanie będzie bardziej stabilne i dane nie będą tracone.
Plik R10-06 - v2.xlsx jest zmodyfikowaną wersją pliku R10-06.xlsx, zawierającą dodatkowe
kolory. W powyższych plikach z rozwiązaniem wykorzystany jest skoroszyt R10-06 - v2.xlsx.
Pułapka 8. Scalanie kolumn

W poprzednim podrozdziale, „Dzielenie kolumn”, dowiedziałeś się, jak unikać pułapki związanej
z dzieleniem kolumn. Jeżeli koniecznie musisz podzielić odseparowane przecinkami dane na
kolumny, a nie na wiersze, w argumencie funkcji powinieneś podać liczbę kolumn, które mają zostać
utworzone. W tym podrozdziale nauczysz się budować poprawne zapytania wykonujące odwrotną
operację, tj. scalanie kolumn.
Formuła scalająca kolumny przekształca wszystkie wartości liczbowe na tekstowe, a następnie
łączy je. Poniżej przedstawiony jest kod (podzielony na osobne wiersze dla większej czytelności),
który został automatycznie wygenerowany podczas scalenia trzech kolumn tabeli Źródło. Dwie
pierwsze kolumny, Kolumna liczbowa 1 i Kolumna liczbowa 2, zawierały wartości liczbowe,
a trzecia, Kolumna tekstowa, wartości tekstowe.
#"Scalono kolumny" = Table.CombineColumns(
Table.TransformColumnTypes(
Źródło, {
{"Kolumna liczbowa 1", type text},
{"Kolumna liczbowa 2", type text}
},
"pl-PL"),
{"Kolumna liczbowa 1", "Kolumna liczbowa 2", "Kolumna tekstowa"},
Combiner.CombineTextByDelimiter("", QuoteStyle.None),
"Scalone"
)
Funkcja Table.TransformColumnTypes użyta w powyższej formule wykonuje konwersję typu
danych w kolumnach liczbowych, a następnie łączy wskazane kolumny. Całe zapytanie jest narażone
na niepotrzebne problemy z odświeżaniem danych i należy je zmienić tak, aby nie wykorzystywało
wpisanych statycznie nazw kolumn.
Załóżmy, że masz listę KolumnyDoScalenia zawierającą nazwy kolumn. Poniżej przedstawiona
jest zmodyfikowana formuła, której możesz użyć zamiast poprzedniej:
#"Scalono kolumny" = Table.CombineColumns(
Table.TransformColumnTypes(
Źródło,
List.Transform(
KolumnyDoScalenia,
each {_, type text}
),
"pl-PL"),
KolumnyDoScalenia,
Combiner.CombineTextByDelimiter("", QuoteStyle.None),
"Scalone"
)
269
4650570396d9eb2765da56c12eb840b5
4
Obie formuły różnią się głównie tym, że poniższy fragment kodu użyty w pierwszej z nich:
{
{"Kolumna liczbowa 1", type text},
{"Kolumna liczbowa 2", type text}
}
został zastąpiony funkcją List.Transform zwracającą taką samą listę, jednak bez odwoływania się
do nazw kolumn:
List.Transform(
KolumnyDoScalenia,
each {_, type text}
)
Funkcja ta odczytuje z listy KolumnyDoScalenia kolejne nazwy kolumn i przekształca je na listę
nazw kolumn tekstowych.
Choć z powyższej funkcji będziesz korzystał raczej rzadko, jest to ważny przykład, ponieważ
pokazuje, jak stosować funkcje operujące na listach do tworzenia skalowanych i stabilnych zapytań.
Inne pułapki i techniki zapobiegawcze

Na początku rozdziału wspomniałem o dziesięciu pułapkach, które opisałem na swoim blogu
DataChant. W tym rozdziale pominąłem pułapki 9. i 10., które krótko przedstawię w tym
podrozdziale. Aby uzyskać o nich więcej informacji, odwiedź mój blog.
Pułapka 9. pojawia się podczas rozwijania kolumn. Jest to przekształcenie często wykonywane
podczas łączenia plików zapisanych w folderze, scalania dwóch tabel oraz przetwarzania danych
bez określonej struktury, np. w formacie JSON.
Podczas rozwijania kolumn za pomocą edytora Power Query tworzona jest formuła zawierająca
statycznie wpisane nazwy kolumn. Jeżeli więc w przyszłości pojawią się nowe kolumny, nie zostaną
rozwinięte. Aby dowiedzieć się więcej o tym przekształceniu i zapobieganiu pomijania kolumn,
odwiedź stronę https://datachant.com/2017/02/07/power-bi-pitfall-9.
Pułapka 10. dotyczy usuwania powtarzających się wartości i została opisana w rozdziale 2.,
w ćwiczeniu 2.7.
Podsumowanie
W tym rozdziale wzbogaciłeś swoje umiejętności przetwarzania danych. Nauczyłeś się patrzeć
dalekowzrocznie i tworzyć zapytania, które będą działać długo i stabilnie bez konieczności ich
nieustannego dostosowywania do zmieniających się danych. Poznałeś najczęściej spotykane pułapki,
z powodu których raporty mogą się nie odświeżać lub będą pojawiać się w nich błędne dane.
Aby nie wpadać w te pułapki, musisz przestrzegać trzech ogólnych zasad: świadomego działania,
stosowania dobrych praktyk i umiejętnego modyfikowania kodu M. Abyś mógł wykrywać
w formułach statycznie wpisywane nazwy kolumn i błędne warunki, wyświetlaj pasek formuły
i często sprawdzaj jego zawartość.
270
4650570396d9eb2765da56c12eb840b5
4
W tym rozdziale poznałeś kilka dobrych praktyk, dzięki którym zmniejszysz ryzyko pojawienia się
błędów w zapytaniach. Jeżeli formalnie lub nieformalnie umówisz się z autorami danych w kwestii
ich formatu, będziesz mógł podczas tworzenia zapytań przyjmować poprawne założenia i podejmować
właściwe decyzje dotyczące wyboru rozwiązania problemu.
Nauczyłeś się również usprawniać zapytania, wprowadzając niewielkie zmiany w formułach M.
Tabela 10.1 zawiera podsumowanie najważniejszych pułapek, ich skutków i sposobów unikania.
TABELA 10.1. Najważniejsze pułapki, ich skutki i sposoby unikania
Pułapka Skutek Sposoby unikania

Pułapka 1. Potencjalne problemy Włącz pasek formuły i przeglądaj
Ignorowanie paska formuły wynikające z nieznajomości pojawiający się w nim kod.
automatycznie generowanego Wyszukuj wartości ujęte
kodu M. w cudzysłowy i sprawdzaj,
czy odpowiadają operacjom
wykonywanym w edytorze.
Pułapka 2. Wysokie prawdopodobieństwo Usuwaj krok Zmieniono typ.
Zmiana typów danych pojawienia się problemów W każdym skoroszycie Excela
z odświeżaniem raportów. i raporcie Power BI wyłączaj
opcję automatycznego
wykrywania typów danych.
Typy danych zmieniaj ręcznie
i rób to jak najpóźniej.
Pułapka 3. Wysokie prawdopodobieństwo Nie wybieraj wartości w panelu
Niebezpieczne filtrowanie pojawienia się błędnych danych filtru, tylko używaj polecenia
w raportach. Filtry tekstu. Sprawdzaj w pasku
formuły, czy warunki filtrowania
są zgodne z oczekiwaniami.
Pułapka 4. Wysokie prawdopodobieństwo W miarę możliwości unikaj
Zmiana kolejności kolumn pojawienia się problemów przemieszczania kolumn,
z odświeżaniem raportów. ewentualnie przemieszczaj
tylko niektóre z nich za pomocą
formuł M.
Pułapka 5. Dość wysokie Jeżeli w tabeli ma pozostać
Usuwanie i wybieranie kolumn prawdopodobieństwo niewiele kolumn, używaj
pojawienia się problemów funkcjonalności Wybieranie
z odświeżaniem raportów. kolumn, a nie Usuń kolumny.
Zazwyczaj kolumny, które mają
pozostać w tabeli, nie są
usuwane ze źródła danych.
Pułapka 6. Dość wysokie Nazwy kolumn zmieniaj
Zmiana nazw kolumn prawdopodobieństwo za pomocą funkcji
pojawienia się problemów Table.TransformColumnNames
z odświeżaniem raportów. lub Table.ColumnNames
wykorzystującej indeksy
kolumn.
271
4650570396d9eb2765da56c12eb840b5
4
TABELA 10.1. Najważniejsze pułapki, ich skutki i sposoby unikania — ciąg dalszy
Pułapka Skutek Sposoby unikania

Pułapka 7. Wysokie prawdopodobieństwo Unikaj dzielenia kolumn na
Dzielenie kolumn utraty danych. kolumny. Zamiast tego stosuj
zaawansowaną opcję dzielenia
kolumn na wiersze. Jeżeli nie
jest to możliwe, umieszczaj
w drugim argumencie funkcji
Table.SplitColumn
maksymalną oczekiwaną
liczbę kolumn.
Pułapka 8. Dość wysokie W automatycznie tworzonym
Scalanie kolumn prawdopodobieństwo kodzie umieszczane są nazwy
pojawienia się problemów wszystkich scalanych kolumn.
z odświeżaniem raportów. Jeżeli kolumn jest dużo lub ich
lista dynamicznie się zmienia,
odpowiednio zmieniaj formułę.
Pułapka 9. Dość wysokie Patrz https://datachant.com/
Rozwijanie kolumn prawdopodobieństwo 2017/02/07/power-bi-pitfall-9.
utraty danych.
Pułapka 10. Wysokie prawdopodobieństwo Patrz rozdział 2., ćwiczenie 2.7,
Usuwanie duplikatów danych pojawienia się problemów część „Jeżeli nie uda się utworzyć
z odświeżaniem raportów relacji”. Przed utworzeniem
i tworzeniem relacji między relacji z tabelą wyszukiwania
tabelami faktów a tabelami ujednolicaj wielkie oraz małe
wyszukiwania. litery i przycinaj spacje.
272
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 11.
Podstawy analizy tekstu
Słowa puste jak wiatr najlepiej pozostawić niewypowiedziane.

— Homer

 wyszukiwać słowa kluczowe w kolumnach tekstowych i wykorzystywać tę samą technikę
do prostego określania tematu tekstu,
 dynamicznie ładować zewnętrzną listę słów kluczowych i wyszukiwać w tekście zawarte
w niej słowa,
 wyszukiwać słowa kluczowe, wykorzystując iloczyn kartezjański i niestandardową funkcję,
 przyspieszać za pomocą funkcji Table.Buffer i List.Buffer ładowanie do raportów
wyników wyszukiwania słów kluczowych,
 stosować różne metody dzielenia tekstu na słowa, zliczania ich oraz pomijania w analizach
powszechnie używanych słów,
 przygotowywać dane tekstowe i ładować je do niestandardowego elementu wizualnego
Word Cloud w programie Power BI.
W tym rozdziale nauczysz się używać narzędzia Power Query do pozyskiwania kluczowych informacji
z tekstowych źródeł danych. Już teraz na pewno wiele kolumn w Twoich tabelach zawiera bogate,
ale niewykorzystywane dane tekstowe. Parafrazując cytat Homera, możesz uznać, że wiele słów
zawartych w tych danych jest pustych jak wiatr. Kolumn tekstowych zazwyczaj nie wykorzystuje się
w raportach, ewentualnie pozyskuje się z niektórych wierszy pewne informacje kontekstowe.
W rzeczywistości jednak można z nich uzyskiwać bardzo dużo cennych informacji. W rozdziałach
12., „Zaawansowana analiza tekstu: rozpoznawanie znaczenia” i 13., „Analiza sieci społecznościowych”,
poznasz kilka bardzo przydatnych metod, dzięki którym odkryjesz w kolumnach tekstowych ukryte
w nich skarby.
Techniki opisane w tym rozdziale przydają się szczególnie do analizowania takich informacji
tekstowych jak wyniki ankiet, komentarze operacyjne czy wpisy na portalach społecznościowych.
Dowiesz się teraz, jak stosując popularne przekształcenia, można wyodrębniać znaczenia słów.
Najpierw poznasz prostą technikę wyszukiwania słów kluczowych, a później będziesz stopniowo
wzbogacał swój arsenał o bardziej zaawansowane metody umożliwiające rozwiązywanie za pomocą
4650570396d9eb2765da56c12eb840b5
4
narzędzia Power Query często spotykanych, ale skomplikowanych problemów. Swoją przygodę
będziesz kontynuował w kolejnym rozdziale, w którym poznasz zaawansowane techniki analizy
danych w chmurze Azure, obejmujące m.in. tłumaczenia tekstu, analizę nastroju i wyszukiwanie
kluczowych fraz. Nie będziesz przy tym potrzebował pomocy analityków ani programistów.
Wyszukiwanie słów kluczowych w kolumnach tekstowych

Twoje pierwsze zadanie w tym rozdziale jest bardzo typowe: masz wyszukać słowa kluczowe
w tekstowym źródle danych. Choć może wydawać się trywialne, okazuje się nie lada wyzwaniem,
gdy wyszukiwanych słów jest dużo lub trzeba je dynamicznie ładować z zewnętrznych źródeł bez
dodatkowych modyfikacji. W ćwiczeniu 11.1 dowiesz się, jak wyszukiwać niewielką liczbę
predefiniowanych słów kluczowych.
Ćwiczenie 11.1. Proste wyszukiwanie słów kluczowych

Ćwiczenie polega na wyszukiwaniu słów kluczowych we wpisach umieszczanych przez wydawnictwo
Microsoft Press na oficjalnej stronie na Facebooku (https://www.facebook.com/microsoftpress).
Na podstawie znalezionych słów będziesz mógł określić najpopularniejsze tematy poruszane
przez wydawnictwo.
W ćwiczeniu wykorzystasz skoroszyt R11-01.xlsx zawierający następujące dane: unikatowy identyfikator
wpisu (kolumna ID wpisu), treść (Wpis), data umieszczenia (Data) i adres URL wpisu (URL).
Dane możesz odświeżyć i zaimportować z Facebooka najnowsze wpisy. W tym celu kliknij
w karcie Dane ikonę Odśwież wszystko. Ćwiczenie wykonaj jednak na oryginalnych, tj.
nieodświeżonych danych.
Zobacz też. W rozdziale 13., „Analiza sieci społecznościowych”, nauczysz się importować za
pomocą narzędzia Power Query bieżące wpisy z Facebooka, natomiast tematem tego rozdziału
jest analiza tekstu. Dlatego w ćwiczeniu wykorzystasz skoroszyt Excela R11-01.xlsx. Jeżeli jesteś
niecierpliwy, przejrzyj zawarte w nim zapytanie importujące bieżące wpisy.
Wyobraź sobie, że jesteś analitykiem danych w wydawnictwie Microsoft Press i zajmujesz się
mediami społecznościowymi. Twoim zadaniem jest określenie, który z poniższych produktów jest
najbardziej promowany na Facebooku:
 Microsoft Excel,
 Visual Studio,
 Azure,
 Windows.
Czy potrafisz wyszukać te cztery frazy w arkuszu w kolumnie Wpis? Poniższe ćwiczenie
pokazuje krok po kroku, jak można to zrobić.
274
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 11.  PODSTAWY ANALIZY TEKSTU

4. Zwróć uwagę, że wpisy z Facebooka są umieszone w kolumnie Wpis, tak jak na rysunku 11.1.
RYSUNEK 11.1. Kolumna Wpis zawiera wpisy wydawnictwa Microsoft Press na Facebooku; Twoim zadaniem
jest wyszukanie w nich zadanych słów kluczowych
Ponieważ w Power Query w funkcji wyszukiwania wielkość liter ma znaczenie, w kolejnym

kroku utworzysz kopię kolumny Wpis, w której wszystkie litery tekstu zostaną zamienione
na małe. Oryginalną kolumnę zachowasz na wypadek, gdybyś musiał ją wykorzystać
w raporcie.
5. Zaznacz kolumnę Wpis, a następnie w karcie Dodaj kolumnę kliknij ikonę Duplikuj kolumnę.
6. Zaznacz kolumnę Wpis — kopia, a następnie w karcie Przekształć kliknij ikonę Format
i wybierz polecenie Małe litery.
7. Zmień nazwę kolumny Wpis — kopia na Małe litery.
Teraz utworzysz kolumnę Temat i każdym jej wierszu umieścisz jeden z tematów:
Microsoft Excel, Visual Studio, Azure lub Windows.
8. W kolumnie Dodaj kolumnę kliknij ikonę Kolumna warunkowa. Pojawi się okno
Dodawanie kolumny warunkowej.
9. Utwórz nową kolumnę zawierającą jedną z czterech powyższych fraz, o ile znajduje się ona
w kolumnie Małe litery. W tym celu wykonaj następujące kroki (patrz rysunek 11.2).
a. W polu Nazwa nowej kolumny wpisz Temat.
b. W rozwijanej liście Nazwa kolumny wybierz pozycję Małe litery.
c. W rozwijanej liście Operator wybierz pozycję zawiera.
d. W polu Wartość wpisz microsoft excel.
e. W polu Wartość wyjściowa wpisz Microsoft Excel.
Uwaga. W punkcie 9d wpisałeś temat małymi literami (microsoft excel), ponieważ w funkcji
wyszukiwania wielkość liter ma znaczenie. Temat, który w punkcie 9e wpisałeś wielkimi
i małymi literami, wykorzystasz w raporcie.
275
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 11.2. Okno Dodawanie kolumny warunkowej z warunkami umożliwiającymi wyszukiwanie fraz
„Microsoft Excel”, „Visual Studio”, „Azure” i „Windows”
10. Kliknij przycisk Dodaj regułę. Pojawi się nowy wiersz umożliwiający zdefiniowanie kolejnego
warunku. Powtórz punkt 9. z następującymi zmianami: w punkcie 9d w polu Wartość wpisz
visual studio, a w polu Wartość wyjściowa Visual Studio.
11. Kliknij przycisk Dodaj regułę. Powtórz punkt 9. z następującymi zmianami: w punkcie 9d
w polu Wartość wpisz azure, a w polu Wartość wyjściowa Azure.
12. Kliknij przycisk Dodaj regułę. Powtórz punkt 9. z następującymi zmianami: w punkcie 9d
w polu Wartość wpisz windows, a w polu Wartość wyjściowa Windows.
13. W polu W przeciwnym razie wpisz Inny. Sprawdź, czy wszystkie ustawienia są takie, jak na
rysunku 11.2 i kliknij OK, aby zamknąć okno.
Oczywiście, nie jest to skuteczny sposób wyszukiwania wszystkich możliwych tematów
wpisów wydawnictwa Microsoft Press na Facebooku. Wiele wpisów zostanie sklasyfikowanych
jako Inny. Niektóre z nich reklamują książki o Office 365, inne o bazie SQL Server, a jeszcze
inne zawierają informacje o promocjach, np. „visit www.microsoftpressstore.com
today—and discover deals, new books, and special promotions!”.
Dla uproszczenia przyjmijmy, że na razie opisany sposób spełnia Twoje potrzeby i możesz
w kolumnie Temat odrzucić wiersze zawierające tekst Inny.
14. W nagłówku kolumny Temat kliknij ikonę filtru, usuń zaznaczenie pozycji Inny i kliknij OK.
15. Na koniec usuń kolumnę Małe litery, zmień nazwę zapytania na Wpisy Microsoft Press
i załaduj dane do raportu.
Teraz, gdy osiągnąłeś swój cel, przyjrzyjmy się najważniejszym mankamentom metody, którą
zastosowałeś w tym ćwiczeniu.
276
4650570396d9eb2765da56c12eb840b5
4
 Mankament 1. Liczba wyszukiwanych tematów jest ograniczona do listy słów.

W przypadku długiej listy tematów ręczne wpisywanie słów kluczowych w definicji kolumny
warunkowej będzie niepraktycznym rozwiązaniem. Potrzebny jest inny, bardziej skalowalny
sposób.
 Mankament 2. Wyszukiwane tematy tworzą statyczną listę.
W tym ćwiczeniu ręcznie wpisywałeś poszczególne tematy w definicji kolumny warunkowej.
Innym rozwiązaniem mogłoby być modyfikowanie utworzonej formuły, ale problem
pozostałby nierozwiązany, tj. wyszukiwane frazy byłyby statycznie wpisane w kodzie.
Gdybyś musiał ładować z zewnętrznego źródła listę nieznanych fraz, wtedy zastosowana
metoda okazałaby się nieefektywna. Potrzebny jest sposób umożliwiający dynamiczne
ładowanie listy fraz z zewnętrznego źródła, bez spowalniania wykonywanych operacji.
 Mankament 3. W każdym wpisie wyszukiwany jest tylko jeden temat.
Wpis na Facebooku może zawierać kilka fraz. Przykładowo we wpisie
„New book! Programming for the Internet of Things: Using Windows 10 IoT Core
and Azure IoT Suite”
nie został znaleziony temat Windows, ponieważ użyta w kolumnie warunkowej formuła
znalazła wcześniej temat Azure. Czasami lepszym rozwiązaniem jest wyszukiwanie i zliczanie
wszystkich słów kluczowych.
 Mankament 4. Słowa kluczowe mogą być fragmentami dłuższych słów, przez co wpis
może zostać błędnie sklasyfikowany.
Ponieważ w definicji kolumny warunkowej użyłeś operatora zawiera, formuła wyszukuje
słowa kluczowe będące fragmentami dłuższych słów. Weźmy np. słowo Excel. Jak zostaną
sklasyfikowane poniższe wpisy?
„This SQL Server book is excellent”.
„Read this C# book to excel in software development”.
W obu przypadkach zostanie znaleziony niewłaściwy temat. Aby tego uniknąć, musisz
podzielić wpisy na osobne słowa, a następnie porównać je ze słowami kluczowymi.
Więcej o tym sposobie dowiesz się dalej w tym rozdziale.
Zajmijmy się teraz pierwszym mankamentem. Przedstawiam Ci doskonałą metodę porównywania
dwóch zestawów danych, czyli iloczyn kartezjański.
Wyszukiwanie słów kluczowych z użyciem iloczynu kartezjańskiego

W następnym ćwiczeniu poznasz skuteczną metodę wyszukiwania dużej liczby słów kluczowych.
Wcześniej do tego celu użyłeś kolumny warunkowej (patrz rysunek 11.2). Czy zastosowałbyś tę
samą metodę w przypadku większej liczby słów? Byłaby to czasochłonna operacja, tym bardziej,
gdyby słowa te regularnie się zmieniały.
Bardziej skalowalny sposób pozwalający na wyszukiwanie większej, dynamicznie zmieniającej się
listy słów polega na użyciu iloczynu kartezjańskiego. Tworzona jest wtedy większa tabela, taka jak
na rysunku 11.3, zawierająca wszystkie kombinacje wpisów i słów kluczowych.
277
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 11.3. Iloczyn kartezjański wpisów i słów kluczowych
Uwaga. W teorii zbiorów iloczyn kartezjański może obejmować wiele zestawów elementów.
Wynikiem jest wtedy zbiór wszystkich kombinacji elementów po jednym z każdego zestawu.
W narzędziu Power Query iloczyn kartezjański dwóch tabel (a nawet tej samej tabeli) tworzy się
poprzez dodanie do pierwszej tabeli kolumny niestandardowej zawierającej odwołania do drugiej
tabeli. Po rozwinięciu takiej kolumny tworzony jest iloczyn kartezjański, taki jak na rysunku 11.3.
Na rysunku 11.3 w lewym górnym rogu widoczna jest tabela zawierająca trzy wpisy, a w prawym
górnym znajduje się tabela ze słowami kluczowymi. Wynikiem iloczynu kartezjańskiego jest nowa
tabela zawierająca wszystkie kombinacje wpisów i słów kluczowych, pokazana w dolnej części rysunku.
W ten sposób można tworzyć pary wartości zawierające wszystkie możliwe kombinacje i dalej je
przetwarzać. W tym przypadku przetwarzanie będzie polegało na wyszukiwaniu słowa kluczowego
we wpisie, a następnie filtrowaniu wierszy, w których słowa zostały znalezione.
Uwaga. Iloczyn kartezjański ma wiele zastosowań; korzystając z niego, można pozyskiwać

różne informacje z danych źródłowych. Po znalezieniu wszystkich kombinacji elementów kilku
tabel można wykonywać analizy warunkowe, analizy koszyka, jak również przeprowadzać różne
operacje z teorii grafów (np. wyszukiwać najkrótszą drogę).
Jeżeli nie wiesz jeszcze, jak utworzyć iloczyn kartezjański i jak go użyć do wyszukiwania słów
kluczowych na szeroką skalę, wykonaj następne ćwiczenie, w którym znajdziesz odpowiedzi na
swoje pytania.
278
4650570396d9eb2765da56c12eb840b5
4
Ćwiczenie 11.2. Iloczyn kartezjański

Twoim kolejnym zadaniem, jako szefa działu analiz w Microsoft Press (awansowałeś po wykonaniu
poprzedniego zadania — gratulacje!), jest przygotowanie raportu, takiego jak na rysunku 11.4.
Wykorzystasz w tym celu iloczyn kartezjański tabeli wpisów i tabeli tematów widocznych
we fragmentatorze po prawej stronie rysunku.
RYSUNEK 11.4. Skoroszyt R11-02 - rozwiązanie.xlsx zawiera wyniki analizy tematów wpisów wydawnictwa
Microsoft Press na Facebooku
Część I. Przygotowanie
W tym ćwiczeniu wykorzystasz te same dane źródłowe, co w poprzednim. Najpierw jednak musisz
wykonać pewne operacje przygotowawcze.
4. Zmień nazwę zapytania na Wpisy Microsoft Press.
Teraz utworzysz odwołanie do zapytania Wpisy Microsoft Press i użyjesz go do przygotowania
nowej tabeli zawierającej wpisy i tematy. W tabeli tej będą wielokrotnie występowały wpisy
z tymi samymi identyfikatorami.
5. W panelu Zapytania kliknij prawym przyciskiem myszy zapytanie Wpisy Microsoft Press
i z podręcznego menu wybierz polecenie Odwołanie.
6. Zmień nazwę nowego zapytania na Tematy wpisów.
7. Zaznacz zapytanie Tematy wpisów, a następnie w karcie Strona główna kliknij ikonę
Wybieranie kolumn.
8. W oknie, które się pojawi, zaznacz pozycje ID wpisu i Wpis, a następnie kliknij OK.
279
4650570396d9eb2765da56c12eb840b5
4
9. Zaznacz kolumnę Wpis, a następnie w karcie Dodaj kolumnę kliknij ikonę Duplikuj kolumnę.
10. Zaznacz kolumnę Wpis — kopia, a następnie w karcie Przekształć kliknij ikonę Format
i wybierz polecenie Małe litery.
11. Zmień nazwę kolumny Wpis — kopia na Małe litery.
12. Lista słów kluczowych znajduje się w pliku C:\Dane\R11\Słowa kluczowe.txt. Aby utworzyć
na jego podstawie nowe zapytanie, kliknij w karcie Strona główna ikonę Nowe źródło, następnie
wybierz polecenia Plik/Plik tekstowy lub CSV i zaimportuj plik C:\Dane\R11\Słowa kluczowe.txt.
13. W oknie Słowa kluczowe.txt, które się pojawi, kliknij OK.
14. W zapytaniu Słowa kluczowe zmień nazwę kolumny na Słowo kluczowe.
15. Zaznacz kolumnę Słowo kluczowe, a następnie w karcie Przekształć kliknij ikonę Format
i wybierz polecenie Małe litery. Wtedy będziesz miał pewność, że w filtrze, którego użyjesz
w następnej części ćwiczenia, nie pominiesz żadnego tematu z powodu różnego traktowania
wielkich i małych liter.
Część II. Iloczyn kartezjański

Po wykonaniu kroków przygotowawczych od 1. do 15. jesteś gotów do zastosowania iloczynu
kartezjańskiego. Za pomocą kolumny niestandardowej utworzysz kombinacje wszystkich wpisów
i tematów, a następnie użyjesz filtru wybierającego wyłącznie wpisy zawierające znalezione tematy.
W tym celu wykonaj poniższe kroki.
16. W panelu Zapytania zaznacz zapytanie Tematy wpisów.
17. W karcie Dodaj kolumnę kliknij ikonę Kolumna niestandardowa. W oknie, które się pojawi,
wprowadź następujące zmiany.
a. W polu Nazwa nowej kolumny wpisz Iloczyn kartezjański.
b. W polu Formuła kolumny niestandardowej wpisz następujący kod:
= #"Słowa kluczowe"
18. Pojawi się kolumna Iloczyn kartezjański zawierająca w każdym wierszu obiekt Table
reprezentujący tabelę Słowa kluczowe. Rozwiniesz ją teraz.
19. W nagłówku kolumny Iloczyn kartezjański kliknij ikonę rozwinięcia. (Ewentualnie zaznacz
tę kolumnę, a następnie w karcie Przekształć kliknij ikonę Rozwiń). W panelu, który się
pojawi, zaznacz pozycję Słowo kluczowe i usuń zaznaczenie opcji Użyj oryginalnej nazwy
kolumny jako prefiksu. Kliknij OK.
W panelu podglądu pojawi się tabela zawierająca iloczyn kartezjański. Teraz dowiesz się,
dlaczego jest tak przydatny. Po utworzeniu wszystkich kombinacji wpisów i tematów
zastosujesz filtr przepuszczający tylko wpisy zawierające znalezione tematy. Utworzysz w tym
celu kolumnę warunkową, w której następnie zastosujesz filtr.
warunkowej, które się pojawi, wprowadź opisane niżej i przedstawione na rysunku 11.5 zmiany.
a. W polu Nazwa nowej kolumny wpisz Temat.
b. W rozwijanej liście Nazwa kolumny wybierz pozycję Małe litery.
c. W rozwijanej liście Operator wybierz pozycję zawiera.
280
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 11.5. Za pomocą kolumny warunkowej można powiązać wpisy Microsoft Press na Facebooku
ze słowami kluczowymi umieszczonymi w tabeli będącej wynikiem iloczynu kartezjańskiego
d. W pierwszej rozwijanej liście poniżej etykiety Wartość wskaż pozycję Wybierz kolumnę,
a w drugiej wybierz Słowo kluczowe.
e. W pierwszej rozwijanej liście poniżej etykiety Wartość wyjściowa wskaż pozycję
Wybierz kolumnę, a w drugiej wybierz Słowo kluczowe.
f. W polu W przeciwnym razie wpisz null.
g. Kliknij OK, aby zamknąć okno.
Pojawi się kolumna Temat z wartościami null w wierszach, w których wpis nie zawiera słowa
kluczowego.
21. W nagłówku kolumny Temat kliknij ikonę filtru, a następnie wybierz polecenie Usuń puste.
22. Usuń kolumny Wpis, Małe litery i Słowo kluczowe.
Przeanalizujmy to, co zrobiłeś do tej pory. Za pomocą iloczynu kartezjańskiego powiązałeś wpisy
ze słowami kluczowymi zawartymi w dynamicznej liście. Do utworzenia raportu będziesz potrzebował
dwóch tabel. Pierwsza z nich to Wpisy Microsoft Press zawierająca m.in. kolumny ID wpisu i Wpis,
a druga to Tematy wpisów z kolumnami ID wpisu i Temat.
Część III. Relacje

W tej części ćwiczenia zakończysz etap przygotowywania danych i rozpoczniesz ich modelowanie.
Celem jest przeprowadzenie analizy tematów wpisów. Modelowanie danych nie jest tematem tej
książki, jednak w tej części ćwiczenia opisane są niezbędne kroki, które musisz wykonać, jeżeli nie
znasz tabel przestawnych Excela i funkcjonalności modelowania programu Power BI Desktop.
Utworzysz teraz relacje pomiędzy tabelami zawierającymi wpisy i tematy. Uzyskane w ten sposób
dane będziesz mógł umieścić w tabeli przestawnej i różnych elementach wizualnych.
23. Jeżeli używasz Excela, wykonaj poniższe kroki, aby załadować zapytania Wpisy Microsoft
Press i Tematy wpisów do modelu danych.
a. Aby w edytorze Power Query załadować zapytania do raportu, kliknij w karcie
Strona główna ikonę Załaduj i zamknij.
b. W Excelu w karcie Dane kliknij ikonę Zapytania i połączenia.
281
4650570396d9eb2765da56c12eb840b5
4
c. W panelu Zapytania i połączenia kliknij prawym przyciskiem myszy zapytanie

Wpisy Microsoft Press i z podręcznego menu wybierz polecenie Załaduj do.
d. W oknie Importowanie danych, które się pojawi, zaznacz opcje Utwórz tylko połączenie
oraz Dodaj te dane do modelu danych.
e. W panelu Zapytania i połączenia kliknij prawym przyciskiem myszy zapytanie
Tematy wpisów i z podręcznego menu wybierz polecenie Załaduj do.
f. W oknie Importowanie danych zaznacz opcje Utwórz tylko połączenie oraz Dodaj te dane
do modelu danych.
g. W panelu Zapytania i połączenia kliknij prawym przyciskiem myszy zapytanie
Słowa kluczowe i z podręcznego menu wybierz polecenie Załaduj do.
h. W oknie Importowanie danych zaznacz opcję Utwórz tylko połączenie i usuń zaznaczenie
opcji Dodaj te dane do modelu danych.
i. W karcie Dane kliknij ikonę Zarządzaj modelem danych. W oknie Power Pivot dla
programu Excel, które się pojawi, kliknij w karcie Narzędzia główne ikonę Widok diagramu.
Jeżeli używasz programu Power BI Desktop, wykonaj poniższe kroki, aby nie ładować do
raportu zapytania Słowa kluczowe.
a. W panelu Zapytania kliknij prawym przyciskiem myszy zapytanie Słowa kluczowe i usuń
zaznaczenie polecenia Włącz ładowanie.
b. W karcie Strona główna kliknij ikonę Zamknij i zastosuj.
c. W pasku po lewej stronie okna programu Power BI Desktop kliknij ikonę Model.
24. Aby utworzyć relację między dwiema tabelami, tak jak na rysunku 11.6, przeciągnij z tabeli
Wpisy Microsoft Press pole ID wpisu i upuść je na pole o tej samej nazwie w tabeli Tematy wpisów.
RYSUNEK 11.6. Utworzenie relacji pomiędzy polem „ID wpisu” tabeli „Wpisy Microsoft Press” a polem
„ID wpisu” tabeli „Tematy wpisów”
282
4650570396d9eb2765da56c12eb840b5
4
Teraz możesz zająć się analizą danych (patrz rysunek 11.4). Gotowe rozwiązanie jest zapisane
w plikach R11-02 - rozwiązanie.xlsx oraz R11-02 - rozwiązanie.pbix. Za pomocą wykresu
przestawnego i fragmentatora możesz sprawdzać, ile wpisów na różne tematy pojawiało się
na Facebooku na przestrzeni czasu.
Zapisz raport. Za chwilę wykonasz ważną operację zwiększającą wydajność przetwarzania
danych. Wcześniej jednak przeanalizujemy, co udało Ci się do tej pory osiągnąć. Kiedy zastosowałeś
iloczyn kartezjański, usunąłeś trzy mankamenty wymienione w ćwiczeniu 11.1.
 Możesz teraz ładować większe listy słów kluczowych bez konieczności ręcznego wpisywania
ich w ustawieniach kolumny warunkowej. W ten sposób usunąłeś mankament 1.
 Listę słów kluczowych możesz dynamicznie ładować z zewnętrznego pliku, przy czym nie
musisz wiedzieć zawczasu, które z nich będą wykorzystane. Usunąłeś więc mankament 2.,
jednak możesz zwiększyć wydajność tego rozwiązania. Nie zamykaj edytora Power Query,
ponieważ ten temat będzie opisany dalej w tym rozdziale.
 Jeżeli wpis zawiera kilka słów kluczowych, możesz z nim skojarzyć kilka tematów.
Usunąłeś mankament 3.
Część IV. Zwiększenie wydajności

Zastanówmy się na chwilę nad wydajnością całego rozwiązania. Zwróć uwagę, że podczas odświeżania
raportu zapytanie ładuje się dość szybko. Generowanie iloczynu kartezjańskiego wraz z filtrowaniem
wierszy jest zaimplementowane w efektywny, niewymagający dużych ilości pamięci sposób. Rozwinięta
tabela zawierająca wszystkie kombinacje wpisów i tematów nie została w całości umieszczona w pamięci.
Silnik języka M wykonywał przekształcenia na małych częściach dwóch tabel. Jest to ważna i bardzo
użyteczna cecha narzędzia Power Query. Wszędzie tam, gdzie jest to możliwe, przekształcenia wykonywane
są na niewielkich porcjach danych wyodrębnianych kolejno z całego zbioru. Dzięki temu do pamięci
nie są ładowane całe zbiory danych. W efekcie generowanie iloczynu kartezjańskiego nie zajmuje
wiele pamięci.
Mimo to, możesz jednak znacząco zwiększyć szybkość generowania iloczynu kartezjańskiego.
W tym celu wykonaj następujące kroki w skoroszycie Excela lub raporcie Power BI, który utworzyłeś
w ćwiczeniu 11.2.
1. W edytorze Power Query zaznacz zapytanie Tematy wpisów, a następnie w panelu
Zastosowane kroki zaznacz krok Dodano kolumnę niestandardową. W pasku formuły
= Table.AddColumn(#"Zmieniono nazwy kolumn", "Iloczyn kartezjański", each #"Słowa kluczowe")
W tym kroku silnik języka M odczytuje słowa kluczowe z poszczególnych wierszy. Co ciekawe,
operacja ta oraz następna, czyli rozwinięcie kolumny, są wykonywane w ten sposób, że słowa
kluczowe są wielokrotnie odczytywane z zewnętrznego pliku.
Aby zawartość zewnętrznego pliku była ładowana do tabeli Słowa kluczowe tylko raz, użyj
w zapytaniu funkcji Table.Buffer, która całą powyższą tabelę umieści w pamięci. Dzięki
temu silnik języka M nie będzie wielokrotnie odwoływał się do pliku.
Wskazówka. Choć funkcja Table.Buffer bardzo skutecznie skraca czas ładowania danych
do raportu, nie używaj jej przy każdym scalaniu tabel. Przykładowo funkcja ta nie przydaje się
w przekształceniach Scal zapytania lub Dołącz zapytania. Warto ją stosować tylko wtedy, gdy
do utworzenia kolumny niestandardowej wymagany jest dostęp do innego źródła danych.
283
4650570396d9eb2765da56c12eb840b5
4
Dlaczego funkcja Table.Buffer jest tak przydatna w formułach kolumn niestandardowych

ładujących dane z zewnętrznych źródeł? W tego rodzaju kolumnach obliczenia są wykonywane
na poziomie wierszy i nie są przy tym stosowane żadne mechanizmy optymalizacyjne. Co więcej,
silnik języka M jest zaprojektowany tak, aby zużywał jak najmniej pamięci, co powoduje, że
na czas tworzenia kolumny niestandardowej tabela Słowa kluczowe jest usuwana z pamięci.
Funkcja Table.Buffer powoduje, że silnik przestaje stosować mechanizm oszczędzania
zasobów w tym konkretnym przypadku, kiedy wielokrotnie ładowany plik ze słowami
kluczowymi wymaga wykonania wielu operacji odczytu danych z dysku.
2. Aby zastosować funkcję Table.Buffer, kliknij ikonę Edytor zaawansowany i w wierszu
poniżej instrukcji let wpisz następujący kod:
BuforSłówKluczowych = Table.Buffer(#"Słowa kluczowe"),
3. Następnie zastąp wiersz:
#"Dodano kolumnę niestandardową" = Table.AddColumn(#"Zmieniono nazwy kolumn", "Iloczyn
kartezjański", each #"Słowa kluczowe"),
następującym wierszem:
#"Dodano kolumnę niestandardową" = Table.AddColumn(#"Zmieniono nazwy kolumn", "Iloczyn
kartezjański", each BuforSłówKluczowych),
Jeżeli teraz załadujesz zapytanie, zauważysz, że operacja ta zostanie wykonana znacznie
szybciej, ponieważ ilość danych jest niewielka.
4. Aby porównać szybkość ładowania zapytania Tematy wpisów przed i po zastosowaniu
funkcji Table.Buffer, otwórz plik R11-02 - porównanie.xlsx i w karcie Dane kliknij ikonę
Zapytania i polecenia (patrz rysunek 11.7). Następnie odśwież zapytania Tematy wpisów
(bez funkcji Table.Buffer) oraz Tematy wpisów (szybsze) (z funkcją Table.Buffer), klikając
każde z nich prawym przyciskiem myszy i wybierając polecenie Odśwież. Jak się przekonasz,
drugie zapytanie odświeży się o wiele szybciej.
RYSUNEK 11.7. Zapytanie wykorzystujące funkcję Table.Buffer odświeża się szybciej
284
4650570396d9eb2765da56c12eb840b5
4
Wskazówka. Aby porównać czasy odświeżania zapytań, należy użyć odpowiednio dużych zbiorów
danych. Żeby sztucznie powiększyć zbiór użyty w tym ćwiczeniu, zwielokrotnij tabelę za pomocą
funkcji Table.Repeat. W tym celu w zapytaniu Wpisy Microsoft Press dodaj niestandardowy
krok i wpisz w nim następującą formułę:
= Table.Repeat(#"Zmieniono typ", 100)
W następnym ćwiczeniu poznasz inną metodę wyszukiwania słów kluczowych, wykorzystującą

niestandardową funkcję.
Ćwiczenie 11.3. Wyszukiwanie słów kluczowych

za pomocą niestandardowej funkcji
Jeżeli metoda wyszukiwania słów kluczowych z użyciem iloczynu kartezjańskiego wydaje Ci się
mało intuicyjna i podejrzewasz, że jest jakaś prostsza, masz rację. Jest taka metoda. W tym punkcie
dowiesz się, jak zamiast iloczynu kartezjańskiego możesz użyć niestandardowej funkcji. Jest to
bardziej intuicyjna technika, ale jak sam się przekonasz, znacznie mniej wydajna niż iloczyn
kartezjański. Jednak użyta razem z funkcją Table.Buffer okazuje się od niego szybsza.
1. Otwórz skoroszyt R11-02 - porównanie.xlsx i uruchom edytor Power Query.
2. W panelu Zapytania kliknij prawym przyciskiem myszy zapytanie Tematy wpisów
i z podręcznego menu wybierz polecenie Duplikuj.
3. Zmień nazwę nowego zapytania na Tematy wpisów z funkcją i zaznacz je.
Teraz usuniesz przekształcenie wykorzystujące iloczyn kartezjański i do wyszukiwania słów
kluczowych użyjesz niestandardowej funkcji.
4. W panelu Zastosowane kroki usuń pięć ostatnich kroków.
5. W karcie Strona główna kliknij ikonę Nowe źródło, a następnie wybierz polecenia Inne źródła
i Puste zapytanie. Zmień nazwę funkcji na FnWyszukajSłowaKluczowe i w kolumnie Strona
główna kliknij ikonę Edytor zaawansowany.
6. Usuń istniejące wyrażenie i w jego miejscu wpisz poniższy kod:
(Wpis, SłowaKluczowe)=>
Table.SelectRows(SłowaKluczowe, each Text.Contains(Wpis, [Słowo kluczowe]))
Argumentami tej funkcji są wpis i tabela słów kluczowych, a zwracanym wynikiem fragment
tej tabeli zawierający słowa kluczowe występujące we wpisie. Zwróć uwagę na przyjęte
założenie, że tabela zawiera kolumnę o nazwie Słowo kluczowe.
Kliknij przycisk Gotowe, aby zamknąć edytor.
7. W panelu Zapytania kliknij zapytanie Tematy wpisów z funkcją.
8. W karcie Dodaj kolumnę kliknij ikonę Kolumna niestandardowa. W polu Nazwa nowej
kolumny wpisz Słowa kluczowe, a w polu Formuła kolumny niestandardowej wpisz
następującą formułę:
= FnWyszukajSłowaKluczowe([Małe litery], #"Słowa kluczowe")
Każda komórka w nowej kolumnie niestandardowej będzie zawierała listę słów kluczowych
znalezionych w kolumnie Małe litery.
285
4650570396d9eb2765da56c12eb840b5
4
Uwaga. Jak już się przekonałeś w ćwiczeniu 11.2, przetwarzanie danych za pomocą kolumny
niestandardowej może być długotrwałą operacją. W tym przykładzie silnik języka M
nieustannie ładuje listę słów kluczowych ze źródła danych. Aby temu zapobiec, na końcu
ćwiczenia użyjesz funkcji Table.Buffer.
9. Kliknij OK, aby zamknąć okno Kolumna niestandardowa, a następnie rozwiń kolumnę Słowa
kluczowe (usuń przy tym zaznaczenie opcji Użyj oryginalnej nazwy kolumny jako prefiksu).
10. Pojawi się kolumna Słowo kluczowe zawierająca tematy znalezione we wpisach. Jeżeli dany
wpis nie zawiera żadnego tematu, wtedy w powyższej kolumnie zostanie umieszczona
wartość null.
11. Kliknij w nagłówku kolumny Słowo kluczowe ikonę filtru i wybierz polecenie Usuń puste.
12. Usuń kolumny Wpis i Małe litery. Zmień nazwę kolumny Słowo kluczowe na Temat.
13. Aby załadować zapytanie do raportu i porównać wydajność trzech zapytań, kliknij w karcie
Strona główna ikonę Zamknij i załaduj. Następnie w Excelu w karcie Dane kliknij ikonę
Zapytania i połączenia. W panelu o tej samej nazwie kliknij prawym przyciskiem myszy
zapytanie Tematy wpisów z funkcją i z podręcznego menu wybierz polecenie Załaduj do.
W oknie Importowanie danych zaznacz opcje Utwórz tylko połączenie oraz Załaduj te dane
do modelu danych. Na koniec kliknij ikonę Odśwież wszystko. Zwróć uwagę, że nowe
zapytanie ładuje się najdłużej. Jest nieco wolniejsze od zapytania Tematy wpisów
wykorzystującego iloczyn kartezjański bez funkcji Table.Buffer. Teraz dowiesz się,
jak możesz zwiększyć wydajność zapytania.
14. Otwórz edytor Power Query i w panelu Zapytania kliknij prawym przyciskiem myszy
zapytanie Tematy wpisów z funkcją. Z podręcznego menu wybierz polecenie Duplikuj
i zmień nazwę nowego zapytania na Tematy wpisów (najszybsze).
15. Zaznacz ostatnie zapytanie, a następnie w karcie Strona główna kliknij ikonę
Edytor zaawansowany.
16. Poniżej instrukcji let wpisz poniższy kod:
BuforSłówKluczowych = Table.Buffer(#"Słowa kluczowe"),

17. W poniższym wierszu zastąp fragment #"Słowa kluczowe":
#"Dodano kolumnę niestandardową" = Table.AddColumn(#"Zmieniono nazwy kolumn", "Słowa

kluczowe", each FnWyszukajSłowaKluczowe([Małe litery], #"Słowa kluczowe")),
zmienną BuforSłówKluczowych, tak jak niżej:
#"Dodano kolumnę niestandardową" = Table.AddColumn(#"Zmieniono nazwy kolumn", "Słowa
kluczowe", each FnWyszukajSłowaKluczowe([Małe litery], BuforSłówKluczowych)),
18. Załaduj nowe zapytanie do raportu. W karcie Dane kliknij ikonę Odśwież wszystko
i porównaj szybkość ładowania danych ze wszystkich czterech zapytań.
Jak pokazuje rysunek 11.8, zapytanie Tematy wpisów (najszybsze) jest szybsze od utworzonego
wcześniej zapytania Tematy wpisów (szybsze). Jeżeli zapomnisz zastosować funkcję Table.Buffer,
wtedy opisana technika okaże się najwolniejsza, o czym świadczy wydajność zapytania Tematy
wpisów z funkcją.
286
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 11.8. Najszybciej ładuje się zapytanie „Tematy wpisów (najszybsze)”, wykorzystujące funkcję
niestandardową i funkcję Table.Buffer
Dlaczego ostatnie zapytanie wykorzystujące funkcję Table.Buffer jest szybsze niż iloczyn
kartezjański, a bez tej funkcji jest wolniejsze? W kroku 6. zaimplementowałeś odwołanie do tabeli
Słowa kluczowe wewnątrz funkcji. Silnik języka M, zaprojektowany tak, aby domyślnie zajmował
minimalną ilość pamięci, usuwał z niej tabelę Słowa kluczowe po wykorzystaniu. Z tego powodu
podczas wyliczania wartości w nowej kolumnie tabela ta była wielokrotnie odczytywana z pliku.
W zapytaniu wykorzystującym iloczyn kartezjański odwołanie do tabeli Słowa kluczowe znajduje się
w głównym kodzie, więc tabela ta nie jest ładowana wielokrotnie z pliku.
Dzięki zastosowaniu funkcji Table.Buffer silnik języka M umieścił tabelę Słowa kluczowe
w pamięci na stałe i nowe zapytanie było szybsze niż zapytanie wykorzystujące iloczyn kartezjański
(nawet po zastosowaniu w nim funkcji Table.Buffer). Zapytanie z iloczynem kartezjańskim jest
wolniejsze od zapytania z funkcją niestandardową, ponieważ zajmuje więcej pamięci i wykonuje
bardziej złożone przekształcenia. Silnik musi w nim replikować każdy wiersz z wpisem tyle razy,
ile jest wierszy w tabeli Słowa kluczowe, a potem stosować filtr. Te dwa przekształcenia nie są
wykonywane w zapytaniu wykorzystującym funkcję niestandardową, dzięki czemu jest ono
wydajniejsze.
Gotowe rozwiązanie jest zapisane w pliku R11-03 - rozwiązanie.xlsx.
287
4650570396d9eb2765da56c12eb840b5
4
Jakiej metody użyć: zwykłego wyszukiwania,

iloczynu kartezjańskiego czy niestandardowej funkcji?
W ćwiczeniach 11.1, 11.2 i 11.3 poznałeś trzy metody wyszukiwania słów kluczowych. Pierwsza
polegała na zwykłym wyszukiwaniu kilku słów umieszczonych w definicji kolumny warunkowej.
Druga metoda wykorzystywała iloczyn kartezjański i dynamicznie ładowaną listę słów. Wydajność
zapytania opartego na tej metodzie można było zwiększyć za pomocą funkcji Table.Buffer. W ostatniej,
trzeciej metodzie zastosowana została funkcja niestandardowa. Jak się przekonałeś, na początku była
to najwolniejsza metoda, ale po zastosowaniu funkcji Table.Buffer okazała się najszybsza.
W praktyce, jeżeli lista słów będzie krótka, korzystaj z pierwszej metody. Jeżeli lista będzie
dłuższa lub ładowana dynamiczne, a pisanie niestandardowych funkcji w języku M nie jest Twoją
ulubioną czynnością, stosuj metodę z iloczynem kartezjańskim. Jeżeli czujesz się pewnie w języku M,
stosuj technikę wykorzystującą niestandardową funkcję. Pamiętaj jednak, aby wywoływać w niej
funkcję Table.Buffer.
Wskazówka. Opisane techniki są również bardzo skuteczne w filtrowaniu kolumn tekstowych

wg słów kluczowych. W opisanych ćwiczeniach tworzyłeś kolumnę Temat, w której stosowałeś
filtr odrzucający puste wiersze. Technika ta przydaje się również do filtrowania tekstów.
Dzielenie wpisów na słowa

Przypomnij sobie czwarty mankament metody, którą zastosowałeś w ćwiczeniu 11.1: słowa kluczowe
mogą stanowić fragmenty dłuższych słów, przez co wpis może zostać błędnie sklasyfikowany. W tym
podrozdziale dowiesz się, jak usprawnić wyszukiwanie słów kluczowych poprzez dzielenie kolumn
tekstowych na pojedyncze słowa, jak przetwarzać uzyskiwane wyniki w tabelach i wykresach
przestawnych Excela oraz chmurach słownych Power BI i pozyskiwać w ten sposób z kolumn
tekstowych nowe informacje. Technikę tę możesz również wykorzystać do zliczania słów
i wizualizowania wyników za pomocą chmury słownej.
Ćwiczenie 11.4. Trywialne dzielenie wpisów na słowa

W tym ćwiczeniu załadujesz wpisy umieszczone przez wydawnictwo Microsoft Press na Facebooku
i podzielisz je na słowa. Dowiesz się, jak pomijać powszechnie stosowane słowa w języku angielskim,
takie jak the, and, in oraz on.
Część I. Dzielenie według spacji

W tej części ćwiczenia zastosujesz trywialną metodę dzielenia wpisów na słowa według spacji.
W kolejnych częściach wykorzystasz lepsze rozwiązanie.
288
4650570396d9eb2765da56c12eb840b5
4

4. Zmień nazwę zapytania na Wpisy Microsoft Press.
Aby opracować nową tabelę zawierającą identyfikatory wpisów i użyte w nich słowa, utwórz
odwołanie do zapytania Wpisy Microsoft Press. W tym celu kliknij je prawym przyciskiem
myszy i wybierz polecenie Odwołanie.
5. Zmień nazwę nowego zapytania na Wszystkie słowa.
6. Zaznacz nowe zapytanie, a następnie w karcie Strona główna kliknij ikonę Wybieranie
kolumn. W oknie o tej samej nazwie, które się pojawi, zaznacz pozycje ID wpisu oraz Wpis
i kliknij OK.
7. Kliknij prawym przyciskiem myszy kolumnę Wpis i z podręcznego menu wybierz polecenia
Przekształć i Małe litery.
8. Kliknij prawym przyciskiem myszy kolumnę Wpis i z podręcznego menu wybierz polecenia
Podziel kolumny i Według ogranicznika. Ewentualnie w karcie Strona główna kliknij ikonę
Podziel kolumny i wybierz polecenie Według ogranicznika.
Pojawi się okno Dzielenie kolumny według ogranicznika. Jak już się przekonałeś w rozdziale
10., „Od złych do dobrych zapytań”, domyślny sposób dzielenia kolumny na kolumny nie
skaluje się dobrze, tym bardziej, gdy wpisy składają się z wielu słów.
9. Aby podzielić kolumnę Wpis na wiersze, wykonaj poniższe kroki.
a. W rozwijanej liście Wybierz lub wprowadź ogranicznik wskaż pozycję Spacja.
c. Zaznacz opcję Wiersze.
10. Zmień nazwę kolumny na Słowo.
Na pierwszy rzut oka może Ci się wydawać, że powyższe przekształcenie rozwiązuje problem.
Okazuje się jednak, że wiele słów zawiera znaki interpunkcyjne, przez co to samo słowo może
występować w kilku wierszach. Przykładowo często pojawia się słowo excel z przecinkiem,
wykrzyknikiem lub dwukropkiem. Aby rozwiązać ten problem, musisz oddzielić słowa od znaków
interpunkcyjnych.
Część II. Oddzielenie słów od znaków interpunkcyjnych

W tej części ćwiczenia zastosujesz lepszy sposób podziału wpisów na słowa i usuniesz wszystkie
znaki interpunkcyjne. Kontynuuj ćwiczenie 11.4 i wykonaj poniższe kroki.
11. Utwórz puste zapytanie o nazwie Znaki interpunkcyjne, a następnie w pasku formuły wpisz
następujący kod:
= {" ", "~", ",", ".", "?", "!", "(", ")", "[", "]", "{", "}", "@", "#", "$", "%", "^",
"&", "*", "-", "+", "=", ":", ";", "|", "<", ">", "/", "“", "”", "\", """", "#(tab)",
"#(cr)", "#(lf)"}
Powyższe wyrażenie tworzy listę znaków interpunkcyjnych i specjalnych, takich jak tabulator
lub przełamanie wiersza.
12. W panelu Zapytania zaznacz zapytanie Wszystkie słowa.
289
4650570396d9eb2765da56c12eb840b5
4
13. W panelu Zastosowane kroki zaznacz krok Podzielono kolumnę według ogranicznika
i przyjrzyj się kodowi w pasku formuły. Jak pokazuje rysunek 11.9, formuła jest bardzo
skomplikowana.
RYSUNEK 11.9. Krok „Podzielono kolumnę według ogranicznika” nie uwzględnia znaków interpunkcyjnych;
aby rozwiązać problem, musisz zmodyfikować formułę
Zwróć uwagę, że formuła składa się z dwóch części: pierwsza dzieli kolumnę Wpis na obiekty
typu List, które następnie rozwija. Nie musisz dokładnie rozumieć kodu tej formuły. Skup się
na jej najważniejszej części, wyróżnionej na rysunku 11.9 i pokazanej niżej:
Splitter.SplitTextByDelimiter(" ", QuoteStyle.Csv)
Zastąp powyższy kod następującym:
Splitter.SplitTextByAnyDelimiter(#"Znaki interpunkcyjne", QuoteStyle.Csv)
W ten sposób możesz dzielić wpisy według dowolnych ograniczników umieszczonych
w liście Znaki interpunkcyjne. Pomysłowe, prawda?
Wskazówka. Jeżeli chcesz podzielić kolumnę według kilku ograniczników, użyj przekształcenia
Podziel kolumny według ogranicznika, a następnie odpowiednio zmień formułę M. Zastąp funkcję
Splitter.SplitTextByDelimiter funkcją Splitter.SplitTextByAnyDelimiter, a zamiast
pojedynczego ogranicznika użyj listy ograniczników. Technikę tę możesz wykorzystywać
do dzielenia kolumny na kolumny oraz na wiersze.
W wyniku podzielenia wpisów według różnych znaków interpunkcyjnych pojawiło się dużo
wierszy z pustymi komórkami, które musisz odfiltrować.
14. W panelu Zastosowane kroki zaznacz ostatni krok, a następnie w nagłówku kolumny Słowo
kliknij ikonę filtru i wybierz polecenie Usuń puste.
15. Zamknij edytor Power Query i załaduj zapytania Wpisy Microsoft Press oraz Wszystkie słowa
do modelu danych. Nie ładuj zapytania Znaki interpunkcyjne. Utwórz relację pomiędzy
polami ID wpisu obu tabel (w podobny sposób utworzyłeś relację w ćwiczeniu 11.2 pomiędzy
polami ID wpisu tabel Wpisy Microsoft Press i Tematy wpisów).
16. Zapisz raport. Będzie Ci potrzebny w następnej części ćwiczenia.
290
4650570396d9eb2765da56c12eb840b5
4
Gdy utworzysz w programie Power BI Desktop wykres słupkowy lub w Excelu tabelę przestawną,
umieszczając pole Słowo w obszarach Wiersze i Wartości, tak jak na rysunku 11.10, okaże się, że
najczęściej we wpisach występują powszechnie używane słowa, co nie jest przydatną informacją.
RYSUNEK 11.10. Najczęściej używanym słowem we wpisach Microsoft Press

jest „http”, po nim „the” i „and”, co nie jest nową ani cenną informacją
Dlaczego najczęściej występuje słowo http? Ponieważ wiele wpisów zawiera adresy URL stron
internetowych, zaczynające się od prefiksu http://. Czy nie lepiej byłoby pozostawić odnośniki
niepodzielone i potraktować je jak całe słowa?
Część III. Dzielenie wpisów według spacji i usuwanie znaków interpunkcyjnych

W tej części ćwiczenia w inny sposób usuniesz znaki interpunkcyjne. Zamiast dzielić wpis na słowa
według różnych znaków, tak jak w poprzedniej części, podzielisz je tylko według spacji, znaku
tabulacji, powrotu kursora i nowego wiersza, a następnie usuniesz znaki interpunkcyjne znajdujące
się przed słowami lub po słowach.
17. Jeżeli nie zapisałeś skoroszytu lub raportu, wykonaj ponownie kroki od 1. do 16.
18. Uruchom edytor Power Query. W panelu Zapytania kliknij prawym przyciskiem myszy
zapytanie Wszystkie słowa i z podręcznego menu wybierz polecenie Duplikuj.
19. Zmień nazwę nowego zapytania na Wszystkie słowa — bez interpunkcji.
20. Zaznacz nowe zapytanie, a następnie w panelu Zastosowane kroki kliknij krok
Podzielono kolumnę według ogranicznika.
21. W pasku formuły zastąp wyróżniony fragment kodu:
Splitter.SplitTextByAnyDelimiter(#"Znaki interpunkcyjne", QuoteStyle.Csv)

następującym fragmentem:
Splitter.SplitTextByAnyDelimiter({" ", "#(tab)", "#(cr)", "#(lf)"}, QuoteStyle.Csv)
Podzielisz w ten sposób wpisy według spacji, znaku tabulacji, powrotu kursora i nowego
wiersza. Teraz zajmij się wyszukaniem i usunięciem znaków interpunkcyjnych znajdujących
się przed słowami i po słowach.
22. W panelu podglądu zaznacz kolumnę Wpis, a następnie w karcie Przekształć kliknij ikonę
Format i wybierz polecenie Przycięcie.
291
4650570396d9eb2765da56c12eb840b5
4
23. W oknie Wstawianie kroku, które się pojawi, kliknij przycisk Wstaw. Domyślnie
przekształcenie to usuwa spacje znajdujące się przed słowem i po słowie. Tutaj
zmodyfikujesz je tak, aby usuwało również znaki interpunkcyjne.
Zwróć uwagę na następujący fragment kodu w pasku formuły:
= Table.TransformColumns(#"Podzielono kolumnę według ogranicznika",{{"Wpis", Text.Trim,
type text}})
Zastąp ten fragment następującym:
= Table.TransformColumns(#"Podzielono kolumnę według ogranicznika",{{"Wpis", each
Text.Trim(_, #"Znaki interpunkcyjne"), type text}})
W ten sposób zamiast domyślnych argumentów funkcji Text.Trim użyjesz innych, jawnie
podanych. Jak pamiętasz z rozdziału 9., „Wprowadzenie do języka M”, instrukcja each służy
do tworzenia prostych funkcji. Drugim argumentem funkcji Text.Trim jest lista znaków
przeznaczonych do usunięcia. W tym przypadku jest to lista Znaki interpunkcyjne, którą
utworzyłeś wcześniej.
Uwaga. Lista Znaki interpunkcyjne zawiera spację, znak tabulacji, powrotu kursora i nowego
wiersza, które już zostały użyte do podzielenia wpisów. Aby całe zapytanie było bardziej wydajne,
utwórz duplikat tej listy, usuń z niego powyższe znaki i umieść jego nazwę w drugim argumencie
funkcji Text.Trim.
Teraz na podstawie zapytania Wszystkie słowa — bez interpunkcji utwórz tabelę przestawną,
tak jak na rysunku 11.11. Jak widać, nie ma w niej słowa http.
RYSUNEK 11.11. Wśród najczęściej używanych słów we wpisach

wydawnictwa Microsoft Press nie ma już słowa „http”
Zapisz skoroszyt lub raport, ponieważ będzie Ci potrzeby w następnym ćwiczeniu.

292
4650570396d9eb2765da56c12eb840b5
4
Ćwiczenie 11.5. Odrzucenie stop-słów

W ćwiczeniu 11.4 nauczyłeś się dzielić wpisy na słowa, ale uzyskałeś mało przydatne wyniki.
Nic w tym dziwnego, że najczęściej występującymi słowami są spójniki, przyimki i przymiotniki,
co widać na rysunku 11.11. Czy nie lepiej byłoby odrzucić tego rodzaju słowa i zobaczyć, ile jest
rzeczowników, czasowników i przymiotników?
Aby odrzucić powszechnie występujące słowa, które w tej części ćwiczenia będą nazywane
stop-słowami (określenie często używane przez informatyków), musisz je zapisać w pliku tekstowym,
załadować do zapytania i usunąć z wyników. W tym ćwiczeniu dowiesz się, jak to zrobić.
1. Otwórz plik, który utworzyłeś w ćwiczeniu 11.4, lub skoroszyt Excela R11-04 - rozwiązanie.xlsx
albo raport Power BI R11-04 - rozwiązanie.pbix.
2. Uruchom edytor Power Query, w panelu Zapytania kliknij prawym przyciskiem myszy
zapytanie Wszystkie słowa — bez interpunkcji i z podręcznego menu wybierz polecenie
Odwołanie.
3. Zmień nazwę nowego zapytania na Bez stop-słów.
4. Zaimportuj plik Stop-słowa.txt. W tym celu kliknij w karcie Strona główna ikonę Nowe
źródło i wybierz polecenia Plik i Plik tekstowy lub CSV. W oknie Importowanie danych
odszukaj plik C:\Dane|R11\Stop-słowa.txt i kliknij Otwórz. W oknie Stop-słowa.txt,
które się pojawi, kliknij przycisk OK.
5. Upewnij się, że nowe zapytanie nazywa się Stop-słowa. Zmień nazwę kolumny na Stop-słowo.
Zwróć uwagę na panel podglądu. Wszystkie słowa są zapisane małymi literami. Zgodnie
z dobrą praktyką, powinieneś teraz zamienić wszystkie litery na małe, aby w przyszłości
uniknąć pominięcia słów wynikającego z różnego traktowania wielkich i małych liter.
Zaznacz kolumnę Stop-słowo, a następnie w karcie Przekształć kliknij ikonę Format i wybierz
polecenie Małe litery.
Teraz usuń stop-słowa z wyników. W zapytaniu Bez stop-słów w kolumnie Słowo wszystkie
wyrazy są już zapisane małymi literami. Teraz zastosujesz lewe antysprzężenie i w ten sposób
usuniesz z zapytania Bez stop-słów słowa znajdujące się w zapytaniu Stop-słowa.
6. Wykonaj następujący kroki.
a. W panelu Zapytania zaznacz zapytanie Bez stop-słów.
b. W karcie Strona główna kliknij ikonę Scal zapytania.
c. W oknie Scalanie, które się pojawi, zaznacz w tabeli Bez stop-słów kolumnę Słowo.
d. W rozwijanej liście poniżej tabeli wybierz pozycję Stop-słowa.
e. W tabeli poniżej zaznacz kolumnę Stop-słowo.
f. W rozwijanej liście Rodzaj sprzężenia wybierz pozycję Lewe anty
(wiersze tylko w pierwszej), tak jak na rysunku 11.12, i kliknij OK.
W tabeli pojawi się kolumna Stop-słowa zawierająca obiekty Table. Gdy klikniesz puste
miejsce w dowolnej komórce tej kolumny (nie klikaj odnośnika Table, ponieważ utworzysz
nowy krok wyszczególniający), okaże się, że obiekt ten zawiera wartość null. Jest to efekt
zastosowania lewego antysprzężenia, które nie zwróciło żadnego wiersza z drugiej scalanej
kolumny. Oznacza to, że w zapytaniach Stop-słowa nie musisz niczego wyodrębniać.
293
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 11.12. Do odrzucenia stop-słów użyj lewego antysprzężenia
7. Usuń kolumnę Stop-słowa i zamknij edytor. Nie ładuj zapytania Stop-słowa do modelu
danych, natomiast załaduj do niego zapytanie Bez stop-słów.
Utwórz tabelę przestawną zliczającą wystąpienia słów w zapytaniu Bez stop-słów (patrz rysunek
11.13). Na podstawie uzyskanych wyników można wyciągnąć kilka interesujących wniosków.
RYSUNEK 11.13. Nowa tabela przestawna zawiera słowa

najczęściej występujące we wpisach Microsoft Press, bez stop-słów
294
4650570396d9eb2765da56c12eb840b5
4
Poniżej opisane są dwa przykładowe, dotyczące dziesięciu najczęściej występujących słów.

 Jednym z najczęściej występujących słów jest 2016, ponieważ jest stosowane w nazwach
wielu produktów, które pojawiły się w 2016 r. (Office 2016, Excel 2016, Windows Server
2016 itp.).
 Innym często używanym słowem jest 50, pojawiające się we wpisach oferujących książki
z upustem 50%. Czy wiedziałeś, że w soboty można kupować książki Microsoft Press z takim
rabatem? Jeżeli wyszukasz wpisy zawierające to słowo, przekonasz się, że większość z nich
brzmi Save 50% through Saturday! (W sobotę oszczędzisz 50%!).
Zapisz skoroszyt lub raport, ponieważ wykorzystasz go w następnym ćwiczeniu.
Ćwiczenie 11.6. Wyszukiwanie słów kluczowych

w wyodrębnionych słowach
Jak pamiętasz, w ćwiczeniach 11.2 i 11.3 wyszukiwałeś słowa kluczowe we wpisach Microsoft Press
na Facebooku za pomocą operatora zawiera. Operator ma ten mankament, że błędnie kwalifikuje
znalezione słowo jako kluczowe, jeżeli jest ono częścią większego słowa. Przykładowo excel jest
fragmentem słowa excellent. W tym ćwiczeniu ulepszysz wyszukiwanie słów kluczowych, stosując
technikę dzielenia wpisów na słowa, której użyłeś w ćwiczeniu 11.5.
Część I. Scalenie zapytań za pomocą sprzężenia wewnętrznego

Ćwiczenie zaczniesz od zastosowania bardzo przydanej techniki polegającej na filtrowaniu wielu
wartości tabeli poprzez scalanie zapytań.
1. Otwórz plik, który utworzyłeś w ćwiczeniu 11.5, lub skoroszyt Excela R11-05 - rozwiązanie.xlsx
albo raport Power BI R11-05 - rozwiązanie.pbix.
2. Uruchom edytor Power Query. W karcie Strona główna kliknij ikonę Nowe źródło, wybierz
polecenia Plik/Plik tekstowy lub CSV. W oknie Importowanie danych, które się pojawi,
odszukaj plik C:\Dane\R11\Słowa kluczowe.txt i kliknij Otwórz.
3. W oknie Słowa kluczowe.txt, które się pojawi, kliknij przycisk OK.
4. W zapytaniu Słowa kluczowe zmień nazwę kolumny na Słowo kluczowe.
5. Zamień wszystkie litery na małe. W tym celu zaznacz kolumnę Słowo kluczowe, a następnie
w karcie Przekształć kliknij ikonę Format i wybierz polecenie Małe litery.
Teraz na podstawie zapytania Bez stop-słów, które zawiera identyfikatory wpisów
i skojarzone z nimi słowa, utworzysz nowe zapytanie Tematy wpisów.
6. W panelu Zapytania kliknij prawym przyciskiem myszy zapytanie Bez stop-słów i z podręcznego
menu wybierz polecenie Odwołanie. Zmień nazwę nowego zapytania na Tematy wpisów.
7. Aby odfiltrować wszystkie słowa znajdujące się w zapytaniu Słowa kluczowe, wykonaj
poniższe kroki.
a. W panelu Zapytania zaznacz zapytanie Tematy wpisów.
b. W karcie Strona główna kliknij ikonę Scal zapytania.
c. W oknie Scalanie, które się pojawi, zaznacz w tabeli Tematy wpisów kolumnę Słowo.
295
4650570396d9eb2765da56c12eb840b5
4
d. W rozwijanej liście poniżej tabeli Tematy wpisów wybierz pozycję Słowa kluczowe.
e. W tabeli Słowa kluczowe zaznacz kolumnę Słowo kluczowe.
f. W rozwijanej liście Rodzaj sprzężenia wybierz pozycję Wewnętrzne
(tylko pasujące wiersze) i kliknij OK.
8. Zmień nazwę kolumny Słowo na Temat.
9. Aby uniknąć sytuacji, w której to samo słowo kluczowe pojawi się kilka razy w tym samym
wpisie, zaznacz kolumny ID wpisu i Temat, a następnie w karcie Strona główna kliknij ikonę
Usuń wiersze i wybierz polecenie Usuń duplikaty. Teraz dane słowo kluczowe będzie
skojarzone z danym identyfikatorem wpisu tylko raz.
Na tym możesz zakończyć ćwiczenie. Jednak pojawia się nowe wyzwanie. Czy zauważyłeś,
że plik Słowa kluczowe.txt zawiera dwuczłonowe frazy, np. power query, power bi lub power pivot?
Ponieważ na początku ćwiczenia podzieliłeś wpisy na pojedyncze słowa, nie będziesz w stanie
wyszukać w nich dwuczłonowych słów kluczowych. W następnej części ćwiczenia dowiesz się,
jak rozwiązać ten problem.
Zapisz skoroszyt lub raport. Wykorzystasz go w następnej części ćwiczenia do wyszukiwania
wieloczłonowych słów kluczowych.
Część II. Wyszukiwanie wieloczłonowych słów kluczowych

Aby we wpisach Microsoft Press można było wyszukiwać takie dwuczłonowe frazy jak power query
lub power bi, tymczasowo zastąp w każdej z nich spację innym znakiem, np. podkreśleniem.
Następnie podziel kolumnę Wpis według spacji. Dwuczłonowe frazy nie zostaną wtedy podzielone.
Na koniec przywróć spacje.
Rysunek 11.14 ogólnie ilustruje ten proces. Wykorzystana jest w nim tabela konwersji z kolumną
Źródło, w której słowa oddzielone są spacjami, oraz kolumną Cel zawierającą znaki podkreślenia
zamiast spacji. We wpisach wszystkie frazy występujące w kolumnie Źródło są zastępowane ich
odpowiednikami z kolumny Cel (krok 1.). Następnie wpisy są dzielone na słowa według spacji
(krok 2.) i na koniec znaki pokreślenia są zastępowane z powrotem spacjami (krok 3.).
RYSUNEK 11.14. Dwuczłonowe słowa kluczowe można wyszukiwać, stosując tabelę konwersji
i przedstawioną tu sekwencję przekształceń
296
4650570396d9eb2765da56c12eb840b5
4
Jak pokazuje rysunek 11.14, najpierw musisz utworzyć tabelę konwersji. Użyjesz do tego celu
odwołania do tabeli Słowa kluczowe. Aby kontynuować ćwiczenie, wykonaj poniższe kroki.
10. W panelu Zapytania zaznacz zapytanie Słowa kluczowe i z podręcznego menu wybierz
polecenie Odwołanie. Zmień nazwę nowego zapytania na Tabela konwersji.
11. Aby pozostawić w zapytaniu wyłącznie frazy zawierające spacje, wykonaj poniższe kroki.
a. W karcie Przekształć kliknij ikonę Format i wybierz polecenie Przycięcie. Tabela Słowa
kluczowe nie zawiera wprawdzie wiodących ani końcowych spacji, ale dobrą praktyką
jest stosowanie tego przekształcenia przed wykonaniem kolejnych kroków.
b. W nagłówku kolumny Słowo kluczowe kliknij ikonę filtru, a następnie wybierz polecenia
Filtry tekstu i Zawiera.
c. W oknie Filtrowanie wierszy, które się pojawi, wpisz spację w polu po prawej stronie
rozwijanej listy zawiera i kliknij OK. Teraz tabela widoczna w panelu podglądu powinna
zawierać dziewięć wierszy.
12. Zmień nazwę kolumny Słowo kluczowe na Źródło.
13. Aby utworzyć kopię kolumny Źródło, w której spacje będą zastąpione znakami podkreślenia,
a. Zaznacz kolumnę Źródło, a następnie w karcie Dodaj kolumnę kliknij ikonę Duplikuj.
b. Zmień nazwę nowej kolumny na Cel.
c. W karcie Strona główna kliknij ikonę Zamienianie wartości.
d. W oknie Zamienianie wartości, które się pojawi, wpisz w polu Wartość do znalezienia
spację, a w polu Zamień na wpisz znak podkreślenia. Kliknij OK, aby zamknąć okno.
Tabela konwersji jest gotowa (patrz rysunek 11.4). Teraz pora, abyś dowiedział się, jak jej
użyć. W kolejnych krokach każdą wartość w kolumnie Wpis w tabeli Wpisy Microsoft Press,
występującą w kolumnie Źródło, w tabeli konwersji musisz zamienić na jej odpowiednik
w kolumnie Cel. Przekształcenie to musisz wykonać przed krokiem Podzielono kolumnę
według ogranicznika. Zamienianie pojedynczych wartości w edytorze Power Query jest
proste, ale tutaj masz całą sekwencję par Źródło/Cel.
Niestety, interfejs edytora nie oferuje funkcjonalności umożliwiającej zastępowanie kilku
różnych ciągów znaków. Co więcej, funkcja Table.ReplaceValue nie ma odpowiednika
pozwalającego zastąpić kilka wartości. Dlatego musisz zastosować dość skomplikowaną
technikę polegającą na użyciu funkcji List.Accumulate.
Jak pamiętasz z rozdziału 9., „Wprowadzenie do języka M”, argumentami funkcji
List.Accumulate są lista, obiekt inicjujący i funkcja akumulująca, która powinna zawierać
obiekt stanu i obiekt bieżący (reprezentujący element listy podczas jej iterowania).
Po wykonaniu przekształcenia i przetworzeniu całej listy funkcja ta zwraca obiekt stanu
zawierający zakumulowane wyniki. Teraz jest dobry moment, abyś na chwilę wrócił do
rozdziału 9. i przypomniał sobie opis funkcji List.Accumulate, gdyż wtedy będziesz
wiedział, jak działa wyrażenie, które za chwilę wpiszesz. Jeśli nawet nie znasz dobrze
języka M, możesz kontynuować ćwiczenie, ponieważ nie musisz w pełni rozumieć
wyrażeń, których tutaj użyjesz.
297
4650570396d9eb2765da56c12eb840b5
4
Zanim wykorzystasz funkcję List.Accumulate, dowiedz się, jak możesz przekształcić tabelę
konwersji w listę par wartości źródło-cel, którą umieścisz w argumencie powyższej funkcji.
Rysunek 11.15 pokazuje, jak do tego celu użyć funkcji Table.ToRecords zwracającej listę
rekordów (po jednym dla każdego wiersza oryginalnej tabeli).
RYSUNEK 11.15. Za pomocą funkcji Table.ToRecords można przekształcić tabelę konwersji w listę rekordów
Teraz, gdy wiesz już, jak utworzyć listę rekordów, dowiesz się, jakiej funkcji możesz użyć,
aby zdefiniować funkcję akumulującą. Argumentem takiej funkcji powinien być wpis
z Facebooka, a przekształcenie powinno polegać na zastąpieniu wartości Źródło jej
odpowiednikiem z kolumny Cel. Aby np. ciąg power bi nie został w kolejnym kroku
podzielony na dwa osobne słowa, funkcja musi go zastąpić ciągiem power_bi.
Poniżej przedstawiony jest kod funkcji akumulującej:
(wpis, rekordKonwersji) =>
Text.Replace(
wpis,
rekordKonwersji[Źródło],
rekordKonwersji[Cel]
)
Funkcja ta zastępuje za pomocą funkcji Text.Replace we wpisie z Facebooka
(pierwszy argument) ciąg źródłowy (drugi argument) ciągiem docelowym (trzeci argument).
14. Teraz masz już wszystkie części niezbędne do utworzenia formuły wykorzystującej funkcję
List.Accumulate:
List.Accumulate(
Table.ToRecords(#"Tabela konwersji"),
[Wpis],
Text.Replace(
wpis,
)
)
Powyższa formuła użyta w kolumnie niestandardowej będzie modyfikować każdą wartość
umieszczoną w kolumnie Wpis w następujący sposób: wyszuka w niej wszystkie słowa
kluczowe zawarte w kolumnie Źródło i zastąpi je ich odpowiednikami z kolumny Cel.
Formułę tę zastosujesz w kolumnie niestandardowej i będzie ona wykonywana dla każdego
wiersza zawierającego wpis Microsoft Press na Facebooku. Za każdym razem będzie iterować
pary Źródło/Cel w tabeli konwersji. Stanem inicjującym (drugim argumentem funkcji
List.Accumulate) będzie wartość z kolumny Wpis. Funkcja akumulująca (trzeci argument
funkcji List.Accumulate) zawiera stan i bieżące argumenty (o nazwach wpis i rekordKonwersji).
298
4650570396d9eb2765da56c12eb840b5
4
Argument stanu zawiera wartość bieżącej komórki w kolumnie Wpis. Bieżącym argumentem
funkcji akumulującej jest bieżący rekord zawierający parę Źródło/Cel. Funkcja akumulująca
będzie zastępowała we wpisie słowo kluczowe Źródło jego odpowiednikiem Cel. W kolejnej
iteracji funkcja List.Accumulate użyje następnej pary Źródło/Cel.
W kolejnych krokach wykorzystasz funkcję List.Accumulate do zastąpienia spacji znakami
podkreślenia w słowach kluczowych we wpisach. Operację tę zaimplementujesz przed
krokiem Podzielono kolumnę według ogranicznika.
15. W panelu Zapytania zaznacz zapytanie Wszystkie słowa — bez interpunkcji dzielące wpisy na
słowa. W panelu Zastosowane kroki zaznacz krok Tekst pisany małymi literami znajdujący się
przed krokiem Podzielono kolumnę według ogranicznika.
16. W karcie Dodaj kolumnę kliknij ikonę Kolumna niestandardowa. W oknie Wstawianie kroku,
które się pojawi, kliknij przycisk Wstaw.
17. W oknie Kolumna niestandardowa, które się pojawi, wprowadź poniższe zmiany.
a. W polu Nazwa nowej kolumny wpisz Zmodyfikowany wpis.
b. W polu Formuła kolumny niestandardowej wpisz formułę z kroku 14. Kliknij OK,
aby zamknąć okno.
W nowej kolumnie Zmodyfikowany wpis pojawią się wpisy z zastąpionymi wartościami.
Aby sprawdzić, czy funkcja List.Accumulate spełniła swoje zadanie, utwórz tymczasowy
krok filtrujący wpisy zawierające frazy power query i power pivot. W tym celu w panelu
Zastosowane kroki zaznacz krok Dodano kolumnę niestandardową, a następnie w nagłówku
kolumny Wpis kliknij ikonę filtru. Wybierz polecenia Filtry tekstu i Zawiera. W oknie
Filtrowanie wierszy wpisz w pierwszym polu po prawej stronie power query i zaznacz opcję
Oraz. W dolnej rozwijanej liście po lewej stronie wybierz pozycję zawiera i w polu po jej
prawej stronie wpisz power pivot. Kliknij OK, aby zamknąć okno.
W panelu podglądu pojawi się m.in. wiersz zawierający w kolumnie Wpis następujący tekst:
microsoft office 2016 step by step …
• solve business intelligence problems with power pivot and power query …
Natomiast w kolumnie Zmodyfikowany wpis będzie widoczny zmieniony tekst:
microsoft office 2016 step by step …
• solve business intelligence problems with power_pivot and power_query …
18. Usuń tymczasowy filtr. W tym celu usuń z panelu Zastosowane kroki krok Przefiltrowano
wiersze1.
19. W panelu Zastosowane kroki zaznacz krok Dodano kolumnę niestandardową i usuń kolumnę
Wpis. W oknie Wstawianie kroku, które się pojawi, kliknij przycisk Wstaw.
20. Zmień nazwę kolumny Zmodyfikowany wpis na Wpis. Jak poprzednio, w oknie Wstawianie
kroku kliknij Wstaw.
Teraz wszystkie dwuczłonowe słowa kluczowe zawierają znaki podkreślenia zamiast spacji,
dzięki czemu nie zostaną podzielone w kolejnym kroku.
21. Aby na koniec odtworzyć spacje, zaznacz w panelu Zapytania zapytanie Bez stop-słów,
a następnie w panelu Zastosowane kroki zaznacz ostatni krok. W tym miejscu zastąpisz
znaki podkreślenia spacjami.
299
4650570396d9eb2765da56c12eb840b5
4
22. Znaki podkreślenia możesz zastąpić na dwa sposoby. Pierwszy jest dość prosty: jeżeli jesteś
pewien, że żaden ważny tekst w karcie Słowo nie zawiera znaku podkreślenia, możesz
zastosować przekształcenie Zamień wartości.
Drugi sposób jest lepszy, jeżeli kolumna zawiera teksty ze znakami podkreślenia
(inne niż słowa kluczowe). Aby zastąpić te znaki tylko w słowach kluczowych,
a. Zaznacz zapytanie Bez stop-słów, a następnie w karcie Dodaj kolumnę kliknij ikonę
Kolumna niestandardowa.
b. W polu Nazwa nowej kolumny wpisz Zmodyfikowane słowo.
c. W polu Formuła kolumny niestandardowej wpisz poniższy kod:
List.Accumulate(
Table.ToRecords(#"Tabela konwersji"),
[Słowo],
(słowo, rekordKonwersji) =>
if słowo = rekordKonwersji[Cel] then
rekordKonwersji[Źródło]
else
słowo
)
Powyższa formuła jest nieco prostsza niż użyta w kroku 14. Jest wykorzystywana w kolumnie
niestandardowej, a więc wykonywana dla każdego wiersza z wpisem. Podobnie jak poprzednia
formuła, iteruje rekordy zawierające pary Źródło/Cel. Początkowym stanem (drugi argument
funkcji List.Accumulate) jest wartość w kolumnie Słowo. Funkcja akumulująca (trzeci
argument funkcji List.Accumulate) zawiera stan i bieżące argumenty (o nazwach słowo
i rekordKonwersji). Argument stanu zawiera wartość bieżącej komórki w kolumnie Słowo.
Bieżącym argumentem funkcji akumulującej jest bieżący rekord zawierający parę Źródło/Cel.
Funkcja akumulująca porównuje bieżące słowo z wartością w kolumnie Cel (zawierającą
słowo kluczowe ze znakiem podkreślenia). Jeżeli słowa są takie same, funkcja zwraca
odpowiednik z kolumny Źródło, ponieważ celem jest przywrócenie słowa zawierającego
spację. Jeżeli słowa są różne, funkcja zwraca oryginalne słowo. W kolejnej iteracji funkcja
List.Accumulate używa następnej pary Źródło/Cel.
23. Aby sprawdzić, czy formuła działa poprawnie, odfiltruj w kolumnie Słowo wartość power_bi.
Pojawią się wiersze zawierające w kolumnie Zmodyfikowane słowo powyższy ciąg.
Po sprawdzeniu, że wszystko działa poprawnie, usuń krok filtru.
24. Usuń kolumnę Słowo, a następnie zmień nazwę kolumny Zmodyfikowane słowo na Słowo.
25. W panelu Zapytania zaznacz zapytanie Tematy wpisów i w nagłówku kolumny Temat
kliknij ikonę filtru. W panelu filtru powinny pojawić się dwuczłonowe słowa kluczowe.
Zanim załadujesz zapytanie Tematy wpisów do raportu, popraw jego wydajność za pomocą
funkcji Table.Buffer lub List.Buffer. Jak pamiętasz, w krokach 14. i 22. utworzyłeś kolumny
niestandardowe odwołujące się do tabeli konwersji. W ćwiczeniach 11.2 i 11.3 dowiedziałeś
się, że silnik M w kolumnie niestandardowej wielokrotnie odczytuje dane z zewnętrznych
źródeł. W kolejnych krokach rozwiążesz ten problem i skrócisz czas ładowania zapytania
za pomocą funkcji List.Buffer.
300
4650570396d9eb2765da56c12eb840b5
4
26. Zaznacz zapytanie Wszystkie słowa — bez interpunkcji, a następnie w karcie Strona główna
kliknij ikonę Edytor zaawansowany.
Powyżej wiersza zaczynającego się od #"Dodano kolumnę niestandardową" wpisz następujący
wiersz:
BuforListy = List.Buffer(Table.ToRecords(#"Tabela konwersji")),
W kroku #"Dodano kolumnę niestandardową" w pierwszym argumencie funkcji
List.Accumulate zastąp funkcję Table.ToRecords(#"Tabela konwersji") zmienną
BuforListy. Poniżej przedstawiony jest cały kod tego kroku po wprowadzeniu zmiany:
#"Dodano kolumnę niestandardową" = Table.AddColumn(
#"Tekst pisany małymi literami",
"Zmodyfikowany wpis",
each List.Accumulate(
BuforListy,
[Wpis],
Text.Replace(
wpis,
)
),
28. Zaznacz zapytanie Bez stop-słów, a następnie w karcie Strona główna kliknij ikonę
Powyżej wiersza zaczynającego się od #"Dodano kolumnę niestandardową" wpisz
następujący kod:
BuforListy = List.Buffer(Table.ToRecords(#"Tabela konwersji")),
W kroku #"Dodano kolumnę niestandardową" w pierwszym argumencie funkcji List.Accumulate
zastąp funkcję Table.ToRecords(#"Tabela konwersji") zmienną BuforListy. Poniżej
przedstawiony jest cały kod tego kroku po wprowadzeniu opisanej zmiany:
#"Dodano kolumnę niestandardową" = Table.AddColumn(
#"Usunięto kolumny",
"Zmodyfikowane słowo",
each List.Accumulate(
BuforListy,
[Słowo],
(słowo, rekordKonwersji) =>
if słowo = rekordKonwersji[Cel] then
rekordKonwersji[Źródło]
else
słowo
)
),
Teraz możesz załadować zapytanie Lista tematów do raportu i utworzyć nową tabelę lub
wykres pokazujące najczęstsze tematy wpisów wydawnictwa Microsoft Press na Facebooku
301
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 11.16. Raport przedstawia liczbę wpisów na Facebooku według tematów, w tym przypadku
w formie tabeli przestawnej i wykresu przestawnego w Excelu
Ćwiczenie 11.7. Chmura słowna w Power BI Desktop

Na zakończenie rozdziału zobaczysz, jak w programie Power BI Desktop można wizualizować dane
tekstowe w postaci chmury słownej. W poprzednim ćwiczeniu dowiedziałeś się, jak dzielić wpisy
i zliczać słowa z pominięciem stop-słów. Okazuje się, że jeżeli wpisów jest mało, można je
bezpośrednio, bez dzielenia na pojedyncze słowa, ładować do chmury słownej.
To ćwiczenie pokazuje, jak dostosowywać niestandardowy element wizualny, tj. chmurę słowną,
i jak pomijać w niej stop-słowa bez konieczności dzielenia wpisów. Utworzysz teraz chmurę
podobną do przedstawionej na rysunku 11.17.
1. Uruchom program Power BI Desktop.
2. W karcie Strona główna kliknij w sekcji Niestandardowe elementy wizualne ikonę
Z platformy handlowej.
3. W oknie Wizualizacje usługi Power BI, które się pojawi, w polu Wyszukaj wpisz Word Cloud
i kliknij ikonę lupy.
302
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 11.17. W programie Power BI Desktop dane tekstowe można wizualizować w postaci chmury
słownej; opcja „Słowa ignorowane” pozwala dzielić wpisy na słowa na poziomie wizualizacji
4. W wynikach wyszukiwania pojawi się niestandardowy element Word Cloud. Kliknij przycisk
Dodaj. W oknie z powiadomieniem, które się pojawi, kliknij OK.
5. Kliknij ikonę Pobierz dane, następnie wybierz pozycję Program Excel i kliknij przycisk
Połącz.
6. Odszukaj plik C:\Dane\R11\R11-01.xlsx i kliknij przycisk Otwórz.
7. W oknie Nawigator zaznacz pozycję Facebook i kliknij przycisk Załaduj.
8. W panelu Wizualizacje kliknij element WordCloud. Przeciągnij z panelu Pola pole Wpis
do panelu Wizualizacje do pola Kategoria. Po chwili zostaną do niego załadowane dane.
9. Kliknij chmurę słowną w głównym panelu. W panelu Wizualizacje kliknij ikonę Format,
a następnie włącz opcję Słowa ignorowane oraz Domyślne słowa ignorowane. Jak się
przekonasz, Power BI Desktop skutecznie usuwa stop-słowa. Aby dodać własne stop-słowo,
wpisz je w polu Słowa.
Jeżeli załadujesz dużo wpisów do chmury słownej, wtedy wszelkie interakcje z raportem będą
odbywały się bardzo powoli. Aby rozwiązać ten problem, podziel wpisy w edytorze Power
Query na słowa, tak jak to zrobiłeś w ćwiczeniach 11.4 i 11.5, a następnie uzyskane dane
załaduj do chmury słownej. Innym ważnym powodem, dla którego powinieneś wykonywać
to przekształcenie, jest możliwość późniejszego prezentowania najczęściej używanych słów
za pomocą innych elementów wizualnych, np. wykresu słupkowego. Tego rodzaju elementy,
w odróżnieniu od chmury słownej, nie mają wbudowanych funkcjonalności pomijania
stop-słów ani dzielenia długich wpisów na pojedyncze słowa.
Gotowe rozwiązanie jest zapisane w pliku R11-07 - rozwiązanie.pbix, w którym zostały
wykorzystane różne techniki opisane w tym rozdziale, m.in. analiza liczby słów i tematów.
Za sprawą bardzo użytecznych powiązań tworzonych pomiędzy elementami wizualnymi
w Power BI można wydobywać więcej kluczowych informacji z dostępnych danych tekstowych.
303
4650570396d9eb2765da56c12eb840b5
4
Podsumowanie
W tym rozdziale poznałeś kilka technik pozyskiwania informacji z danych tekstowych. Niektóre
dane, takie jak daty, kody pocztowe czy adresy, można przetwarzać wprost, ale do analizy tekstu
lepiej nadają się opisane tutaj metody.
We wpisach umieszczonych przez wydawnictwo Microsoft Press na Facebooku wyszukiwałeś
słowa kluczowe i określałeś tematy. Dowiedziałeś się, jak za pomocą kolumny warunkowej można
wyszukiwać niewielką liczbę słów kluczowych. Bardzo skuteczną metodą wyszukiwania dużych
ilości słów dynamicznie ładowanych z zewnętrznych źródeł jest iloczyn kartezjański. Nauczyłeś się
tworzyć niestandardowe funkcje wyszukujące słowa kluczowe. Przekonałeś się, że za pomocą funkcji
Table.Buffer i List.Buffer można ograniczyć liczbę odwołań w kolumnach niestandardowych do
zewnętrznych źródeł danych, dzięki czemu raporty ładują się szybciej.
Poznałeś techniki dzielenia wpisów na słowa i pomijania stop-słów. Dowiedziałeś się, jak scalając
zapytania, możesz filtrować dane w tabelach według słów kluczowych pochodzących z zewnętrznych
źródeł. Aby pominąć stop-słowa, użyłeś lewego antysprzężenia. Technika ta przydaje się podczas
filtrowania wierszy w oparciu o zewnętrzną listę wartości. Aby powiązać podzielone słowa z listą
słów kluczowych, scaliłeś zapytania za pomocą sprzężenia wewnętrznego, które przydaje się również
do filtrowania danych w oparciu o zewnętrzną listę słów.
W tym rozdziale dowiedziałeś się też, jak wyszukiwać wieloczłonowe słowa kluczowe. W tym
celu tymczasowo przekształciłeś wpisy za pomocą funkcji List.Accumulate i tabeli konwersji.
Na koniec poznałeś chmurę słowną — element wizualny w Power BI umożliwiający prezentowanie
danych tekstowych.
Twoja przygoda z analizą tekstu dopiero się zaczyna. W rozdziale 12., „Zaawansowana analiza
tekstu: rozpoznawanie znaczenia”, dowiesz się, jak wykorzystać potęgę sztucznej inteligencji usługi
Azure do przeprowadzania zaawansowanych analiz tekstu. Nauczysz się stosować takie techniki jak
tłumaczenie tekstu, analiza nastroju i wyszukiwanie fraz — i to bez pomocy analityków i programistów.
304
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 12.
Zaawansowana analiza tekstu:

rozpoznawanie znaczenia
Wszystko na tym świecie ma ukryte znaczenie.

— Nikos Kazantzakis

 wykorzystywać siłę sztucznej inteligencji usługi Microsoft Azure Cognitive Services
do analizowania tekstów,
 przekładać zdania w Excelu i Power BI na różne języki za pomocą interfejsu Translator
Text API,
 określać nastrój tekstu za pomocą interfejsu Sentiment Analytics API,
 grupować zdania w paczki w celu zmniejszenia liczby żądań wysyłanych do interfejsu API,
 wyodrębniać frazy ze zdań za pomocą interfejsu Key Phrase API,
 przetwarzać wielojęzykowe dane tekstowe i wykrywać język tekstu za pomocą interfejsu
Language Detection API.
W rozdziale 11., „Podstawy analizy tekstu”, poznałeś najważniejsze przekształcenia umożliwiające

pozyskiwanie informacji z danych tekstowych. Dowiedziałeś się, jak wyszukiwać słowa kluczowe
w kolumnach tekstowych, dzielić zdania na słowa, zliczać słowa i uzyskiwać w ten sposób dodatkowe
cenne informacje. W tym rozdziale pójdziesz krok dalej i nauczysz się przekładać tekst na różne
języki, określać nastroje tekstów, wyodrębniać z nich kluczowe frazy za pomocą chmurowej usługi
Microsoft Cognitive Services. Przy użyciu konektora Power Query Web i kilku funkcji M będziesz
określał znaczenie tekstu — wszystko bez pomocy analityków i programistów.
4650570396d9eb2765da56c12eb840b5
4
Usługa Microsoft Azure Cognitive Services

Aby zaimplementować komputerowe tłumaczenie tekstu lub przeprowadzić analizę jego nastroju,
nie trzeba dzisiaj kończyć wieloletnich studiów informatycznych ani zajmować się praktycznymi
zastosowaniami sztucznej inteligencji w badaniu danych. Jeszcze nie tak dawno temu, aby utworzyć
raport wymagający wykonania takich operacji, trzeba było angażować całe zespoły programistów
i badaczy danych. Ponieważ określanie znaczenia tekstu jest skomplikowanym zadaniem
wymagającym użycia dużych mocy obliczeniowych, tylko niektóre instytucje i firmy były w stanie
mu podołać.
Na szczęście, nadeszła nowa era, w której sztuczna inteligencja jest powszechnie dostępna.
Pojawiły się usługi rozpoznawania języka tekstu i określania jego treści. Jedną z nich jest Microsoft
Azure Cognitive Services obejmująca pięć dziedzin: decyzji, mowy, języka, obrazu i wyszukiwania.
Za pomocą prostego interfejsu API (ang. Application Programming Interface, programistyczny
interfejs aplikacji) można wykorzystywać tę usługę do tworzenia raportów i pozyskiwania informacji
z danych tekstowych.
Zobacz też. Informacje o usłudze Azure Cognitive Services są dostępne na stronie

https://azure.microsoft.com/pl-pl/services/cognitive-services.
W tym rozdziale dowiesz się, jak w Excelu i Power BI tworzyć zapytania przekładające tekst na
inny język, rozpoznające jego nastrój i wyszukujące kluczowe frazy. Wykorzystasz w tym celu dwa
interfejsy API oferowane przez usługę Azure Cognitive Services: Text Analytics i Translator Text
RYSUNEK 12.1. Implementacja w Excelu lub Power BI procesu przedstawionego na tym rysunku nie wymaga
programowania; całą magię realizuje czarna skrzynka o nazwie Azure Cognitive Services
306
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 12.  ZAAWANSOWANA ANALIZA TEKSTU: ROZPOZNAWANIE ZNACZENIA
Zazwyczaj w zaawansowanej analizie tekstu trzeba stosować rozbudowane kombinacje różnych

komponentów realizujących skomplikowane operacje. Na szczęście, firma Microsoft całą tę
złożoność zaimplementowała w usłudze Azure Cognitive Services, którą można traktować jak
magiczną czarną skrzynkę. Po przesłaniu do niej tekstu otrzymuje się jego tłumaczenie w zadanym
języku, ocenę nastroju lub listę wyodrębnionych kluczowych fraz. Dzięki temu cały proces wygląda
bardzo prosto: za pomocą edytora Power Query w Excelu lub Power BI Desktop przygotowuje się
dane, umieszcza je w magicznej skrzynce, następnie wyjmuje wzbogacone informacjami o treści
i umieszcza w raporcie.
Rysunek 12.2 ilustruje najważniejsze kroki tego procesu. Najpierw zapytanie ładuje z zewnętrznego
źródła dane tekstowe, a następnie przesyła do usługi Azure Cognitive Services za pomocą interfejsu
Translator Text API lub Text Analytics API. Uzyskane wyniki umieszczane są w raporcie. Zwróć
uwagę, że wszystkie trzy kroki są wykonywane za jednym razem podczas odświeżania raportu.
RYSUNEK 12.2. Odświeżenie raportu powoduje wykonanie trzech kroków: załadowanie danych z zewnętrznego
źródła, przesłanie ich do usługi Azure Cognitive Services i umieszczenie wyników w raporcie
Usługa Azure Cognitive Services jest przykładem usługi SaaS (ang. software-as-a-service
— oprogramowanie jako usługa). Oznacza to, że nie musisz pisać kodu, który na zewnętrznych
serwerach wykonywałby żądane operacje. Wystarczy, że załadujesz dane, przygotujesz je, prześlesz
do usługi Azure Cognitive Services i uzyskane wyniki umieścisz w raporcie. To wszystko wykonasz
w jednym miejscu przy wsparciu edytora Power Query. Do komunikacji pomiędzy raportem a usługą
wykorzystywana jest metoda HTTP POST i proste funkcje M, które poznasz dalej w tym rozdziale.
Aby zacząć korzystać z interfejsów Translator Text API i Text Analytics API, musisz najpierw
uzyskać do nich klucze w sposób opisany w następnym punkcie rozdziału.
Klucze API i zasoby Azure

Azure Cognitive Services jest usługą chmurową udostępnianą za pomocą prostych w użyciu
interfejsów API. Aby z niej skorzystać, trzeba posiadać konto w usłudze Azure, subskrybować
odpowiednie zasoby i mieć klucze API umożliwiające wysyłanie zapytań HTTP. W tym punkcie
opisane są czynności, które musisz w tym celu wykonać.
307
4650570396d9eb2765da56c12eb840b5
4
Uwaga. Z usługi Azure Cognitive Services można korzystać bezpłatnie bez ograniczeń
czasowych, pod warunkiem że raport zawiera niewielką ilość danych. Ponadto bezpłatnie
można jej używać przez pierwszy miesiąc.
Uzyskanie kluczy interfejsu Translator Text API

Aby w skoroszycie Excela lub raporcie Power BI można było korzystać z interfejsu Translator Text
API, trzeba uzyskać do niego klucz w opisany niżej sposób.
Uwaga. Ponieważ firma Microsoft systematycznie wprowadza nowe funkcjonalności, w czasie

gdy czytasz tę książkę, opisana niżej procedura może już nie być aktualna. W takim przypadku
skorzystaj z instrukcji zawartej na stronie https://www.microsoft.com/pl-pl/translator/business/
trial/#get-started.
1. Zaloguj się do usługi Azure.

a. Jeżeli nie masz konta, załóż je na stronie https://azure.microsoft.com.
b. Jeżeli masz konto, zaloguj się na stronie https://portal.azure.com.
2. Aby uzyskać dostęp do interfejsu Translator Text API, otwórz stronę
https://portal.azure.com/#create/Microsoft.CognitiveServicesTextTranslation.
3. Wykonaj poniższe kroki.
a. W polu Nazwa wpisz Translacja.
b. W rozwijanej liście Subskrypcja wybierz posiadaną opcję subskrypcji.
c. W rozwijanej liście Warstwa cenowa wybierz odpowiednią opcję płatności. Jeżeli
co miesiąc będziesz wysyłał nie więcej niż 2 mln znaków, wybierz bezpłatną opcję F0.
Więcej informacji na temat płatności znajdziesz na stronie https://azure.microsoft.com/
pl-pl/pricing/details/cognitive-services/translator-text-api.
d. W rozwijanej liście Grupa zasobów wybierz istniejącą grupę lub utwórz nową. Grupa
zasobów służy do łączenia zasobów i zarządzania nimi w usłudze Azure. Jeżeli pierwszy
raz korzystasz z usługi, utwórz nową grupę o nazwie Zasoby-translacyjne.
e. W rozwijanej liście Lokalizacja grupy zasobów wybierz pozycję (Europa) Europa Zachodnia.
f. Kliknij przycisk Utwórz.
4. W panelu po lewej stronie kliknij odnośnik Pulpit nawigacyjny, a następnie odnośnik
Translacja. W panelu Translacja — Szybki start kliknij po lewej stronie w sekcji
ZARZĄDZANIE ZASOBAMI odnośnik Klucze.
5. Jak pokazuje rysunek 12.3, zostaną utworzone dwa klucze, które wykorzystasz w ćwiczeniu
12.1. Nie musisz ich teraz zapisywać. Zawsze możesz zalogować się do portalu Azure
i uzyskać do nich dostęp, wykonując kroki od 1. do 4.
Uwaga. Nie udostępniaj kluczy innym osobom. Dalej w tym rozdziale dowiesz się więcej
o zabezpieczaniu kluczy w edytorze Power Query.
308
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 12.3. Skopiuj do schowka jeden z kluczy dostępnych w sekcji Klucze zasobu Translacja
Teraz, gdy wiesz już, jak przygotować zasoby interfejsu Translator Text API w usłudze Azure
i uzyskać klucze, zrób to samo dla interfejsu Text Analytics API, niezbędnego w analizie nastroju
tekstu i wyodrębnianiu z niego kluczowych fraz.
Uzyskanie kluczy interfejsu Text Analytics API

W tym podpunkcie dowiesz się, jak utworzyć zasoby interfejsu Translator Text API w usłudze Azure
i uzyskać jego klucze, aby w skoroszycie Excela lub raporcie Power BI analizować nastroje tekstów
lub wyodrębniać z nich kluczowe frazy. Wykonaj opisane niżej kroki.
1. Zaloguj się do usługi Azure.
a. Jeżeli nie masz konta, załóż je na stronie https://azure.microsoft.com.
b. Jeżeli masz konto, zaloguj się na stronie https://portal.azure.com.
2. Aby uzyskać dostęp do interfejsu Translator Text API, otwórz stronę
https://portal.azure.com/#create/Microsoft.CognitiveServicesTextAnalytics.
3. Wykonaj poniższe kroki.
a. W polu Nazwa wpisz Analityka.
b. W rozwijanej liście Subskrypcja wybierz posiadaną opcję subskrypcji.
c. W rozwijanej liście Lokalizacja wybierz (Europa) Europa Zachodnia.
d. W rozwijanej liście Warstwa cenowa wybierz odpowiednią opcję płatności. Jeżeli
miesięczna liczba Twoich transakcji nie przekroczy 5000, wybierz bezpłatną opcję F0.
Więcej informacji na temat płatności znajdziesz na stronie https://azure.microsoft.com/
pl-pl/pricing/details/cognitive-services/text-analytics.
e. W rozwijanej liście Grupa zasobów wybierz istniejącą grupę lub utwórz nową. Jeżeli
pierwszy raz korzystasz z usługi, utwórz nową grupę o nazwie Zasoby-analityczne.
309
4650570396d9eb2765da56c12eb840b5
4
f. W rozwijanej liście Lokalizacja grupy zasobów wybierz pozycję (Europa) Europa Zachodnia.
g. Kliknij przycisk Utwórz.
4. W panelu po lewej stronie kliknij odnośnik Pulpit nawigacyjny, a następnie odnośnik
Analityka. W panelu Analityka — Szybki start kliknij po lewej stronie w sekcji
ZARZĄDZANIE ZASOBAMI odnośnik Klucze.
5. Podobnie jak na rysunku 12.3, zostaną utworzone dwa klucze, które wykorzystasz w ćwiczeniach
12.2 do analizy nastrojów tekstów i 12.4 do wyodrębnienia z nich kluczowych fraz.
Uwaga. Jak już wspomniałem, nie udostępniaj kluczy innym osobom. Dalej w tym rozdziale
dowiesz się więcej o zabezpieczaniu kluczy w edytorze Power Query.
Uwagi dotyczące korzystania z usługi Azure Cognitive Services

za pomocą edytora Power Query
Techniki tłumaczenia tekstu, analizy jego nastroju i wyszukiwania kluczowych fraz, które poznasz w tym
rozdziale, są niezwykle przydatne. Zanim jednak zaczniesz z nich korzystać, musisz poznać ich wymagania.
Jak się przekonasz dalej w tym rozdziale, integracja Excela z usługą Azure Cognitive Services
wymaga głębszej znajomości edytora Power Query. Jednak opisane tu ćwiczenia są dość proste,
a schematy postępowania, których się nauczysz, będziesz mógł wykorzystać w Excelu i Power BI
Desktop do analizy dowolnego tekstu.
Cały proces nie wymaga głębokiej wiedzy z dziedziny analizy danych, uczenia maszynowego
czy programowania. Każdy użytkownik Excela, po wykonaniu opisanych tu ćwiczeń, będzie mógł
od razu korzystać z usługi Azure Cognitive Services w swoich narzędziach i pozyskiwać z tekstu
cenne informacje biznesowe.
Liczba żądań wysyłanych do interfejsu API

Azure Cognitive Services jest usługą płatną. Pamiętaj, że w przypadku intensywnego korzystania
z interfejsu API za pomocą edytora Power Query możesz wyczerpać limit bezpłatnych żądań i stanąć
przed koniecznością skorzystania z płatnych opcji. Aby tego uniknąć, przestrzegaj opisanych niżej zaleceń.
Używaj niewielkich ilości danych. Podczas tworzenia zapytań w edytorze Power Query używaj
niewielkich zbiorów danych. Aby chwilowo zmniejszyć ilość danych przesyłanych do usługi Azure
Cognitive Services, stosuj przekształcenie Zachowywanie pierwszych wierszy.
Wyłącz ładowanie danych do podglądu w tle. Domyślnie, o czym prawdopodobnie nie wiesz,
edytor Power Query ładuje dane w tle, aby przechodzenie pomiędzy zapytaniami lub krokami w panelu
Zastosowane kroki odbywało się płynnie. Dzięki temu w panelu podglądu szybko pojawiają się
przekształcane dane. W ten sposób można jednak szybko osiągnąć limit żądań. Aby tego uniknąć,
wyłączaj w każdym raporcie ładowanie danych w tle. W tym celu w edytorze Power Query kliknij
kartę Plik, a następnie polecenia Opcje i ustawienia i Opcje zapytania. W oknie, które się pojawi,
kliknij w sekcji Bieżący skoroszyt (w Excelu) lub Bieżący plik (w Power BI Desktop) polecenie
Ładowanie danych i usuń zaznaczenie opcji Zezwalaj na pobieranie podglądu danych w tle (patrz
rysunek 12.4). Opcję tę wyłączaj w każdym skoroszycie Excela i raporcie Power BI, w którym
będziesz korzystał z usługi Azure Cognitive Services. Jeżeli tego nie zrobisz, edytor Power Query
będzie niepotrzebnie wywoływał interfejs API w celu załadowania w tle danych do panelu podglądu.
310
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 12.4. W oknie „Opcje zapytania” wyłączaj opcję ładowania w tle danych do panelu podglądu
Pamiętaj, że nawet gdy wyłączysz tę opcję, edytor Power Query po każdorazowym otwarciu go
i wybraniu określonych zapytań będzie odwoływał się do interfejsu API usługi Azure Cognitive
Services, aby załadować do panelu podglądu najnowsze dane.
Stosuj przyrostowe odświeżanie danych. W wersji Power BI Premium dostępna jest opcja
przyrostowego odświeżania danych zapobiegająca intensywnemu odwoływaniu się do interfejsu
API. W Excelu i bezpłatnej wersji Power BI nie ma tej opcji. Przy każdorazowym odświeżeniu
raportu zapytanie ładuje wszystkie dane, ponieważ wcześniej załadowane dane nie są nigdzie
przechowywane. Jeżeli będziesz często odświeżał raport wykorzystujący usługę Azure Cognitive
Services, wielokrotnie wyślesz do niej te same dane, co może skutkować osiągnięciem limitu
odwołań do interfejsu API. Aby tego uniknąć, twórz opisane w tym rozdziale zapytania,
wykorzystując kilka plików Excela. Do każdego pliku będą wtedy przyrostowo ładowane dane
obejmujące tylko określony przedział czasu. Następnie za pomocą opisanej w rozdziale 3.,
„Łączenie danych z kilku źródeł”, techniki importowania danych z plików zapisanych w folderze
będziesz mógł w jednym raporcie scalić wszystkie fragmenty, odwołując się do interfejsu API tylko
w niezbędnym zakresie.
Prywatność i bezpieczeństwo danych

Sprawdź, czy w Twojej firmie można korzystać z usługi Azure Cognitive Services. Wprawdzie Azure
należy do najbardziej bezpiecznych usług, jednak wewnętrzne przepisy mogą zabraniać stosowania
jej do przetwarzania poufnych danych. Jeżeli nie masz pewności, czy możesz korzystać z usługi,
skontaktuj się ze swoim działem IT.
Kiedy będziesz chciał udostępnić raport osobom spoza swojego zespołu, pamiętaj, aby wcześniej
usunąć klucze API. Więcej na ten temat dowiesz się dalej w tym rozdziale.
311
4650570396d9eb2765da56c12eb840b5
4
Planowane odświeżanie raportów

Raporty tworzone za pomocą opisanych tutaj technik można odświeżać jedynie przy użyciu Excela
i Power BI Desktop. Próba planowanego odświeżenia z wykorzystaniem usługi Power BI zakończy się
komunikatem o błędzie. Można wprawdzie opracować własny konektor umożliwiający planowane
odświeżanie lokalnie zapisanych raportów za pomocą bramy On-Premises Gateway, ale sposób ten
wymaga umiejętności programistycznych i jego opis wykracza poza zakres tej książki.
Wskazówka. Zważywszy na opisane wymagania, zalecane jest stosowanie opisanych w tym

rozdziale technik do doraźnego analizowania niewielkich ilości danych i testowania większych
procesów, docelowo realizowanych bez użycia Excela i Power BI Desktop.
Tłumaczenie tekstu
Automatyczne tłumaczenie tekstu za pomocą edytora Power Query w Excelu lub Power BI Desktop
może być bardzo dobrym sposobem pozyskiwania informacji z treści napisanych w różnych językach.
W tym podrozdziale dowiesz się, jak tłumaczyć kolumny tekstowe za pomocą interfejsu Translator
Text API usługi Azure Cognitive Services. Na pewno korzystałeś już z tłumaczy internetowych, ręcznie
kopiując i wklejając teksty napisane w obcych językach. Opisana tutaj technika pozwoli Ci zautomatyzować
ten proces i pozyskiwać z danych tekstowych niedostępne wcześniej informacje (patrz rysunek 12.5).
RYSUNEK 12.5. Za pomocą Excela lub Power BI Desktop

możesz zautomatyzować proces tłumaczenia serii tekstów
Opis interfejsu Translator Text API

Funkcjonalności interfejsu Translator Text API są rozbudowane, a ich opis bardzo obszerny.
W tym rozdziale skupimy się na najbardziej podstawowych metodach tłumaczenia pojedynczych
komunikatów. Wykorzystamy w tym celu najnowszą wersję 3.0 interfejsu API, której pełny opis
jest dostępny na stronie https://docs.microsoft.com/pl-pl/azure/cognitive-services/translator/
reference/v3-0-reference.
Usługa tłumaczenia polega na wysyłaniu żądania na adres URL https://api.cognitive.micro
softtranslator.com/translate uzupełniony o parametry api-version z numerem wersji interfejsu
oraz to z dwuznakowym oznaczeniem docelowego języka. Poniżej przedstawiony jest przykładowy
adres wykorzystywany do tłumaczenia tekstu na język polski za pomocą interfejsu API w wersji 3.0:
https://api.cognitive.microsofttranslator.com/translate?api-version=3.0&to=pl
Aby przetłumaczyć tekst na inny język, użyj parametru to z odpowiednim dwuznakowym kodem. Lista
obsługiwanych języków jest dostępna na stronie https://docs.microsoft.com/pl-pl/azure/cognitive-services/
translator/languages. Za pomocą poniższego adresu można przetłumaczyć tekst na język angielski:
https://api.cognitive.microsofttranslator.com/translate?api-version=3.0&to=en
312
4650570396d9eb2765da56c12eb840b5
4
Aby przetłumaczyć tekst, musisz uwierzytelnić się w usłudze, wysyłając do niej klucz API. W ćwiczeniu
12.1 dowiesz się, jak możesz to zrobić z wykorzystaniem nagłówka Ocp-Apim-Subscription-Key.
Oprócz tego musisz przesłać tekst przeznaczony do przetłumaczenia. W wersji 3.0 interfejsu API
tekst należy umieścić w ciele żądania w formacie JSON, tak jak niżej:
[
{"Text":"Hello world"}
]
W ten sposób można przesłać maksymalnie 25 komunikatów, każdy o maksymalnej długości
1000 znaków (włącznie ze spacjami), przy czym łączna długość wszystkich komunikatów nie może
przekroczyć 5000 znaków. Aby podzielić dłuższy komunikat na mniejsze części, akceptowane przez
interfejs API, użyj metody BreakSentence opisanej na stronie https://docs.microsoft.com/pl-pl/
azure/cognitive-services/translator/reference/v3-0-break-sentence. Ponieważ w tym rozdziale nie ma
miejsca na szczegółowe opisanie wszystkich technik, skupimy się na tłumaczeniu pojedynczych
komunikatów.
Ćwiczenie 12.1. Proste tłumaczenie

W tym ćwiczeniu zaimplementujesz prosty proces tłumaczenia pojedynczego komunikatu „Hello
world” za pomocą interfejsu Translator Text API w wersji 3.0.
Część I. Utworzenie treści żądania w formacie JSON

W pierwszej części ćwiczenia dowiesz się, jak utworzyć w formacie JSON komunikat przeznaczony
do przetłumaczenia. Komunikat ten umieścisz w ciele żądania, które wyślesz do interfejsu API.
W Excelu: kliknij kartę Dane, a następnie polecenia Z innych źródeł/Puste zapytanie.
W Power BI Desktop: rozwiń menu Pobierz dane i wybierz Puste zapytanie.
2. W pasku formuły wpisz następujący kod zawierający tekst przeznaczony do przetłumaczenia:
= [Text = "Hello world"]

Powyższa formuła, zapisana w formacie JSON, przyjmie następującą postać:
{Text = "Hello world"}
Zapisz rekord w formacie JSON, umieszczając zawartość paska formuły w argumencie
funkcji Json.FromValue:
= Json.FromValue([Text = "Hello world"])
3. W panelu podglądu pojawi się ikona pliku CSV. Kliknij ją prawym przyciskiem myszy
i wybierz polecenie Plik tekstowy. Pojawi się tabela zawierająca jeden wiersz z komunikatem
w żądanym formacie:
{Text = "Hello world"}
4. Teraz utwórz cały blok danych w formacie JSON, włącznie z nawiasami klamrowymi. W tym
celu w panelu Zastosowane kroki kliknij krok Źródło, a następnie zmień kod w pasku formuły,
umieszczając rekord wewnątrz nawiasów klamrowych, tak jak niżej:
= Json.FromValue( { [Text = "Hello world"] } )
313
4650570396d9eb2765da56c12eb840b5
4
W ten sposób umieścisz rekord wewnątrz listy. Zaznacz w panelu Zastosowane kroki krok
Zaimportowano plik tekstowy. W panelu podglądu zobaczysz efekt wprowadzonych
modyfikacji. Tabela będzie zawierała komunikat zapisany w wymaganym formacie JSON:
[{"Text":"Hello world"}]
5. Teraz, gdy wiesz już, jak przygotowywać komunikaty w formacie JSON, usuń Zapytanie1. Za chwilę
wykorzystasz funkcję Json.FromValue w innej funkcji M, wysyłającej żądanie do interfejsu API.
Wskazówka. W formacie JSON rekordy i listy definiuje się w odwrotny sposób w porównaniu
z językiem M. W języku M nawiasy kwadratowe stosuje się do definiowania rekordów, natomiast
w formacie JSON do definiowania listy. Z kolei nawiasy klamrowe w języku M definiują listę,
a w JSON rekord. Pamiętaj o tym podczas tworzenia w języku M formuł przygotowujących
w formacie JSON dane do wysłania do interfejsu API.
Część II. Utworzenie parametru dla klucza API

Teraz utwórz parametr dla klucza, który wykorzystasz do wysyłania żądań do interfejsu API.
Wykonaj poniższe kroki.
6. Zaloguj się do portalu usługi Azure i ponownie wykonaj kroki 4. i 5., opisane w podpunkcie
„Uzyskanie kluczy interfejsu Translator Text API”. Skopiuj do schowka jeden z kluczy
interfejsu Translator Text API.
7. Aby utworzyć parametr dla skopiowanego wyżej klucza, wykonaj poniższe kroki.
a. W karcie Strona główna rozwiń ikonę Zarządzaj parametrami i wybierz polecenie Nowy parametr.
b. W oknie Parametry, które się pojawi, w polu Nazwa wpisz KluczAPI, a następnie w polu
Wartość bieżąca wklej klucz, który skopiowałeś w kroku 6. (patrz rysunek 12.6). Kliknij
OK, aby zamknąć okno.
RYSUNEK 12.6. Utworzenie parametru dla klucza Translator Text API
314
4650570396d9eb2765da56c12eb840b5
4
Część III. Przygotowanie żądania

W tej części ćwiczenia przygotujesz i wyślesz żądanie, na które otrzymasz odpowiedź
z przetłumaczonym komunikatem. Wykonaj poniższe kroki.
8. Utwórz puste zapytanie o nazwie Przetłumaczony komunikat.
9. Zaznacz nowe zapytanie w panelu Zapytania, a następnie w karcie Strona główna
kliknij ikonę Edytor zaawansowany i wpisz poniższy kod:
let
Źródło = Web.Contents(
"https://api.cognitive.microsofttranslator.com/" &
"translate?api-version=3.0&to=pl",
[
Headers = [
#"Ocp-Apim-Subscription-Key" = KluczAPI,
#"Content-Type" = "application/json"
],
Content = Json.FromValue({[Text = "Hello world"]})
]
)
in
Źródło
Przyjrzyjmy się bliżej powyższemu wyrażeniu. Główną funkcją jest tu Web.Contents. Funkcja ta
jest używana w zapytaniach tworzonych za pomocą polecenia Pobierz dane/Inne źródła/Internet.
Uwaga. Zazwyczaj w celu zaimportowania danych z internetu nie trzeba pisać od podstaw
formuł M, tak jak w tym ćwiczeniu. Zamiast tego wystarczy użyć polecenia Dane/Z sieci Web
w Excelu lub Pobierz dane/Internet w Power BI Desktop, a następnie w oknie Z sieci Web
wpisać odpowiedni adres URL. Po wybraniu opcji Zaawansowane można nawet definiować
nagłówki HTTP. Jeżeli jednak trzeba przesłać treść w ciele żądania, wtedy należy utworzyć
formułę M z funkcją Web.Contents.
Funkcja Web.Contents ma dwa parametry, czyli adres URL i opcje. W drugim argumencie
umieszcza się wszystkie dane, m.in. nagłówki i treść, które mają znaleźć się w żądaniu.
W powyższej formule rekord Headers składa się z par klucz-wartość zawierających nagłówki
HTTP wymagane w żądaniu wysyłanym do interfejsu API.
Nagłówek Ocp-Apim-Subscription-Key zawiera wartość parametru KluczAPI, który
utworzyłeś w kroku 7. Ponieważ w nazwie nagłówka użyte są myślniki, które w języku M
są znakami specjalnymi, nazwa została umieszczona wewnątrz cudzysłowów i poprzedzona
znakiem # . Drugi klucz w rekordzie Headers zawiera inny wymagany nagłówek
Content-Type .
Drugi rekord, Content, zawiera wynik funkcji Json.Value opisanej w kroku 4.
Zwróć uwagę, że w funkcji Web.Contents możesz umieścić również inne rekordy, m.in
RelativePath i Query, do których możesz przenieść fragmenty adresu URL. Poniżej
przedstawiona jest formuła M zawierająca nowe elementy wyróżnione pogrubioną czcionką.
Jak widać, teraz adres URL zawiera tylko nazwę domeny.
315
4650570396d9eb2765da56c12eb840b5
4
let
Źródło = Web.Contents(
"https://api.cognitive.microsofttranslator.com",
[
RelativePath = "translate",
Query = [
#"api-version" = "3.0",
to = "pl"
],
Headers = [
],
]
)
in
Źródło
Wskazówka. Stosowanie rekordów RelativePath i Query w funkcji Web.Contents ma kilka zalet.

Użycie pierwszego z nich zwiększa prawdopodobieństwo, że w usłudze Power BI będzie można
zaplanować odświeżanie złożonego zapytania. Natomiast w przypadku użycia rekordu Query
silnik języka M będzie automatycznie umieszczał w żądaniu opcje kodowania treści, co pozwoli
uniknąć nieprzewidzianych efektów wywołanych użyciem nietypowych znaków w adresie URL.

11. Jeżeli w panelu podglądu pojawi się komunikat, kliknij przycisk Edytuj poświadczenia.
Zobaczysz okno Dostęp do zawartości sieci Web. Kliknij opcję Anonimowy, a następnie
przycisk Połącz.
12. W panelu podglądu pojawi się ikona api.cognitive.microsofttranslator.com. Kliknij ją prawym
przyciskiem myszy i wybierz polecenie JSON. Pojawi się odpowiedź na wysłane żądanie
zawierające listę z jednym rekordem.
13. Ponieważ wysłałeś tylko jeden komunikat, kliknij odnośnik Record. W panelu podglądu
pojawi się rekord zawierający klucze detectedLanguages (wykryte języki) oraz translations
(tłumaczenia). Gdy klikniesz puste miejsce w komórce detectedLanguages, pojawi się rekord
zawierający pary language=en i score=1. Wartości te oznaczają, że usługa określiła język
źródłowy jako angielski ze 100% pewnością. Ponieważ Twoim celem jest przetłumaczenie
tekstu na język polski, możesz pominąć ten rekord i wyszczególnić listę translations.
14. W polu translations kliknij odnośnik List.
15. W panelu podglądu pojawi się lista zawierająca jeden rekord. Kliknij odnośnik Record.
Pojawi się rekord zawierający pola text i to. Pierwsze z nich zawiera przetłumaczony tekst.
16. Kliknij prawym przyciskiem myszy komórkę zawierającą tekst Cześć ludzie i z podręcznego
menu wybierz polecenie Wyszczególnij.
17. Załaduj zapytanie Przetłumaczony komunikat do skoroszytu Excela lub raportu Power BI
i zapisz go.
316
4650570396d9eb2765da56c12eb840b5
4
Udostępnianie raportu bez klucza API

Jeżeli zamierzasz udostępnić innej osobie skoroszyt lub raport, który utworzyłeś w ćwiczeniu 12.1,
pamiętaj, że klucz API jest w nim zapisany w niezabezpieczony sposób i będzie go mógł odczytać
każdy, kto ten raport otworzy. W rozdziale 8., „Praca grupowa”, opisanych zostało kilka metod
udostępniania skoroszytów i raportów innym osobom. Aby nie ujawniać klucza API, musisz go
zaciemnić, co jest bardzo prostą czynnością. Przed udostępnieniem skoroszytu lub raportu wykonaj
poniższe kroki.
1. Otwórz plik, który utworzyłeś w ćwiczeniu 12.2, i uruchom edytor Power Query.
(Jeżeli nie zapisałeś pliku, otwórz R12-01 - rozwiązanie.xlsx lub R12-01 - rozwiązanie.pbix).
2. Zaznacz parametr KluczAPI.
3. W polu Wartość bieżąca wpisz następujący tekst:
Tutaj wklej swój klucz

4. Udostępniając raport innej osobie, poinformuj ją, aby wykonała kroki 1. i 2., a następnie
w miejsce powyższego tekstu wkleiła własny klucz API. Dopiero wtedy będzie mogła
odświeżyć raport.
W programie Power BI możesz pójść krok dalej i dla wygody użytkownika utworzyć szablon
w sposób opisany w rozdziale 8. Użytkownik przed otwarciem raportu będzie mógł wpisać swój klucz.
Jak to zrobić, będziesz wiedział po wykonaniu kolejnego ćwiczenia. Wcześniej jednak dowiesz się,
jak można wysyłać wiele żądań do interfejsu API.
Ćwiczenie 12.2. Tłumaczenie wielu komunikatów

W tym ćwiczeniu przekształcisz zapytanie w funkcję, której będziesz mógł używać do tłumaczenia
wielu komunikatów. Jak pamiętasz, w jednym żądaniu można do interfejsu Translator Text API
wysłać 25 komunikatów, co jest pewnym utrudnieniem, jeżeli tekstów do przetłumaczenia jest dużo.
W tym ćwiczeniu dowiesz się, jak w prosty sposób zaimplementować tłumaczenie dużej liczby
komunikatów, wysyłając je po jednym w każdym żądaniu.
1. Otwórz skoroszyt Excela lub raport Power BI, który utworzyłeś w ćwiczeniu 12.1.
Jeżeli nie zapisałeś pliku, otwórz R12-01 - rozwiązanie.xlsx lub R12-01 - rozwiązanie.pbix.
2. Uruchom edytor Power Query.
3. Wykonaj poniższe kroki, aby utworzyć nowe parametry, które wykorzystasz w zapytaniu
zamiast statycznie wpisanych wartości parametrów text i to w adresie URL.
Parametr text
a. W karcie Strona główna rozwiń ikonę Zarządzaj parametrami i wybierz polecenie
Nowy parametr.
b. W oknie Parametry, które się pojawi, w polu Nazwa wpisz OryginalnyTekst, a w polu
Wartość bieżąca wpisz Hello world. Kliknij OK, aby zamknąć okno.
Parametr to
c. Wykonaj ponownie punkt 3a, ale tym razem w polu Nazwa wpisz JęzykDocelowy.
d. W polu Wartość bieżąca wpisz pl. Kliknij OK, aby zamknąć okno.
317
4650570396d9eb2765da56c12eb840b5
4
4. W panelu Zapytania zaznacz zapytanie Przetłumaczony komunikat i kliknij ikonę

Teraz w formule M zastąp statycznie wpisane wartości parametrami, które utworzyłeś
w kroku 3. Poniżej pokazany jest fragment wyrażenia, które pojawi się w edytorze.
Pogrubioną czcionką wyróżnione są wartości pl i Hello world, które musisz zmienić.
(Zwróć uwagę, że wyrażenie, aby było bardziej czytelne, jest sformatowane nieco inaczej
niż w edytorze).
= Json.Document(
Web.Contents(
"https://api.cognitive.microsofttranslator.com", [
Query = [
to = "pl"
],
Headers = [
#"Ocp-Apim-Subscription-Key" = APIKey,
],
]
)
)
1. Zastąp tekst "Hello world" parametrem OryginalnyTekst, a tekst "pl" parametrem
JęzykDocelowy. Poniżej przedstawiona jest zmodyfikowana formuła:
= Json.Document(
Web.Contents(
"https://api.cognitive.microsofttranslator.com", [
Query = [
to = JęzykDocelowy
],
Headers = [
],
Content = Json.FromValue({[Text = OryginalnyTekst]})
]
)
)
6. W panelu Zastosowane kroki kliknij ostatni krok i sprawdź, czy w panelu podglądu pojawi
jest tekst Cześć ludzie. W ten sposób możesz się upewnić, że poprawnie wprowadziłeś
wszystkie zmiany.
7. Teraz jesteś gotów przekształcić zapytanie Przetłumaczony komunikat w niestandardową
funkcję.
a. W panelu Zapytania kliknij prawym przyciskiem myszy zapytanie Przetłumaczony
komunikat i z podręcznego menu wybierz polecenie Utwórz funkcję.
b. W oknie o tej samej nazwie, które się pojawi, w polu Nazwa funkcji wpisz FnTłumacz
i kliknij przycisk OK.
318
4650570396d9eb2765da56c12eb840b5
4
8. Załaduj tabelę zawierającą kilka komunikatów, przedstawionych na rysunku 12.5, i wykonaj

poniższe kroki, aby przetłumaczyć je na język polski.
a. W karcie Strona główna kliknij ikonę Nowe źródło i wybierz polecenia Plik, Excel.
b. W oknie Importowanie danych, które się pojawi, odszukaj plik C:\Dane\R12\R12-02.xlsx
i kliknij przycisk Otwórz.
c. W oknie Nawigator, które się pojawi, zaznacz tabelę OryginalnyTekst i kliknij przycisk OK.
9. Zmień nazwę nowego zapytania na Przetłumaczony tekst.
10. Zaznacz nowe zapytanie, a następnie w karcie Dodaj kolumnę kliknij ikonę Wywołaj funkcję
niestandardową.
11. W oknie o tej samej nazwie, które się pojawi, w polu Nazwa nowej kolumny wpisz
Przetłumaczony tekst.
12. W rozwijanej liście Zapytanie funkcji wybierz pozycję FnTłumacz.
13. Zwróć uwagę, że w rozwijanej liście KluczAPI (opcjonalnie) została niepoprawnie wybrana
pozycja Oryginalny tekst. Niestety, w tym oknie nie można w argumentach funkcji
umieszczać zdefiniowanych parametrów. Pozostaw na razie te ustawienia bez zmian,
zajmiesz się nimi za chwilę.
14. W pierwszej rozwijanej liście pod etykietą Oryginalny tekst (opcjonalnie) wskaż pozycję
Wybierz kolumnę, a w drugiej liście wybierz pozycję Oryginalny tekst.
15. W polu pod etykietą JęzykDocelowy (opcjonalnie) wpisz pl. Kliknij OK, aby zamknąć okno.
= Table.AddColumn(#"Zmieniono typ", "Przetłumaczony tekst",
each FnTłumacz([Oryginalny tekst], [Oryginalny tekst], "pl"))
Zastąp pierwszy fragment [Oryginalny tekst] nazwą parametru KluczAPI, tak jak niżej:
= Table.AddColumn(#"Zmieniono typ", "Przetłumaczony tekst",
each FnTłumacz(KluczAPI, [Oryginalny tekst], "pl"))
W zależności od ustawień prywatności w oknie Opcje zapytania w panelu podglądu może
pojawić się komunikat Wymagane są informacje dotyczące prywatności danych.
17. Kliknij przycisk Kontynuuj. Pojawi się okno Poziomy prywatności, w którym możesz określić
poziomy prywatności danych. Aby zabezpieczyć się przed wysłaniem poufnych danych do
niezaufanych usług, wybierz dla pliku R12-02.xlsx i usługi Azure Cognitive Services poziomy
prywatności przedstawione na rysunku 12.7.
RYSUNEK 12.7. Ustaw poziomy prywatności umożliwiające wysyłanie komunikatów przeznaczonych do przetłumaczenia
319
4650570396d9eb2765da56c12eb840b5
4
a. W rozwijanej liście obok pola zawierającego nazwę katalogu c:\ wybierz pozycję
Organizacyjne.
b. W rozwijanej liście obok pola zawierającego adres URL
https://api.cognitive.microsofttranslator.com wybierz pozycję Organizacyjne.
c. Kliknij przycisk Zapisz.
Wskazówka. Jeżeli przez pomyłkę wybierzesz inne poziomy prywatności, np. Publiczne
i Organizacyjne, wtedy żądanie nie zostanie poprawnie obsłużone. Aby w takim przypadku
usunąć poziomy prywatności, kliknij w karcie Strona główna ikonę Ustawienia źródła danych
i wyczyść uprawnienia dla obu źródeł danych.
W panelu podglądu pojawią się przetłumaczone komunikaty. W każdym wierszu kolumny

Przetłumaczony tekst będzie widoczny napis Cześć ludzie. Zamknij edytor i załaduj wyniki
do raportu. Jeżeli używasz programu Power BI Desktop, zapisz raport. Dalej dowiesz się,
jak możesz go udostępnić bez ujawniania klucza API.
Udostępnianie raportu bez ujawniania klucza API

Jeżeli ćwiczenie 12.2 wykonałeś w programie Power BI Desktop, w tej części ćwiczenia dowiesz się,
jak na podstawie raportu utworzyć szablon, za pomocą którego będziesz mógł udostępniać raport bez
ujawniania klucza API. Jeżeli nie wykonałeś poprzedniego ćwiczenia, otwórz plik R12-02 - rozwiązanie.pbix.
Uwaga. Jeżeli interesuje Cię wyłącznie przetwarzanie danych w Excelu, pomiń tę sekcję i otwórz
plik R12-02 - rozwiązanie.xlsx, w którym do wprowadzenia klucza API zostały zastosowane
techniki opisane w rozdziale 8., „Praca grupowa”. Poinformuj osobę, której udostępnisz skoroszyt,
aby w odpowiedniej komórce wpisała swój klucz. Zastosowany sposób rozwiązuje również
problem komunikatu Formula.Firewall opisany też w 8. rozdziale.
Teraz na podstawie raportu Power BI utwórz szablon, który sprawi, że nie ujawnisz swojego
klucza API, a jednocześnie inny użytkownik, który będzie chciał otworzyć raport, będzie mógł
w wygodny sposób wpisać własny klucz. Jak pamiętasz, szablon (plik .pbit) utworzyłeś już
w rozdziale 8. Tutaj ten proces jest opisany ponownie, ponieważ jest to przypadek specjalny: są dwa
parametry, OryginalnyTekst i JęzykDocelowy, które nie powinny być widoczne w podczas otwierania
szablonu, natomiast powinien pojawić się parametr KluczAPI.
1. Otwórz raport, który utworzyłeś w ćwiczeniu 12.2, lub gotowy plik R12-02 - rozwiązanie.pbix.
(W drugim przypadku zmień wartość parametru KluczAPI. W tym celu w karcie Strona
główna kliknij ikonę Edytuj zapytania, a następnie w panelu Zapytania zaznacz parametr
KluczAPI i w polu Wartość bieżąca wpisz swój klucz).
W karcie Strona główna kliknij ikonę Edytuj zapytania. W edytorze Power Query w panelu
Zapytania będą widoczne trzy parametry: KluczAPI, OryginalnyTekst i JęzykDocelowy.
Dwa ostatnie są wykorzystywane w niestandardowej funkcji, którą utworzyłeś wcześniej.
2. Aby parametry OryginalnyTekst i JęzykDocelowy nie były pokazywane podczas otwierana
szablonu, przekształć je w zapytania.
320
4650570396d9eb2765da56c12eb840b5
4
a. W panelu Zapytania kliknij prawym przyciskiem myszy parametr OryginalnyTekst

i z podręcznego menu wybierz polecenie Konwertuj do zapytania.
b. Kliknij prawym przyciskiem myszy parametr JęzykDocelowy i wybierz polecenie
Konwertuj do zapytania.
3. W karcie Strona główna kliknij ikonę Zamknij i zastosuj. W głównym oknie programu
Power BI Desktop kliknij w karcie Plik polecenia Eksportuj/Szablon usługi Power BI.
4. W oknie Eksportowanie szablonu, które się pojawi, wpisz krótką instrukcję dla użytkownika
i kliknij ikonę przycisk OK.
5. W oknie Zapisywanie jako, które się pojawi, wpisz nazwę szablonu i kliknij przycisk Zapisz.
Gotowe rozwiązanie jest zapisane w pliku R12-02 - rozwiązanie.pbit. Alternatywne rozwiązanie
zawiera plik R12-02 - rozwiązanie.xlsx.
Rysunek 12.8 pokazuje widoki, jakie zobaczy użytkownik otwierający szablon Power BI
lub skoroszyt Excela.
RYSUNEK 12.8. Raport Power BI (w postaci szablonu) i skoroszyt Excela (wykorzystujący nazwany zakres
komórek) możesz udostępniać innym użytkownikom bez ujawniania swojego klucza API
Wskazówka. Aby unieważnić klucz API, zaloguj się do portalu usługi Azure, przejdź do zasobów
tłumaczeniowych i w oknie Translacja — Klucze kliknij przyciski Wygeneruj ponownie klucz 1
i Wygeneruj ponownie klucz 2.
Analiza nastroju tekstu

Krytycznym elementem, od którego zależy kondycja firmy lub instytucji, jest ciągły proces
gromadzenia i analizowania opinii klientów i ulepszania ich obsługi. Być może gromadzisz już
opinie klientów zapisane w różnych formatach. Najtrudniejsza jest analiza formatu tekstowego.
Jak można wymiernie ocenić opinię klienta wyrażoną w formie zwykłego tekstu? Jak ogólnie
określić nastrój opinii klienta o danym produkcie lub marce? Czy można śledzić jej zmienność
w czasie? Czy jest sposób automatycznego określania nastroju tekstu?
321
4650570396d9eb2765da56c12eb840b5
4
W tym podrozdziale dowiesz się, jak można przetwarzać dane tekstowe i oceniać ich nastroje.
Nauczysz się wykorzystywać edytor Power Query i interfejs Text Analytics API do automatycznego
analizowania nastrojów. Jak pokazuje rysunek 12.9, wynikiem analizy jest liczba z przedziału od 0
do 1, gdzie 0 oznacza negatywny, a 1 pozytywny nastrój tekstu.
RYSUNEK 12.9. Za pomocą interfejsu Sentiment Analytics API

możesz w skali od 0 do 1 oceniać nastroje komunikatów tekstowych
Czym jest interfejs Sentiment Analytics API

W tym punkcie rozdziału krótko opisana jest składnia żądania wysyłanego do interfejsu API, która
pozwoli Ci lepiej poznać funkcje M użyte dalej w tym rozdziale. Jeżeli korzystanie z interfejsu API
nie jest Twoim ulubionym tematem, możesz pominąć ten punkt i przejść do następnego,
poświęconego implementacji wysyłania żądań.
Zobacz też. Pełny opis składni żądania wysyłanego do interfejsu Sentiment Analytics API jest
dostępny na stronie https://docs.microsoft.com/en-us/azure/cognitive-services/text-analytics/
how-tos/text-analytics-how-to-sentiment-analysis.
Interfejs umożliwia rozpoznawanie nastroju tekstu napisanego w języku angielskim, chińskim

uproszczonym, niemieckim, hiszpańskim i francuskim. Aktualna lista obsługiwanych języków
jest dostępna na stronie https://docs.microsoft.com/en-us/azure/cognitive-services/text-analytics/
text-analytics-supported-languages.
Korzystanie z interfejsu polega na wysyłaniu żądania na określony adres URL, zwany również
punktem końcowym:
https://[lokalizacja].api.cognitive.microsoft.com/text/analytics/v2.0/sentiment
Aby wybrać odpowiednią lokalizację, otwórz portal Azure, przejdź do strony swoich zasobów
analitycznych i kliknij odnośnik Przegląd. Jeżeli np. Twoją lokalizacją jest West Europe, punkt
końcowy ma postać:
https://westeurope.api.cognitive.microsoft.com/text/analytics/v2.0/sentiment
322
4650570396d9eb2765da56c12eb840b5
4
Przygotowanie danych
Zanim prześlesz tekst do usługi Sentiment Analytics, zapoznaj się z kilkoma zaleceniami i wymaganiami.
1. Z każdym komunikatem musisz wysyłać jego unikatowy identyfikator i kod języka.
2. Zalecane jest wysyłanie komunikatów składających się z jednego lub dwóch zdań, a nie
dużych bloków tekstu. Długość komunikatu nie może przekraczać 5000 znaków.
Usługa działa dokładniej, jeżeli tekst składa się z niewielkich części.
3. W jednym żądaniu możesz wysłać maksymalnie 1000 komunikatów.
4. Do usługi możesz wysyłać maksymalnie 100 żądań w ciągu jednej minuty.
5. Całkowita wielkość wszystkich komunikatów w jednym żądaniu nie może przekroczyć 1 MB.
6. Komunikat musi być zapisany w formacie JSON. (Tym wymogiem nie musisz się przejmować.
Za pomocą edytora Power Query możesz łatwo nadać tabeli wymagany format).
Poniżej przedstawiona jest przykładowa treść w formacie JSON, którą można umieścić
w żądaniu do interfejsu API:
{
"documents": [
{
"language": "en",
"id": "1",
"text": "We love this trail and make the trip every year."
},
{
"language": "en",
"id": "2",
"text": "Poorly marked trails! I thought we were goners. Worst hike ever."
},
{
"language": "en",
"id": "3",
"text": "This is my favorite trail. It has beautiful views."
}
]
}
W odpowiedzi na żądanie uzyskasz następujące dane w formacie JSON:
{
"documents": [
{
"score": 0.87631344795227051,
"id": "1"
},
{
"score": 0.05087512731552124,
"id": "2"
},
{
"score": 0.97651207447052,
"id": "3"
}
],
"errors": []
}
Nie przejmuj się formatem. Jego obsługa w edytorze Power Query jest prosta i intuicyjna.
323
4650570396d9eb2765da56c12eb840b5
4
Ćwiczenie 12.3. Implementacja niestandardowej funkcji

FnOkreślenieNastroju
W tym ćwiczeniu dowiesz się, jak utworzyć niestandardową funkcję wysyłającą żądanie z komunikatem
do interfejsu Sentiment Analytics API i jak przetwarzać odpowiedź z oceną nastroju.
Niestandardowa funkcja FnOkreślenieNastroju

Zanim zaczniesz ćwiczenie, przyjrzyj się poniższej funkcji, którą za chwilę utworzysz. Funkcję tę
możesz wykorzystać do analizy nastroju tekstu w tabeli wejściowej, a nawet większego zbioru
danych po podzieleniu go na części po 1000 komunikatów każda.
(Źródło) =>
let
#"Usunięto inne kolumny" = Table.SelectColumns(Źródło,{"id", "text"}),
#"Dodano kolumnę niestandardową" =
Table.AddColumn(#"Usunięto inne kolumny", "language", each "en"),
ŻądanieJSON = Json.FromValue([documents = #"Dodano kolumnę niestandardową"]),
OdpowiedźJSON = Json.Document(
Web.Contents(
"https://westeurope.api.cognitive.microsoft.com" &
"/text/analytics/v2.0/sentiment", [
Headers=[#"Ocp-Apim-Subscription-Key"= KluczAPI],
Content=ŻądanieJSON
]
)
),
documents = OdpowiedźJSON[documents],
#"Przekonwertowane na tabelę" = Table.FromList(
documents, Splitter.SplitByNothing(), null, null, ExtraValues.Error
),
OcenaNastroju = Table.ExpandRecordColumn(
#"Przekonwertowane na tabelę", "Column1", {"id", "score"}, {"id", "score"}
)
in
OcenaNastroju
Wskazówka. Powyższa funkcja niestandardowa została utworzona w wyniku wykonania

opisanych niżej kroków. Choć funkcję utworzoną przez innego użytkownika można łatwo
wykorzystać poprzez zwykłe skopiowanie jej kodu i wklejenie do edytora, musisz wiedzieć, że
duże fragmenty kodu nawet skomplikowanych funkcji można tworzyć za pomocą interfejsu
programu. W ten sposób można szybko pisać duże bloki kodu M i implementować skomplikowane
algorytmy. Potraktuj to ćwiczenie jak okazję do sprawdzenia, jak w praktyce można tworzyć
zaawansowane niestandardowe funkcje za pomocą interfejsu edytora Power Query.
Część I. Załadowanie danych

W tym ćwiczeniu wykorzystasz skoroszyt R11-01.xlsx z rozdziału 11., „Podstawy analizy tekstu”,
zawierający wpisy umieszczone przez wydawnictwo Microsoft Press na Facebooku
(https://www.facebook.com/microsoftpress).
324
4650570396d9eb2765da56c12eb840b5
4
Uwaga. Ćwiczenie wykonasz na niewielkim fragmencie danych zawierającym tylko 10 wpisów,

abyś nie osiągnął limitu bezpłatnych żądań ani nie poniósł kosztów spowodowanych intensywnym
korzystaniem z interfejsu Text Analytics API. Szczegółowe informacje na ten temat zawarte są
w punkcie „Uwagi dotyczące korzystania z usługi Azure Cognitive Services za pomocą edytora
Power Query”, w tym rozdziale.
1. Utwórz pusty skoroszyt w Excelu lub raport w Power BI, zaimportuj do niego skoroszyt
C:\Dane\R11\R11-01.xlsx i otwórz edytor Power Query.
2. W oknie Nawigator kliknij Arkusz1, a następnie przycisk Przekształć dane.
3. Zmień nazwę zapytania na Wpisy.
Zwróć uwagę na kolumny Wpis i ID wpisu zawierające wymagane w żądaniu informacje.
Ponieważ tabela zawiera kilkaset wpisów, z których potrzebnych będzie jedynie dziesięć,
musisz zredukować ich liczbę.
4. W karcie Strona główna kliknij ikonę Zachowaj wiersze i wybierz polecenie Zachowywanie
pierwszych wierszy. W oknie o tej samej nazwie, które się pojawi, w polu Liczba wierszy
wpisz 10 i kliknij przycisk OK. Koniecznie wykonaj ten krok, ponieważ musisz ograniczyć
liczbę wierszy.
Wskazówka. Zachowywanie pierwszych wierszy jest przekształceniem bardzo użytecznym

również w innych sytuacjach. Z jego pomocą można ograniczać ilość danych wyświetlanych
w panelu podglądu i usprawniać w ten sposób pracę. Na koniec można usunąć ten krok
i sprawdzić, czy zapytanie działa poprawnie.
Część II. Przygotowanie komunikatów

W kolejnej części ćwiczenia dowiesz się, jak przygotować komunikaty do wysłania ich do interfejsu
Sentiment Analytics API. Wykonaj poniższe kroki.
5. W panelu Zapytania kliknij prawym przyciskiem myszy zapytanie Wpisy i wybierz polecenie
Odwołanie.
6. Zmień nazwę nowego zapytania na OkreślenieNastroju.
7. Zaznacz zapytanie OkreślenieNastroju i zmień nazwę kolumny Wpis na text, a kolumny
ID wpisu na id.
8. Wykonaj następujące operacje, które zapewnią poprawność danych.
a. Usuń z kolumny text puste komórki. W tym celu kliknij w nagłówku ikonę filtru
i wybierz polecenie Usuń puste.
b. Usuń z kolumny id duplikaty danych. W tym celu zaznacz kolumnę id, a następnie
w karcie Strona główna kliknij ikonę Usuń wiersze i polecenie Usuń duplikaty.
Kroki 7. i 8. są bardzo ważne. Jeżeli nie zmienisz nazw kolumn, wyślesz puste wartości
lub powtarzające się identyfikatory, interfejs Sentiment Analytics API nie przeanalizuje
komunikatów.
325
4650570396d9eb2765da56c12eb840b5
4
Wskazówka. W przyszłości, gdy będziesz wykorzystywał opisaną metodę do obróbki swoich

danych i nie będziesz miał unikatowych identyfikatorów, możesz utworzyć kolumnę indeksu
za pomocą przekształcenia Kolumna indeksu dostępnego w karcie Dodaj kolumnę i użyć jej
jako kolumny id.
9. W karcie Strona główna kliknij ikonę Wybieranie kolumn. W oknie o tej samej nazwie,
które się pojawi, zaznacz pozycje text oraz id. Kliknij OK.
Pora utworzyć kolumnę z oznaczeniami języka. Nie jest obowiązkowa. Gdy będziesz
przetwarzał komunikaty w różnych językach, pomiń ten krok.
Dla uproszczenia ćwiczenia przyjmijmy założenie, że wszystkie komunikaty są w języku
angielskim. Dlatego użyjesz oznaczenia en. Pod koniec tego rozdziału dowiesz się, jakich
oznaczeń języków możesz używać i jak je dynamiczne stosować, jeżeli kolumna text zawiera
komunikaty napisane w różnych językach.
10. W karcie Dodaj kolumnę kliknij ikonę Kolumna niestandardowa. W oknie o tej samej nazwie,
które się pojawi, w polu Nazwa nowej kolumny wpisz language, a w polu Formuła kolumny
niestandardowej wpisz "en". Kliknij OK, aby zamknąć okno.
W panelu podglądu (patrz rysunek 12.10) pojawią się trzy kolumny o nazwach, których
trzeba użyć w treści żądania w formacie JSON.
RYSUNEK 12.10. Aby przeprowadzić analizę nastroju, należy utworzyć tabelę z kolumnami o nazwach id,
text i language, następnie przekształcić ją do formatu JSON i wysłać do usługi Azure Cognitive Services
326
4650570396d9eb2765da56c12eb840b5
4
Część III. Przekształcenie tabeli do formatu JSON

W tej części ćwiczenia przekształcisz tabelę do formatu JSON. Wykonaj poniższe kroki.
11. Zgodnie z wymaganiami interfejsu API, w treści żądania musisz umieścić następujący element:
{documents = …}
Jak pamiętasz z ćwiczenia 12.1, rekord w formacie JSON definiuje się za pomocą nawiasów
klamrowych i można do tego celu użyć funkcji Json.FromValue. Kliknij zatem ikonę fx obok
paska formuły. W panelu Zastosowane kroki pojawi się nowy krok o nazwie Niestandardowe1,
= #"Dodano kolumnę niestandardową"
Wpisz w jego miejscu następujący kod:
= [documents = #"Dodano kolumnę niestandardową"]
12. Aby utworzyć rekord w formacie JSON, umieść powyższy kod w argumencie funkcji
Json.FromValue, tak jak niżej:
= Json.FromValue([documents = #"Dodano kolumnę niestandardową"])
W panelu podglądu pojawi się ikona reprezentująca treść w formacie JSON, którą właśnie
utworzyłeś. Teraz dowiesz się, jak ją przygotować do wysłania.
Część IV. Przygotowanie klucza API

W tej części ćwiczenia utworzysz parametr zawierający klucz API. Wykonaj poniższe kroki.
13. Zaloguj się do portalu Azure i otwórz stronę ze swoimi zasobami analitycznymi.
Kliknij odnośnik Klucze i skopiuj do schowka jeden z kluczy.
14. W edytorze Power Query w karcie Strona główna rozwiń ikonę Zarządzaj parametrami
i wybierz polecenie Nowy parametr. W oknie Parametry, które się pojawi, wprowadź
następujące zmiany.
a. W polu Nazwa wpisz KluczAPI.
b. W polu Wartość bieżąca wklej klucz, który skopiowałeś w kroku 13.
Część V. Wysłanie żądania do interfejsu API

Teraz pora wysłać do interfejsu API żądanie zawierające komunikaty zapisane w formacie JSON.
15. W panelu Zapytania zaznacz zapytanie OkreślenieNastroju, a następnie kliknij ikonę fx obok
paska formuły. W panelu Zastosowane kroki pojawi się krok o nazwie Niestandardowe2,
= Niestandardowe1
16. W pasku formuły zastąp powyższy kod następującym:
327
4650570396d9eb2765da56c12eb840b5
4
= Web.Contents(
"https://westeurope.api.cognitive.microsoft.com/text/analytics/v2.0/sentiment", [
Headers = [
#"Ocp-Apim-Subscription-Key" = KluczAPI
],
Content = Niestandardowe1
]
)
Uwaga. Jeżeli swoje zasoby analityczne utworzyłeś w innej lokalizacji niż Europa Zachodnia,
zmień odpowiednio fragment westeurope. Nazwę lokalizacji znajdziesz w portalu Azure na
stronie zasobów analitycznych w sekcji Przegląd.
Przeanalizujmy kod, który wpisałeś w pasku formuły.

Pierwszym argumentem funkcji Web.Contents jest punkt końcowy (adres URL) interfejsu
Sentiment Analytics API. W drugim argumencie umieszczony jest rekord zawierający pola
Headers i Content. W pierwszym z nich jest zapisany klucz Ocp-Apim-Subscription-Key,
którego wartością jest klucz API (podobnie jak w poprzednim ćwiczeniu). Pole Content
zawiera treść w formacie JSON, którą zdefiniowałeś w kroku Niestandardowe1.
17. Jeżeli w panelu podglądu pojawi się komunikat, kliknij przycisk Edytuj poświadczenia. Pojawi się
okno Dostęp do zawartości sieci Web. Kliknij sekcję Anonimowy, a następnie przycisk Połącz.
18. W zależności od ustawień prywatności danych, w panelu podglądu może pojawić się
Wymagane są informacje dotyczące prywatności danych
Kliknij przycisk Kontynuuj. W oknie Poziomy prywatności, które się pojawi, dla obu źródeł
danych wybierz poziom Organizacyjne (tak jak w ćwiczeniu 12.2, w kroku 17.).
19. Jeżeli pojawi się poniższy komunikat:
Formula.Firewall: Element Zapytanie „OkreślenieNastroju” (krok „Niestandardowe2”)

przywołuje inne zapytania lub kroki, dlatego nie może uzyskać bezpośredniego dostępu
do źródła danych. Utwórz ponownie tę kombinację danych.
skonfiguruj skoroszyt Excela lub raport Power BI tak, aby ignorował poziomy prywatności.
W tym celu wykonaj następujące kroki.
a. W karcie Plik kliknij polecenie Opcje i ustawienia, a następnie Opcje zapytania
(w Excelu) lub Opcje (w Power BI Desktop).
b. W sekcji Bieżący skoroszyt (w Excelu) lub Bieżący plik (w Power BI Desktop) kliknij
polecenie Prywatność.
c. Zaznacz opcję Ignorowanie poziomów prywatności i potencjalne poprawianie wydajności
i kliknij OK.
d. W karcie Strona główna kliknij ikonę Odśwież podgląd.
Uwaga. Ignorowanie poziomów prywatności jest niezbędne w tym ćwiczeniu. Istnieje wprawdzie
dość skomplikowany sposób utworzenia zapytania, dzięki któremu powyższy komunikat nie
będzie się pojawiał, jednak jego opis wykracza poza zakres tej książki. Ponadto związany z tym
nakład pracy może nie być proporcjonalny do uzyskanych efektów.
328
4650570396d9eb2765da56c12eb840b5
4
Część VI. Przetworzenie odpowiedzi

W panelu podglądu powinna pojawić się ikona o nazwie [lokalizacja].api.cognitive.microsoft.com,
gdzie [lokalizacja] oznacza miejsce, w którym utworzyłeś swoje zasoby analityczne, np. westeurope.
Ikona reprezentuje treść odpowiedzi usługi na wysłane do niej żądanie. Odpowiedź jest zapisana
w formacie JSON, ale jak się przekonasz, za pomocą edytora Power Query można ją łatwo
przetworzyć. Wykonaj poniższe kroki.
20. Kliknij dwukrotnie ikonę.
W panelu podglądu pojawi się rekord z polami documents i errors zawierającymi obiekty
typu List. W tym miejscu możesz sprawdzić, czy interfejs Sentiment Analytics API zgłosił
błędy. W tym celu kliknij w polu errors odnośnik List. W tym ćwiczeniu przyjmijmy
założenie, że żądania są obsługiwane bez błędów. Dalej w tym rozdziale dowiesz się,
jak unikać najczęściej popełnianych błędów.
21. W polu documents kliknij odnośnik List. Pojawi się lista zawierająca dziesięć obiektów
typu Record.
22. W karcie Narzędzia do obsługi list kliknij ikonę Do tabeli. W oknie o tej samej nazwie,
które się pojawi, pozostaw domyślne ustawienia i kliknij przycisk OK.
23. Rozwiń kolumnę Column1, tak jak na rysunku 12.11. W panelu, który się pojawi, sprawdź,
czy zaznaczone są pozycje id oraz score. Usuń zaznaczenie opcji Użyj oryginalnej nazwy
kolumny jako prefiksu i kliknij OK. Pojawią się identyfikatory komunikatów i ich oceny
nastroju.
RYSUNEK 12.11. Konwersja treści w formacie JSON na tabelę jest bardzo prosta; wyniki analizy nastroju
zwrócone przez interfejs Sentiment Analytics API zostały zamienione na tabelę z kolumnami
identyfikatorów komunikatów i ich ocenami
Część VII. Utworzenie niestandardowej funkcji

W tej części ćwiczenia przekształcisz zapytanie OkreślenieNastroju w niestandardową funkcję.
24. W panelu Zapytania kliknij prawym przyciskiem myszy zapytanie OkreślenieNastroju
i wybierz polecenie Duplikuj. Zmień nazwę nowego zapytania na FnOkreślenieNastroju.
25. W panelu Zapytania zaznacz zapytanie FnOkreślenieNastroju. W karcie Strona główna
kliknij ikonę Edytor zaawansowany.
329
4650570396d9eb2765da56c12eb840b5
4
26. W edytorze pojawi się następujące wyrażenie (tutaj nieznacznie zmodyfikowane w celu
dopasowania go do rozmiarów strony, ale zwracające ten sam wynik):
let
Źródło = Wpisy,
#"Zmieniono nazwy kolumn" =
Table.RenameColumns(Źródło,{{"Wpis", "text"}, {"ID wpisu", "id"}}),
#"Przefiltrowano wiersze" =
Table.SelectRows(#"Zmieniono nazwy kolumn", each [text] <> null and [text] <> ""),
#"Usunięto duplikaty" =
Table.Distinct(#"Przefiltrowano wiersze", {"id"}),
#"Usunięto inne kolumny" =
Table.SelectColumns(#"Zmieniono nazwy kolumn",{"id", "text"}),
Niestandardowe1 = Json.FromValue([documents = #"Dodano kolumnę niestandardową"]),
Niestandardowe2 = Json.Document(
Web.Contents(
"https://westeurope.api.cognitive.microsoft.com/" &
"text/analytics/v2.0/sentiment", [
Headers=[#"Ocp-Apim-Subscription-Key"=KluczAPI],
Content=Niestandardowe1
]
)
),
documents = Niestandardowe2[documents],
),
#"Rozwinięty element Column1" = Table.ExpandRecordColumn(
)
in
#"Rozwinięty element Column1"
27. Aby przekształcić powyższy kod w niestandardową funkcję, usuń dwa wiersze poniżej
instrukcji let, ponieważ dotyczą one konkretnego źródła danych i w nowej funkcji nie będą
potrzebne. Funkcja powinna przetwarzać dowolną tabelę zawierającą komunikaty tekstowe
i ich unikatowe identyfikatory. Dlatego trzeba usunąć odwołanie do zapytania Wpisy
i przekształcenie zmieniające nazwy kolumn. Nazwy kolumn będą zmieniane po użyciu
funkcji z innymi danymi.
28. Usuń również dwa następne wiersze. Funkcje Table.SelectRows i Table.Distinct zostały
użyte w celu usunięcia z danych pustych wartości i duplikatów, które mogłyby być
przyczyną błędów.
Po wprowadzeniu powyższych zmian pierwszy wiersz poniżej instrukcji let będzie zawierał
następujący kod:
#"Usunięto inne kolumny" =
Table.SelectColumns(#"Zmieniono nazwy kolumn",{"id", "text"}),
29. Zastąp fragment #"Zmieniono nazwy kolumn" zmienną Źródło, a przed instrukcją let wpisz
wiersz (Źródło) =>. Aby poprawić czytelność kodu, wprowadź poniższe kosmetyczne zmiany.
a. Oba wystąpienia fragmentu #"Rozwinięty element Column1" (powyżej i poniżej wiersza
in) zastąp identyfikatorem OcenaNastroju.
330
4650570396d9eb2765da56c12eb840b5
4
b. Oba wystąpienia identyfikatora Niestandardowe1 zastąp identyfikatorem ŻądanieJSON.

c. Oba wystąpienia identyfikatora Niestandardowe2 zastąp identyfikatorem OdpowiedźJSON.
Poniżej przedstawiony jest ostateczny kod funkcji (po nieznacznych modyfikacjach w celu
dopasowania go do rozmiarów strony):
(Źródło) =>
let
Web.Contents(
"/text/analytics/v2.0/sentiment", [
]
)
),
),
OcenaNastroju = Table.ExpandRecordColumn(
)
in
OcenaNastroju
Jesteś gotów do użycia funkcji?
Część VIII. Wywołanie funkcji FnOkreślenieNastroju

W kolejnej części ćwiczenia dowiesz się, jak wywoływać niestandardową funkcję i uzyskiwać oceny
nastroju tekstu. Wykonaj poniższe kroki.
30. W panelu Zapytania kliknij prawym przyciskiem myszy zapytanie Wpisy i wybierz polecenie
Odwołanie. Zmień nazwę nowego zapytania na Oceny nastroju.
31. W nowym zapytaniu zmień nazwę kolumny Wpis na text, a kolumny ID wpisu na id.
Następnie kliknij ikonę fx obok paska formuły i wpisz poniższy kod:
= FnOkreślenieNastroju(#"Zmieniono nazwy kolumn")
32. Zanim załadujesz zapytanie Oceny nastroju do raportu, zmień typ kolumny score na Liczba
dziesiętna. Zmień nazwę kolumny score na Ocena nastroju, a kolumny id na ID wpisu.
33. W panelu Zapytania zaznacz zapytanie Oceny nastroju, a następnie w karcie Strona główna
kliknij ikonę Scal zapytania. Wykonaj poniższe kroki, aby scalić zapytania Oceny nastroju
i Wpisy (patrz rysunek 12.12).
a. W oknie Scalanie, które się pojawi, zaznacz w tabeli Oceny nastroju kolumnę ID wpisu.
b. W rozwijanej liście wybierz pozycję Wpisy.
c. W tabeli Wpisy zaznacz kolumnę ID wpisu.
d. W rozwijanej liście Rodzaj sprzężenia wybierz pozycję Prawe zewnętrzne
(wszystkie z drugiej, pasujące z pierwszej) i kliknij OK.
331
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 12.12. Scalenie wpisów z ocenami nastrojów
Sprzężenie prawe spowoduje, że wynikowa tabela będzie zawierała wszystkie wpisy nawet
wtedy, kiedy usługa z powodu błędu nie zwróci ich ocen. (Więcej szczegółowych informacji
o potencjalnych błędach znajdziesz dalej w tym rozdziale).
34. Rozwiń kolumnę Wpisy. W panelu, który się pojawi, zaznacz wszystkie kolumny oprócz
ID wpisu, która już się znajduje w scalonym zapytaniu. Teraz załaduj tabelę Oceny nastroju
do raportu i usuń z niego tabelę Wpisy. Zapisz raport, ponieważ użyjesz go w następnym
ćwiczeniu.
Zapobieganie błędom
Aby zapobiec pojawianiu się błędów podczas wysyłania żądań do interfejsu Text Analytics API,
przed użyciem funkcji FnOkreślenieNastroju wykonuj następujące operacje.
1. Sprawdzaj, czy kolumna zawierająca unikatowe identyfikatory ma nazwę id.
2. Sprawdzaj, czy kolumna zawierająca komunikaty ma nazwę text.
332
4650570396d9eb2765da56c12eb840b5
4
3. Usuwaj puste wartości z kolumny text. Wysyłanie pustych komunikatów nie ma sensu.
Jeżeli wraz ze zwykłymi komunikatami będziesz wysyłał puste, wtedy usługa usunie je listy
wyników (którą rozwinąłeś w ćwiczeniu 12.6, w kroku 23.), a w polu errors umieści listę
błędów. Ponadto wysyłanie pustych komunikatów wyczerpuje limit żądań.
4. Usuwaj duplikaty z kolumny id w sposób opisany w ćwiczeniu 12.8, w kroku 8. Wysłanie
duplikatu do interfejsu API spowoduje, że całe żądanie zakończy się poniższym błędem
i żaden zawarty w nim komunikat nie zostanie przetworzony.
DataSource.Error: Funkcja Web.Contents nie może pobrać zawartości z „https://westeurope.
api.cognitive.microsoft.com/text/analytics/v2.0/sentiment” (400): Bad Request
5. Sprawdzaj, czy komunikaty składają się z maksymalnie 5000 znaków. Inaczej w liście w polu
errors (które możesz rozwinąć w ćwiczeniu12.3, w kroku 20.) pojawi się następujący błąd:
A document within the request was too large to be processed. Limit document size to:
5120 characters
(Dokument zawarty w żądaniu jest zbyt długi, aby można go było przetworzyć.
Zmniejsz wielkość dokumentu do 5000 znaków).
Aby skrócić każdy komunikat do 5000 znaków, wykonaj poniższe kroki.
a. Zaznacz kolumnę text.
b. W karcie Strona główna kliknij ikonę Podziel kolumny i wybierz polecenie
Według liczby znaków.
c. W oknie Dzielenie kolumny według liczby znaków, które się pojawi, w polu
Liczba znaków wpisz 5000.
d. Zaznacz opcję Jedno, jak najdalej z lewej strony.
6. W jednym żądaniu wysyłaj maksymalnie 1000 komunikatów. Jeżeli będzie ich więcej, całe
żądanie zakończy się błędem Bad Request. Liczbę komunikatów możesz łatwo ograniczyć za
pomocą przekształcenia Zachowywanie pierwszych wierszy. W kolejnym ćwiczeniu dowiesz
się, jak możesz dużą liczbę komunikatów podzielić na grupy po 1000 wierszy i każdą z nich
przetwarzać osobno.
Ćwiczenie 12.4. Przetwarzanie dużych ilości danych

Ponieważ w jednym żądaniu wysyłanym do interfejsu Sentiment Analytics API można umieścić
maksymalnie 1000 komunikatów, w tym ćwiczeniu dowiesz się, jak za pomocą funkcji
FnOkreślenieNastroju można przetwarzać podzbiory danych. Opisana technika przyda Ci się
również w innych sytuacjach, w których niezbędne jest dzielenie dużych ilości danych na mniejsze
części i przetwarzanie ich za pomocą niestandardowych funkcji.
Ćwiczenie rozpocznij od miejsca, w którym zakończyłeś ćwiczenie 12.3. Możesz również
wykorzystać skoroszyt Excela R12-03 - rozwiązanie.xlsx lub raport Power BI R12-03 - rozwiązanie.pbix.
Uwaga. Aby ograniczyć do minimum liczbę żądań wysyłanych do interfejsu API, zbiór 100
komunikatów podzielisz na dziesięć bloków, każdy zawierający dziesięć komunikatów. Jeżeli
będziesz chciał zastosować opisane rozwiązanie z własnymi danymi, podziel dane na bloki,
każdy o wielkości 1000 komunikatów.
333
4650570396d9eb2765da56c12eb840b5
4
7. Jeżeli nie zapisałeś wyników ćwiczenia 12.3, otwórz skoroszyt Excela R12-03 - rozwiązanie.xlsx
lub raport Power BI R12-03 - rozwiązanie.pbix i uruchom edytor Power Query.
8. W panelu Zapytania zaznacz parametr KluczAPI. W panelu podglądu wklej w polu
Wartość bieżąca swój klucz do interfejsu Text Analytics API.
9. Zaznacz zapytanie Wpisy, a następnie w panelu Zastosowane kroki kliknij ikonę ustawień
kroku Zachowano pierwsze wiersze. W oknie Zachowywanie pierwszych wierszy, które się
pojawi, wpisz w polu Liczba wierszy wartość 100 i kliknij OK.
10. W panelu Zapytania kliknij prawym przyciskiem myszy zapytanie Wpisy i wybierz
polecenie Odwołanie. Zmień nazwę nowego zapytania na Ocenione wpisy.
11. Zmień nazwę kolumny ID wpisu na id, a kolumny Wpis na text.
12. Usuń puste wartości z kolumny text i duplikaty z kolumny id.
13. W karcie Dodaj kolumnę kliknij ikonę Kolumna indeksu.
14. Zaznacz kolumnę Indeks. W karcie Przekształć kliknij ikonę Standardowy i wybierz polecenie
Podziel bez reszty. W oknie o tej samej nazwie, które się pojawi, wpisz w polu Wartość liczbę
10 i kliknij OK. Pierwsze 10 komunikatów otrzyma indeks 0, następne 10 indeks 1 itd.
Uwaga. Gdy w przyszłości będziesz przetwarzał większe ilości danych, wpisz w kroku 8.
wartość 1000. Tutaj wartość 10 została użyta jedynie w celach demonstracyjnych.
15. W karcie Przekształć kliknij ikonę Grupowane według. Pojawi się okno o tej samej nazwie.
Wprowadź w nim zmiany opisane niżej i pokazane na rysunku 12.13.
a. W polu Nazwa nowej kolumny wpisz Podzbiór.
b. W rozwijanej liście Operacja wybierz pozycję Wszystkie wiersze.
RYSUNEK 12.13. Za pomocą przekształcenia „Grupowane według” możesz przetwarzać tekst w blokach
po 1000 komunikatów
334
4650570396d9eb2765da56c12eb840b5
4
16. W panelu podglądu pojawi się tabela z kolumnami Indeks i Podzbiór. Każdy z dziesięciu
wierszy zawiera obiekt Table z podzbiorem komunikatów.
17. W karcie Dodaj kolumnę kliknij ikonę Wywołaj funkcję niestandardową.
18. W oknie o tej samej nazwie, które się pojawi, wybierz w rozwijanej liście Zapytanie funkcji
pozycję FnOkreślenieNastroju.
19. W rozwijanej liście Źródło (opcjonalnie) wybierz pozycję Podzbiór i kliknij OK.
20. Jeżeli będzie trzeba, skonfiguruj poświadczenia i ustaw poziomy prywatności danych,
tak jak w ćwiczeniu 12.3, w krokach od 17. do 19.
21. Usuń kolumny Indeks i Podzbiór.
22. Rozwiń kolumnę FnOkreślenieNastroju. W panelu, który się pojawi, zaznacz pozycje id
i score oraz usuń zaznaczenie opcji Użyj oryginalnej nazwy kolumny jako prefiksu. Kliknij OK.
23. Zmień nazwy kolumn i scal wyniki z zapytaniem Wpisy w sposób opisany w ćwiczeniu 12.3,
w krokach od 32. do 34.
Wskazówka. Jeżeli używasz programu Power BI Desktop, nie musisz scalać zapytania Ocenione
wpisy. Po załadowaniu go do raportu zostanie automatycznie utworzona relacja typu „jeden do
jednego” z zapytaniem Wpisy; z jej pomocą będziesz mógł skojarzyć komunikaty z ich ocenami.
Po załadowaniu zapytań do raportu możesz zacząć analizować ich oceny nastroju.

Zapisz raport. W następnym podrozdziale dowiesz się, jak z komunikatów wyodrębniać
kluczowe frazy.
Wyodrębnianie kluczowych fraz

Za pomocą interfejsu Text Analytics API i technik opisanych w ćwiczeniach 12.3 i 12.4 można nie
tylko oceniać nastrój tekstu, ale również wyodrębniać z niego kluczowe frazy. Ponieważ składnia
wysyłanych w tym celu żądań jest podobna, możemy pominąć wstępne kroki.
Zobacz też. Aby dowiedzieć się więcej o interfejsie Key Phrase API, odwiedź stronę
https://docs.microsoft.com/pl-pl/azure/cognitive-services/text-analytics/how-tos/
text-analytics-how-to-keyword-extraction.
W tym podrozdziale dowiesz się, jak przystosować funkcję FnOkreślenieNastroju do

wyodrębniania z tekstu kluczowych fraz. W rozdziale 11. nauczyłeś się dzielić wpisy na słowa
i zliczać wystąpienia kluczowych słów. Teraz pójdziesz krok dalej i w prosty, magiczny sposób,
wykorzystując sztuczną inteligencję, wyodrębnisz z tekstu kluczowe frazy, przy użyciu których
będziesz mógł ocenić istotę i znaczenie tekstu.
335
4650570396d9eb2765da56c12eb840b5
4
Ćwiczenie 12.5. Przystosowanie kodu

do wyodrębniania kluczowych fraz
Ćwiczenie rozpocznij od miejsca, w którym zakończyłeś ćwiczenie 12.4, ewentualnie użyj skoroszytu
Excela R12-04 - rozwiązanie.xlsx lub raportu Power BI Desktop R12-04 - rozwiązanie.pbix.
1. Otwórz plik R12-04 - rozwiązanie.xlsx lub R12-04 - rozwiązanie.pbix i uruchom edytor
Power Query.
2. W panelu Zapytania kliknij prawym przyciskiem myszy funkcję FnOkreślenieNastroju
i wybierz polecenie Duplikuj.
3. Zmień nazwę nowej funkcji na FnWyodrębnienieKluczowychFraz, a następnie w karcie
Strona główna kliknij ikonę Edytor zaawansowany.
4. W zaawansowanym edytorze odszukaj w adresie URL fragment sentiment:
https://[lokalizacja].api.cognitive.microsoft.com/text/analytics/v2.0/sentiment
i zastąp go fragmentem KeyPhrases, tak jak niżej:
https://[lokalizacja].api.cognitive.microsoft.com/text/analytics/v2.0/KeyPhrases
5. W poniższym wierszu zastąp oba wystąpienia nazwy score:
OcenaNastroju = Table.ExpandRecordColumn(#"Przekonwertowane na tabelę", "Column1",

{"id", "score"}, {"id", "score"})
fragmentem keyPhrases, tak jak niżej:
OcenaNastroju = Table.ExpandRecordColumn(#"Przekonwertowane na tabelę", "Column1",
{"id", "keyPhrases"}, {"id", "keyPhrases"})
Uwaga. W języku M wielkość liter ma znaczenie. Zwróć uwagę, że na początku nazwy

keyPhrases znajduje się mała litera k.
6. Zmień identyfikator OcenaNastroju na KluczoweFrazy w powyższym i ostatnim wierszu

funkcji.
Poniżej przedstawiony jest zmodyfikowany kod funkcji. Otwórz zaawansowany edytor
i sprawdź, czy zawarte w nim wyrażenie jest takie samo jak tutaj.
(Źródło) =>
let
ŻądanieJSON =
Json.FromValue([documents = #"Dodano kolumnę niestandardową"]),
Web.Contents(
https://westeurope.api.cognitive.microsoft.com &
"/text/analytics/v2.0/KeyPhrases", [
]
)
),
336
4650570396d9eb2765da56c12eb840b5
4
),
KluczoweFrazy = Table.ExpandRecordColumn(
#"Przekonwertowane na tabelę", "Column1", {"id", "keyPhrases"},
{"id", "keyPhrases"}
)
in
KluczoweFrazy
7. W panelu Zapytania kliknij prawym przyciskiem myszy zapytanie Ocenione wpisy i wybierz
polecenie Duplikuj.
8. Zmień nazwę nowego zapytania na Kluczowe frazy. Następnie zaznacz je i w panelu
Zastosowane kroki usuń wszystkie kroki poniżej Pogrupowano wiersze. Teraz możesz
zastosować nową niestandardową funkcję do przekształcenia zgrupowanych wierszy.
9. W karcie Dodaj kolumnę kliknij ikonę Wywołaj funkcję niestandardową.
10. W oknie o tej samej nazwie, które się pojawi, w rozwijanej liście Zapytanie funkcji wybierz
pozycję FnWyodrębnienieKluczowychFraz.
11. W rozwijanej liście Źródło (opcjonalnie) wybierz pozycję Podzbiór i kliknij OK.
12. Usuń kolumny Indeks i Podzbiór.
13. Rozwiń kolumnę FnWyodrębnienieKluczowychFraz. W panelu, który się pojawi, zaznacz
pozycje id oraz keyPhrases i usuń zaznaczenie opcji Użyj oryginalnej nazwy kolumny
jako prefiksu. Kliknij OK.
14. Jeśli będzie trzeba, wybierz właściwe poświadczenia i poziomy prywatności danych
(tak jak to zrobiłeś w ćwiczeniu 12.3, w krokach od 17. do 19.).
15. W panelu podglądu pojawią się kolumny id oraz keyPhrases zawierające obiekty typu List.
Każdy element listy zawiera kluczową frazę i jej identyfikator.
16. Rozwiń kolumnę keyPhrases i wybierz polecenie Rozwiń do nowych wierszy.
17. Zmień nazwę kolumny id na ID wpisu, a kolumny keyPhrases na Kluczowa fraza.
18. Jeżeli używasz programu Power BI Desktop, załaduj zapytanie Kluczowe frazy do elementu
wizualnego Word Cloud, tak jak na rysunku 12.14. (Sposób, jak to zrobić, jest opisany
w rozdziale 11., w ćwiczeniu 11.7).
Wskazówka. Aby umieścić w chmurze słownej wieloczłonowe frazy, rozwiń sekcję ustawień
Ogólne i wyłącz opcję Rozbijanie na wyrazy. Oprócz tego utwórz relację pomiędzy tabelami
Kluczowe frazy a Ocenione wpisy wykorzystującą kolumny ID wpisu w obu tabelach. W tym
celu w karcie Strona główna kliknij ikonę Zarządzaj relacjami i w oknie Tworzenie relacji
wybierz w rozwijanej liście Kierunek filtrowania krzyżowego pozycję Oba.

337
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 12.14. Chmura słowna w programie Power BI Desktop ilustruje liczby wystąpień kluczowych fraz
Obsługa wielu języków

Gdy powstawała ta książka, interfejsy Sentiment Analytics API i Key Phrase API obsługiwały tylko kilka
języków, których lista jest dostępna na stronie https://docs.microsoft.com/pl-pl/azure/cognitive-services/
text-analytics/language-support. Jeżeli Twój język nie jest obsługiwany, możesz wykorzystać interfejs
Translate Text API w sposób opisany wcześniej w tym rozdziale i przetłumaczyć komunikaty na
jeden z obsługiwanych języków.
Zmiana oznaczenia języka

Jeżeli wszystkie komunikaty są zapisane w tym samym, obsługiwanym języku, zmień jego
oznaczenie w następujący sposób.
1. Odszukaj na stronie https://docs.microsoft.com/pl-pl/azure/cognitive-services/
text-analytics/language-support oznaczenie swojego języka.
2. Otwórz w zaawansowanym edytorze kod funkcji FnOkreślenieNastroju
i FnWyodrębnienieKluczowychFraz.
3. W poniższym wierszu zastąp fragment en oznaczeniem swojego języka:
#"Dodano kolumnę niestandardową" = Table.AddColumn(#"Usunięto inne kolumny", "language",

each "en"),
338
4650570396d9eb2765da56c12eb840b5
4
4. Jeżeli dane zawierają komunikaty napisane w różnych językach, wtedy kolumna niestandardowa
zawierająca oznaczenie jednego języka spowoduje, że uzyskane oceny nastroju tekstu i kluczowe
frazy będą błędne. Aby rozwiązać ten problem, usuń z kodu wiersz rozpoczynający się od
#"Dodano kolumnę niestandardową" w następujący sposób.
a. Odszukaj wiersze:

#"Dodano kolumnę niestandardową" = Table.AddColumn(#"Usunięto inne kolumny",
"language", each "en"),
b. Usuń drugi z powyższych wierszy i „połącz” dwa pozostałe poprzez zastąpienie fragmentu
#"Dodano kolumnę niestandardową" fragmentem #"Usunięto inne kolumny", tak jak niżej:
ŻądanieJSON = Json.FromValue([documents = #"Usunięto inne kolumny"]),
Dynamiczne wykrywanie języka

Jeżeli dane tekstowe są w różnych językach i technika opisana w poprzednim punkcie, w kroku 4.
nie sprawdza się, możesz użyć interfejsu Language Detection API do dynamicznego wykrywania
języków poszczególnych komunikatów, wybierać z nich te, które są sformułowane w obsługiwanych
językach i wysyłać je do interfejsu Sentiment Analytics API lub Key Phrase API.
Interfejs Language Detection API jest opisany na stronie https://docs.microsoft.com/en-us/
azure/cognitive-services/text-analytics/how-tos/text-analytics-how-to-language-detection.
Ćwiczenie 12.6. Przystosowanie kodu do wykrywania języka

Żądania wysyłane do interfejsu Language Detection API mają podobną składnię jak wysyłane do
interfejsu Sentiment Analytics API i Key Phrase API. Aby utworzyć nową niestandardową funkcję
FnWykrywanieJęzyka, zmień kod funkcji FnOkreślanieNastroju w sposób opisany w ćwiczeniu 12.5.
Poniżej przedstawiony jest kod nowej funkcji:
(Źródło) =>
let
ŻądanieJSON = Json.FromValue([documents = #"Usunięto inne kolumny"]),
Web.Contents(
"/text/analytics/v2.0/languages", [
Headers=[#"Ocp-Apim-Subscription-Key"=KluczAPI],
]
)
),
documents, Splitter.SplitByNothing(), null, null, ExtraValues.Error),
WykryteJęzyki = Table.ExpandRecordColumn(
#"Przekonwertowane na tabelę", "Column1", {"id", "detectedLanguages"},
{"id", "detectedLanguages"})
in
WykryteJęzyki
339
4650570396d9eb2765da56c12eb840b5
4
Ponieważ trzy opisane interfejsy Text Analytics API są do siebie podobne, w tym ćwiczeniu nie
będziemy zajmować się szczegółami wykrywania języka. Zamiast tego zapoznaj się z plikami R12-06
- rozwiązanie.xlsx oraz R12-06 - rozwiązanie.pbix, w których powyższa funkcja została użyta do
przetwarzania komunikatu „Cześć ludzie” zapisanego w różnych językach.
Gratulacje! Teraz możesz wykorzystać opisane w tym rozdziale techniki we własnych
zaawansowanych analizach tekstu obejmujących określanie nastroju i wyszukiwanie kluczowych
fraz w tekstach napisanych w różnych językach. Poniżej przedstawiony jest przykład takiej analizy.
1. Za pomocą interfejsu Language Detection API przetłumacz wszystkie komunikaty
(w blokach po 1000 wierszy).
2. Utwórz listę obsługiwanych języków.
3. Wykorzystując techniki opisane w rozdziale 11., utwórz dwa zapytania wybierające
komunikaty:
a. napisane w obsługiwanych językach,
b. napisane w nieobsługiwanych językach.
4. Komunikaty wybrane przez drugie zapytanie przetłumacz na język angielski
(lub inny obsługiwany język) i dołącz do wyników pierwszego zapytania.
5. Określ nastroje połączonych komunikatów i wyodrębnij z nich kluczowe frazy.
Podsumowanie
W tym rozdziale dowiedziałeś się, jak za pomocą Excela lub Power BI oraz usługi Azure Cognitive
Services tłumaczyć teksty, określać ich nastroje, wyodrębniać z nich kluczowe frazy i wykrywać
języki. Dzięki tym technikom, wykorzystującym potęgę sztucznej inteligencji, możesz pozyskiwać
nowe informacje z tekstowych źródeł danych.
Zanim zastosujesz opisane metody w praktyce, przejrzyj punkt „Uwagi dotyczące korzystania
z usługi Azure Cognitive Services za pomocą edytora Power Query” i zastosuj zawarte w nim porady,
aby ograniczyć liczbę żądań wysyłanych do interfejsu API. Nie udostępniaj klucza API innym osobom.
Pamiętaj, że nie jest możliwe planowanie odświeżania za pomocą usługi Power BI raportów
utworzonych w opisany tutaj sposób (chyba że w czasie, gdy czytasz tę książkę, firma Microsoft
zaoferowała taką możliwość). Raporty można odświeżać tylko w Excelu i Power BI Desktop.
Techniki określania nastroju tekstu i wyodrębniania kluczowych fraz ujawniają swoją potęgę
jeszcze bardziej, gdy stosuje się je razem z liczbowymi analizami i koreluje uzyskiwane wyniki.
W ten sposób można pozyskiwać nowe informacje o zachowaniach klientów, ich opiniach i wpływie
wywieranym na wyniki firmy.
W rozdziale 13., „Analiza sieci społecznościowych”, spełniona jest obietnica z rozdziału 11.,
„Podstawy analizy tekstu” — opisane są w nim techniki analizowania społecznościowych
zachowań ludzkich za pomocą Excela i Power BI w oparciu o dane uzyskiwane z Facebooka.
340
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 13.
Analiza sieci społecznościowych
Facebook jest pozycjonowany tak, aby ludzie mogli w nim znaleźć odpowiedzi na
pytania typu: „Jakie restauracje sushi odwiedzili ostatnio moi znajomi i które im się
spodobały?”. Takie pytania prawdopodobnie można zadawać tylko na Facebooku
i nigdzie indziej…
— Marc Zuckerberg

 łączyć się z Facebookiem za pomocą Excela lub Power BI Desktop i importować z niego
różnego rodzaju dane,
 importować informacje o tym, kiedy i jakie strony polubiłeś na Facebooku,
 sprawdzać, którzy użytkownicy Facebooka używają Power BI i łączą się z serwisem
za pomocą Excela i Power BI Desktop,
 poruszać po grafie społecznościowym,
 analizować dowolne strony na Facebooku i oceniać ich popularność na podstawie liczby
komentarzy i udostępnień,
 analizować kilka stron Facebooka za pomocą niestandardowej funkcji.
Przy użyciu polecenia Pobierz dane w Excelu i Power BI Desktop możesz łączyć się z wieloma różnymi,
bogatymi źródłami danych — plikami, firmowymi repozytoriami i serwisami internetowymi.
Wykorzystując swoje świeżo nabyte umiejętności posługiwania się edytorem Power Query, możesz
z każdego źródła pozyskiwać najróżniejsze rodzaje informacji. Ograniczeniem jest jedynie Twoja
wyobraźnia.
Ponieważ zbliżamy się do końca książki, nadszedł czas, abyś dowiedział się, jak wykorzystać
swoje umiejętności do pozyskiwania informacji z bogatych, publicznie dostępnych źródeł danych.
Rzeczywiste i urozmaicone zbiory danych otwierają nowe możliwości dla innych doświadczeń.
Przetwarzając nieznane wcześniej dane, inne niż firmowe, do których jesteś przyzwyczajony,
odkryjesz nieznane dotąd techniki, które poszerzą Twoją wiedzę.
4650570396d9eb2765da56c12eb840b5
4
Rozdział skupia się na analizie jednej z sieci społecznościowych — na Facebooku. Edytor Power
Query jest wyposażony w konektor, za pomocą którego możesz analizować swój profil lub dowolną
publiczną stronę w tym serwisie1. Serwis jest dostępny dla każdego, możesz zatem ćwiczyć
przetwarzanie danych bez określonej struktury, różnego typu tabel i nieoczyszczonych danych
pochodzących z heterogenicznych źródeł.
Jeżeli zajmujesz się analizą mediów społecznościowych, w tym rozdziale nie tylko poznasz nowe
techniki, ale również nauczysz się badać aktywność użytkowników serwisów społecznościowych
i identyfikować trendy w ich zachowaniu. Jeśli nie jesteś analitykiem, nie przejmuj się. W tym
rozdziale poznasz kilka doskonałych metod, dzięki którym będziesz mógł zbierać informacje
o swojej firmie i konkurencji, jak również tworzyć efektowne prezentacje dla współpracowników.
Pierwsze kroki z konektorem do Facebooka

Ten podrozdział zawiera podstawowe informacje o konektorze do Facebooka i pokazuje,
jak połączyć się z własnym profilem w tym serwisie.
Facebook oferuje bogaty zestaw interfejsów API umożliwiających programistom łączenie się
z serwisem i pozyskiwanie z niego informacji. Najważniejszy z nich, Facebook Graph API, daje
dostęp do grafu społecznościowego (patrz https://developers.facebook.com/docs/graph-api). Aplikacje
mogą poruszać się po węzłach i krawędziach grafu, podobnie jak po samej sieci społecznościowej,
i w ramach posiadanych uprawnień odczytywać i zapisywać dane w imieniu użytkowników i ich
grup. Niektóre węzły grafu są ukryte przed ciekawskimi aplikacjami, ale wiele innych jest
dostępnych dla każdego.
Aby aplikacja mogła połączyć się z Facebookiem, musisz wcześniej zalogować się na swoje konto
i udzielić aplikacji uprawnień do odczytywania lub zapisywania danych w Twoim imieniu. W pierwszym
ćwiczeniu wykonasz prostą operację zalogowania się na swoje konto za pomocą edytora Power Query
— jednej z wielu aplikacji, które mogą korzystać z Facebooka.
Ćwiczenie 13.1. Uzyskiwanie informacji o ulubionych stronach

W tym ćwiczeniu zaimportujesz z Facebooka informacje o stronach, które polubiłeś, m.in. daty
ich polubienia. Następnie nauczysz się uzyskiwać adresy URL profili i obrazów na podstawie
identyfikatorów tych stron. Aby wykonać to ćwiczenie, będzie Ci potrzebne konto na Facebooku.
Jeżeli go jeszcze nie masz, załóż je teraz.
Uwaga. Jeżeli nie masz konta w serwisie Facebook, nie będziesz mógł wykonać tego ćwiczenia,
dlatego załóż je teraz.
1
Abyś mógł w opisanych ćwiczeniach analizować wybraną publiczną stronę (tutaj Microsoft Press),
musisz uzyskać zezwolenie z Facebooka. Szczegółowe informacje znajdziesz na stronie
https://developers.facebook.com/docs/apps/review — przyp. red.
342
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 13.  ANALIZA SIECI SPOŁECZNOŚCIOWYCH
1. Połącz się z Facebookiem za pomocą Excela lub Power BI Desktop (patrz rysunek 13.1).
RYSUNEK 13.1. Aby połączyć się z Facebookiem, kliknij ikonę Pobierz dane w karcie Dane w Excelu lub
w karcie Strona główna w Power BI Desktop
W Excelu: utwórz pusty skoroszyt, a następnie w karcie Dane kliknij ikonę Pobierz dane
i wybierz polecenia Z usług online/Z serwisu Facebook.
W Power BI Desktop: utwórz pusty raport, a następnie w karcie Strona główna kliknij ikonę
Pobierz dane. W oknie o tej samej nazwie, które się pojawi, kliknij polecenie Usługi online,
wybierz pozycję Witryna Facebook i kliknij przycisk Połącz.
2. Jeżeli pierwszy raz łączysz się z Facebookiem, pojawi się komunikat informujący o potencjalnych
zmianach wprowadzonych w interfejsie API. Zaznacz opcję Nie ostrzegaj ponownie w przypadku
tego łącznika i kliknij przycisk OK.
3. Pojawi się okno Facebook, w którym musisz wybrać identyfikator obiektu do zaimportowania.
Domyślnie w polu „Me” nazwa użytkownika lub identyfikator obiektu umieszczony jest
identyfikator me (ja) reprezentujący Twój profil. W tym polu możesz wpisać inny
identyfikator, np. microsoftpress reprezentujący stronę wydawnictwa Microsoft Press.
Pozostaw domyślne ustawienia i kliknij OK.
Wskazówka. W oknie Facebook znajduje się rozwijana lista Połączenie, w której możesz wybrać
węzły grafu do zaimportowania, np. Znajomi, Komentarze lub Oznaczenia „lubię to”. Ponieważ
interfejs API Facebooka nieustannie się zmienia, nie wszystkie węzły są przydatne. Przykładowo
warto wybierać kombinację identyfikatora me i połączenia Oznaczenia „lubię to”, tak jak w tym
ćwiczeniu, natomiast wybranie innego identyfikatora z tym samym połączeniem spowoduje,
że dane będą puste.
343
4650570396d9eb2765da56c12eb840b5
4
4. Pojawi się okno Dostęp do serwisu Facebook. Jeżeli pierwszy raz łączysz się z Facebookiem,
a. Kliknij przycisk Zaloguj się. W nowym oknie wpisz swój login i hasło.
b. W oknie, które się pojawi, przejrzyj rodzaje uprawnień dostępu, jakie może uzyskać
aplikacja Microsoft Power BI, m.in. do Twojego profilu publicznego, listy znajomych,
komentarzy, aktualizacji stanu, osobistego opisu, polubień i adresu e-mail. Zmień
uprawnienia według potrzeb i kliknij przycisk Kontynuuj.
Uwaga. Twoje poświadczenia do Facebooka nie są zapisywane w raporcie Power BI. Jeżeli
udostępnisz raport innej osobie, która odświeży go na swoim komputerze, pojawi się okno
logowania do Facebooka. Jeżeli za pomocą usługi opublikujesz raport, który będzie
automatycznie odświeżany, będziesz musiał w ustawieniach usługi wpisać swoje poświadczenia
do Facebooka.
c. Jeżeli masz na Facebooku swoją stronę lub aplikację i pojawi się kolejne okno z prośbą
o udzielenie uprawnień, kliknij przycisk OK.
5. W oknie Dostęp do serwisu Facebook kliknij przycisk Połącz.
6. W panelu podglądu pojawi się rekord zawierający pola name, connections i id (patrz rysunek 13.2).
RYSUNEK 13.2. Dane odczytane za pomocą interfejsu Facebook Graph API są prezentowane w edytorze
Power Query w postaci rekordu; po grafie można poruszać się po kliknięciu odnośnika Record
Odczytany rekord sam w sobie nie zawiera wprawdzie cennych informacji, jednak w tym
miejscu musisz poznać kilka jego ważnych elementów. Zwróć uwagę na następujący kod,
który pojawi się w pasku formuły:
= Facebook.Graph("https://graph.facebook.com/v2.10/me")
Funkcja Facebook.Graph ma jeden argument, jest to adres URL. Zanim zaczniesz manipulować
tym adresem, musisz poznać kilka podstawowych zasad korzystania z interfejsu Graph API.
(Ma on wiele ciekawych cech, których opis wykracza poza zakres tego rozdziału).
Pierwszą ważną częścią adresu jest wersja interfejsu (tutaj 2.10). Zazwyczaj każda kolejna
wersja umożliwia odczytywanie nowych treści. Aby uzyskać do nich dostęp, odpowiednio
zmień numer wersji interfejsu. Pamiętaj, że z danej wersji można korzystać przez określony
czas. Informacje o datach wygaśnięcia poszczególnych wersji znajdują się na stronie Graph
API Changelog, https://developers.facebook.com/docs/graph-api/changelog.
344
4650570396d9eb2765da56c12eb840b5
4
Wskazówka. Jeżeli zamierzasz publikować automatycznie odświeżane raporty wykorzystujące

konektor do Facebooka, zapoznaj się dokładnie ze stroną Changelog. W tym rozdziale
wykorzystywana jest wersja 2.10, która będzie dostępna do 7 listopada 2019 r. Aby Twoje
raporty mogły się odświeżać po tej dacie, zmień w pasku formuły numer wersji na najnowszy
i sprawdź, czy zapytania po modyfikacjach działają zgodnie z oczekiwaniami.
Kolejną ważną częścią adresu URL jest punkt końcowy, w tym przypadku me, oznaczający
użytkownika, którego dane będą odczytywane. Za pomocą tego punktu wysyła się do interfejsu
bardziej skomplikowane żądania z parametrami filtrującymi dane i wyodrębniającymi
określone informacje. W ćwiczeniu 13.2 poznasz kilka przykładowych, najczęściej
stosowanych punktów.
7. Kliknij w polu connections obiekt Record. Pojawią się następujące klucze, których
wartościami są obiekty Table: books (książki), feeds (strumienie), friends (znajomi), games
(gry), likes (polubienia), movies (filmy), music (muzyka), permissions (uprawnienia), posts
(komentarze) i television (telewizja). Są to tzw. węzły. Kliknięcie obiektu Table w danym
węźle powoduje jego wyszczególnienie i załadowanie zawartych w nim danych.
Za pomocą interfejsu Facebook Graph API można uzyskać dostęp do wielu innych
węzłów, nie tylko do wyżej wymienionych. Ich pełna lista znajduje się na stronie
https://developers.facebook.com/docs/graph-api/reference/v3.1/user. Jak pamiętasz, w kroku
4b udzieliłeś aplikacji Power BI określonych uprawnień dostępu do swojego profilu.
Aplikacja domyślnie nie żąda wszystkich uprawnień i dlatego nie odczytuje wszystkich
węzłów dostępnych na Facebooku. Kolejne kroki demonstrują te ograniczenia.
8. W panelu Zastosowane kroki usuń ostatni krok, a następnie w pasku formuły dopisz
na końcu adresu URL ciąg /family, tak jak niżej:
= Facebook.Graph("https://graph.facebook.com/v2.10/me/family")
Gdy naciśniesz klawisz Enter, panel podglądu opustoszeje. Aplikacja Power BI nie otrzymała
uprawnienia user_relationship i nie mogła uzyskać dostępu do węzła family.
9. Przywróć formułę do pierwotnej postaci:
= Facebook.Graph("https://graph.facebook.com/v2.10/me")
Ponownie kliknij w polu connections obiekt Record.
10. Kliknij w polu likes obiekt Table, W panelu podglądu pojawią się strony, które polubiłeś
(patrz rysunek 13.3). Widoczne będą też kolumny id (identyfikator strony na Facebooku)
oraz created_time (data i czas polubienia). Na podstawie tej ostatniej kolumny utwórz dwie
nowe, zawierające bardzo przydatne informacje, takie jak daty i godziny polubienia stron.
11. Aby utworzyć kolumnę Data na podstawie kolumny created_time, zmień najpierw typ
danych tej kolumny na Data/godzina/strefa czasowa. Zaznacz kolumnę, a następnie w karcie
Dodaj kolumnę rozwiń ikonę Data i kliknij polecenie Tylko data.
12. Po utworzeniu kolumny Data zmień typ danych w kolumnie created_time na Godzina.
W ten sposób wyodrębnisz z niej oznaczenia czasu. Następnie w kolumnie Dodaj kolumnę
kliknij polecenia Godzina, Godzina i Godzina. Pojawi się nowa kolumna o nazwie Godzina,
na podstawie której możesz np. utworzyć wykres pokazujący, w jakich godzinach najczęściej
klikałeś przycisk Lubię to! (Taką analizę przeprowadzisz na końcu tego ćwiczenia i zapiszesz
w szablonie Power BI).
345
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 13.3. Po kliknięciu obiektu Table w polu likes wyświetlisz w edytorze Power Query listę stron,
które polubiłeś
13. Usuń kolumnę object_link, a następnie pierwszym trzem kolumnom nadaj odpowiednio
nazwy Strona, ID i Czas.
Wskazówka. Identyfikatory stron na Facebooku zapisane w kolumnie ID są niezwykle przydatne.

Ponieważ są unikatowe, można je wykorzystywać do tworzenia relacji pomiędzy tabelami oraz
niestandardowych kolumn z dodatkowymi informacjami. Przykładowo za pomocą poniższej
formuły możesz utworzyć kolumnę niestandardową o nazwie Adres URL strony:
= "https://www.facebook.com/" & [ID]
14. Jeżeli używasz programu Power BI Desktop, wykonaj operacje opisane w powyższej
wskazówce, aby utworzyć kolumnę Adres URL strony, a następnie poniższe kroki,
aby utworzyć kolumnę zawierającą adresy URL obrazów stron.
a. W karcie Dodaj kolumnę kliknij ikonę Kolumna niestandardowa. Pojawi się okno o tej
samej nazwie.
b. W polu Nazwa nowej kolumny wpisz Obraz.
c. W polu Formuła kolumny niestandardowej wpisz poniższy kod:
= "https://graph.facebook.com/" & [ID] & "/picture?type=large"
Wskazówka. W programie Power BI Desktop możesz wskazać, że adresy URL w danej kolumnie
wskazują strony lub ich obrazy. Następnie w raporcie możesz użyć fragmentatora, tabeli lub
macierzy do wyświetlenia obrazów lub odnośników.
15. Zmień nazwę zapytania na Ulubione strony i załaduj je do skoroszytu Excela lub raportu
Power BI. Za pomocą wykresu przestawnego w Excelu lub wykresu w Power BI możesz
pokazać, ile stron polubiłeś na przestrzeni czasu. Taki raport będzie zawierał podobną treść
jak strona https://www.facebook.com/me/likes.
346
4650570396d9eb2765da56c12eb840b5
4
Analiza sieci znajomych

W tym podrozdziale pokrótce zapoznasz się z jedną z najbardziej widowiskowych analiz: badaniem
znajomych na Facebooku. W kolejnym ćwiczeniu nauczysz się importować informacje o swoich
znajomych oraz ich znajomych, jak również tworzyć grafy ilustrujące powiązania między nimi.
W trzecim ćwiczeniu dowiesz się, jak importować informacje o stronach, które polubili Twoi znajomi.
Za pomocą interfejsu Facebook Graph API możesz poruszać się po grafie powiązań pomiędzy
znajomymi. Jednak Twoja aplikacja może analizować graf, zaczynając od Twojego węzła i przechodzić
jedynie przez węzły Twoich znajomych oraz ich znajomych, którzy zatwierdzili Twoją aplikację
(zgodnie z zasadami ochrony prywatności użytkowników Facebooka). Taką analizę przeprowadzisz
w ćwiczeniu 13.2.
Ćwiczenie 13.2. Wyszukiwanie bezpośrednich

i pośrednich znajomych za pomocą Power BI
Wykonaj opisane w tym ćwiczeniu kroki, aby za pomocą konektora do Facebooka uzyskać informacje
o swoich znajomych oraz o ich znajomych, a następnie utworzyć efektowny schemat, podobny do
pokazanego na rysunku 13.4 (dostępny w pliku z rozwiązaniem podanym na końcu ćwiczenia).
RYSUNEK 13.4. Graf społecznościowy użytkowników Excela i Power BI, którzy używają konektora
do Facebooka
347
4650570396d9eb2765da56c12eb840b5
4
Jak się wkrótce przekonasz, przedstawisz tylko tych swoich znajomych, którzy zaimportowali
dane z Facebooka za pomocą narzędzia Power Query (w Excelu lub Power BI Desktop).
W Excelu: kliknij kartę Dane, a następnie polecenia Z usług online/Z serwisu Facebook.
W Power BI Desktop: w karcie Strona główna rozwiń menu Pobierz dane. W oknie o tej
samej nazwie, które się pojawi, wybierz sekcję Usługi online (ewentualnie w polu
wyszukiwania wpisz Facebook), zaznacz pozycję Witryna Facebook i kliknij przycisk Połącz.
2. W oknie Facebook, które się pojawi, wpisz w pierwszym polu me, a w rozwijanej liście
Połączenie wybierz pozycję Znajomi i kliknij OK. W oknie podglądu, które się pojawi,
kliknij przycisk Załaduj. W panelu podglądu pojawi się lista Twoich znajomych.
Uwaga. Jeżeli w panelu podglądu pojawi się pusta tabela, nie będziesz mógł kontynuować
ćwiczenia. Musisz wcześniej pozyskać znajomych, którzy używali konektora do Facebooka
w Excelu i Power BI. W kolejnych krokach przyjęte jest założenie, że tacy znajomi pojawili
się w panelu podglądu.
3. Aby dowiedzieć się, którzy z Twoich pośrednich znajomych używają konektora do

Facebooka, rozwiń kolumnę object_link. Kolumna ta zawiera rekord elementów, które
można wyodrębnić za pomocą konektora. Kolumna connections zawiera wszystkie węzły
grafu, które możesz importować.
W panelu, który się pojawi, usuń zaznaczenie wszystkich pozycji oprócz connections.
4. Rozwiń kolumnę connections. W panelu, który się pojawi, usuń zaznaczenie wszystkich
pozycji oprócz friends. Usuń zaznaczenie opcji Użyj oryginalnej nazwy kolumny jako prefiksu
i kliknij OK.
5. Rozwiń kolumnę friends. W panelu, który się pojawi, usuń zaznaczenie wszystkich pozycji
oprócz name. Usuń zaznaczenie opcji Użyj oryginalnej nazwy kolumny jako prefiksu i kliknij OK.
W panelu podglądu pojawią się dwie nowe kolumny o nazwach name.1 i id.1. Tabela może
zawierać po kilka wierszy z tą samą nazwą Twojego znajomego w kolumnie name, przy czym
każdy wiersz będzie zawierał unikatowy identyfikator w kolumnie id.1, reprezentujący
Twojego pośredniego znajomego. Ze względu na obowiązujące wymagania Facebooka, dwie
nowe kolumny zawierają dane tylko tych Twoich pośrednich znajomych, którzy korzystają
z konektora do Facebooka. W kolumnie name.1 znajdują się ich nazwy.
Dlaczego w kolumnie name.1, w której powinni znajdować się znajomi znajomych, widoczni
są Twoi bezpośredni znajomi? Odpowiedź jest prosta: są to Twoi bezpośredni znajomi,
którzy są jednocześnie znajomymi Twoich znajomych.
W tym momencie możesz wykonać dwie ciekawe analizy. Pierwsza polega na dodaniu nowej
kolumny wyróżniającej wspólnych znajomych z kolumny name.1. Dzięki temu będziesz
mógł sprawdzić, ilu i jakich wspólnych znajomych masz ze swoimi znajomymi. Druga polega
na odrzuceniu wierszy ze wspólnymi znajomymi i utworzeniu grafu społecznościowego.
Wiersze ze wspólnymi znajomymi nie są potrzebne, ponieważ tabela zawiera inne wiersze,
w których znajomi z kolumny name.1 znajdują się w innych wierszach w kolumnie name.
348
4650570396d9eb2765da56c12eb840b5
4
6. Aby wyróżnić wspólnych znajomych, kliknij w karcie Dodaj kolumnę ikonę Kolumna
niestandardowa. W oknie o tej samej nazwie, które się pojawi, wprowadź następujące zmiany.
a. W polu Nazwa nowej kolumny wpisz Wspólni znajomi.
b. W polu Formuła niestandardowej kolumny wpisz poniższy kod i kliknij OK:
List.Contains(#"Rozwinięty element friends"[name], [name.1])

Zwróć uwagę, że nowa kolumna Wspólni znajomi zawiera wartości TRUE i FALSE.
Aby usunąć niepotrzebne wiersze, zastosuj filtr przepuszczający tylko wartości FALSE
w powyższej kolumnie.
Przeanalizujmy pokrótce formułę kolumny niestandardowej. Funkcja List.Contains zwraca
wynik TRUE, jeżeli lista podana w pierwszym argumencie zawiera wartość podaną w drugim
argumencie. W rozdziale 9., „Wprowadzenie do języka M”, dowiedziałeś się, że nazwę tabeli
z następującą po niej nazwą kolumny w nawiasach kwadratowych można traktować jak listę.
W tym przypadku zapis #"Rozwinięty element friends"[name] oznacza kolumnę name
z tabeli #"Rozwinięty element friends". Drugi argument funkcji, [name.1], oznacza
pośredniego znajomego, wyszukiwanego w liście.
Choć nie możesz wykroczyć poza pośrednich znajomych, możesz już teraz utworzyć graf
społecznościowy podobny do pokazanego na rysunku 13.4.
Wskazówka. Istnieje skuteczniejszy sposób poruszania się po grafie społecznościowym, wymagający

wysłania bardziej złożonych żądań do interfejsu API. Przykładowo poniższa funkcja (należy ją
wpisać w jednym wierszu) odczytuje dane 100 Twoich znajomych i pierwszych 50 znajomych
każdego Twojego bezpośredniego znajomego:
=Facebook.Graph("https://graph.facebook.com/v3.0/me?fields=friends.limit(100){name,id,frien
ds.limit(50){name,id}}")
Ćwiczenie 13.3. Wyszukiwanie stron, które polubili znajomi

To ćwiczenie jest odmianą ćwiczenia 13.2. Tym razem jednak nie zaimportujesz informacji o swoich
znajomych, tylko o polubionych przez nich stronach (patrz rysunek 13.5). W ten sposób dowiesz się,
czy masz ze swoimi znajomymi wspólne zainteresowania. Zgodnie z warunkami wspomnianymi
w poprzednim ćwiczeniu, dane będą ograniczone do znajomych, którzy korzystali z konektora
do Facebooka w narzędziu Power Query.
8. W oknie Facebook, które się pojawi, wpisz w pierwszym polu me, a w rozwijanej liście
Połączenie wybierz pozycję Znajomi i kliknij OK. W oknie podglądu, które się pojawi,
kliknij przycisk Załaduj.
349
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 13.5. Raport o swoich znajomych możesz wzbogacić o informacje o stronach, które polubili
9. Aby dowiedzieć się, jakie strony polubili Twoi znajomi, rozwiń kolumnę object_link.
W panelu, który się pojawi, usuń zaznaczenie wszystkich pozycji oprócz connections.
10. Rozwiń kolumnę. W panelu, który się pojawi, usuń zaznaczenie wszystkich pozycji oprócz
likes. Usuń zaznaczenie opcji Użyj oryginalnej nazwy kolumny jako prefiksu i kliknij OK.
11. Zmień nazwę zapytania na Baza. Kliknij prawym przyciskiem myszy zapytanie
i z podręcznego menu wybierz polecenie Odwołanie.
12. Zmień nazwę zapytania na Znajomi. Zaznacz je i usuń z niego kolumnę likes.
13. W panelu Zapytania kliknij prawym przyciskiem myszy Baza i z podręcznego menu wybierz
polecenie Odwołanie. Zmień nazwę zapytania na Strony. Zaznacz je i usuń z niego kolumny
name i id.
14. W zapytaniu Strony rozwiń kolumnę likes. W panelu, który się pojawi, usuń zaznaczenie
wszystkich pozycji oprócz name i id. Usuń zaznaczenie opcji Użyj oryginalnej nazwy
kolumny jako prefiksu i kliknij OK.
15. Aby strony nie powtarzały się, zaznacz kolumnę id, a następnie w karcie Strona główna
kliknij ikonę Usuń wiersze i wybierz polecenie Usuń duplikaty.
Ponieważ niektórzy znajomi mogli nie polubić żadnych stron, usuń puste wiersze.
16. W nagłówku kolumny id kliknij ikonę filtru i wybierz polecenie Usuń puste.
Teraz pora utworzyć nową tabelę wiążącą znajomych z polubionymi przez nich stronami.
350
4650570396d9eb2765da56c12eb840b5
4
17. W panelu Zapytania kliknij prawym przyciskiem myszy zapytanie Baza i z podręcznego
menu wybierz polecenie Odwołanie. Zmień nazwę nowego zapytania na Znajomi i strony.
Następnie zaznacz je, usuń kolumnę name, a nazwę kolumny id zmień na friend id.
18. Rozwiń kolumnę likes. W panelu, który się pojawi, usuń zaznaczenie wszystkich pozycji
oprócz id. Usuń zaznaczenie opcji Użyj oryginalnej nazwy kolumny jako prefiksu i kliknij OK.
19. Zmień nazwę kolumny id na page id.
W tym momencie możesz wzbogacić zapytania Strony i Znajomi o adresy URL profili
i obrazów w sposób opisany w ćwiczeniu 13.1. Poniżej przedstawiona jest formuła
zwracająca adres profilu:
"https://www.facebook.com/" & [id]
Natomiast formuła zwracająca adres obrazu wygląda następująco:
"https://graph.facebook.com/" & [id] & "/picture?type=large"
20. Załaduj zapytania do skoroszytu Excela lub raportu Power BI, a następnie wykonaj
poniższe kroki.
a. Wyłącz ładowanie zapytania Baza (w sposób opisany w rozdziale 3., w ćwiczeniu 3.1).
b. W diagramie relacji utwórz relacje pomiędzy kolumną id w tabeli Znajomi a kolumną
friend id w tabeli Znajomi i strony. Następnie utwórz drugą relację pomiędzy kolumną
id w tabeli Strony a kolumną page id w tabeli Znajomi i strony.
Wskazówka. Istnieje skuteczniejszy sposób poruszania się po grafie społecznościowym,

wymagający wysłania bardziej złożonych żądań do interfejsu API. Przykładowo poniższa
funkcja odczytuje dane 100 Twoich znajomych (którzy korzystają z konektora do Facebooka
w Power Query) i pierwszych 50 polubionych przez nich stron:
=Facebook.Graph("https://graph.facebook.com/v3.0/me?fields=friends.limit(100){name,id,likes
.limit(50){name,id}}")
Analiza stron na Facebooku

Jednym z najczęstszych zastosowań biznesowych konektora do Facebooka jest pozyskiwanie
za pomocą Excela lub Power BI informacji o aktywności użytkowników. W kolejnym ćwiczeniu
dowiesz się, jak odczytywać publiczne wpisy z dowolnej strony Facebooka, analizować liczby ich
komentarzy i udostępnień.
Zaczniesz od prostego ćwiczenia polegającego na odczytaniu wpisów i komentarzy w celu
wyodrębnienia z nich informacji za pomocą technik opisanych w rozdziałach 11. i 12. Dalej
nauczysz się skutecznie odczytywać i zliczać komentarze i udostępnienia stron. Metody te, wraz
z opisanymi wcześniej technikami analizy tekstu, możesz wykorzystywać do pozyskiwania
informacji o opinii publicznej oraz o postrzeganiu marek własnych i konkurencyjnych.
Przykład takiej analizy przedstawia rysunek 13.6.
351
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 13.6. Stosując techniki analizy tekstu, możesz za pomocą Power Query analizować nastroje wpisów
i komentarzy na Facebooku
Ćwiczenie 13.4. Proste odczytywanie wpisów i komentarzy

ze stron Facebooka
W rozdziale 11., „Podstawy analizy tekstu”, analizowałeś wpisy wydawnictwa Microsoft Press
na Facebooku. W tym ćwiczeniu poznasz prosty sposób importowania wpisów i komentarzy
z dowolnej strony serwisu. Jak się przekonasz, metoda ta nie pozwala skutecznie analizować wielu
stron i jest mało wydajna, gdy komentarzy jest dużo.
2. W oknie Facebook, które się pojawi, wpisz w pierwszym polu microsoftpress, w rozwijanej liście
Połączenie wybierz pozycję Komentarze i kliknij OK. W następnym oknie kliknij przycisk Połącz.
W oknie podglądu, które się pojawi, kliknij przycisk Załaduj. Otworzy się edytor Power Query.
Uwaga. Ćwiczenie to możesz wykonać na dowolnej stronie Facebooka. W tym celu w kroku 2.,
w pierwszym polu okna wpisz zamiast microsoftpress nazwę żądanej strony. Aby uzyskać tę nazwę,
otwórz w przeglądarce żądaną stronę i skopiuj do schowka fragment adresu URL zawierający
nazwę głównego folderu. Przykładowo strona poświęcona narzędziu Power BI ma adres https://www.
facebook.com/microsoftbi. Aby ją przeanalizować, wpisz w kroku 2. nazwę microsoftbi. Nazwę tę
możesz również zmienić później, modyfikując argument funkcji Facebook.Graph w formule
kroku Źródło, np. Facebook.Graph("https://graph.facebook.com/v2.10/microsoftbi/posts").
352
4650570396d9eb2765da56c12eb840b5
4
W panelu podglądu pojawi się tabela z następującymi kolumnami: message, created_time, id,
object_link i story.
3. Wyodrębnij z kolumny created_time datę i godzinę. W tym celu wykonaj kroki 11. i 12.
z ćwiczenia 13.1.
4. Nadaj kolumnom czytelne nazwy. W tym celu zmień kolumny message, created_time, id
i story odpowiednio na Komunikat, Czas, ID i Relacja.
W krokach od 6. do 14. opisana jest prosta metoda odczytywania komentarzy z Facebooka.
Jak się przekonasz, jest wprawdzie łatwa w implementacji, ale dość wolna i skutkuje
wysłaniem do interfejsu API wielu żądań, szczególnie w przypadku popularnych stron,
takich jak Microsoft Press. W ćwiczeniu 13.5 dowiesz się, jak usprawnić zapytanie. Na razie
jednak pozostańmy przy prostszym, choć wolniejszym sposobie. Pamiętaj jednak, że po
wysłaniu dużej liczby żądań przez Power Query do interfejsu API Facebooka możesz
otrzymać następujący komunikat:
Facebook: (#17) User request limit reached
(Przekroczono limit żądań).
W takim przypadku przerwij pracę nad raportem na kilka godzin. W serwisie Facebook
zaimplementowany jest mechanizm ograniczający liczbę żądań wysyłanych przez
użytkowników do interfejsu API. Na szczęście, wykonując operacje opisane w kroku 5.,
możesz uniknąć tego błędu.
Wskazówka. Jeżeli przygotowywane zapytanie jest długo przetwarzane, warto tymczasowo

ograniczyć liczbę odczytywanych wierszy, aby oszczędzić czas. W tym celu użyj przekształcenia
Zachowanie pierwszych wierszy. Po zakończeniu pracy usuń to przekształcenie, aby załadować
wszystkie dane.
5. W zakresie Strona główna kliknij ikonę Zachowaj wiersze i wybierz polecenie Zachowywanie
pierwszych wierszy. W oknie o tej samej nazwie, które się pojawi, w polu Liczba wierszy wpisz
100 i kliknij OK. Dzięki temu będziesz mógł kontynuować ćwiczenie, jak również skrócisz
czas przetwarzania zapytania i unikniesz komunikatu o przekroczeniu limitu żądań.
Pamiętaj, aby po zakończeniu etapu przygotowywania danych usunąć powyższy krok.
6. Rozwiń kolumnę object_link. W panelu, który się pojawi, usuń zaznaczenie wszystkich
kolumn oprócz connections. Usuń zaznaczenie opcji Użyj oryginalnej nazwy kolumny jako
prefiksu i kliknij OK.
7. Kolumna object_link zostanie zastąpiona kolumną connections. Rozwiń ją, a następnie
w panelu, który się pojawi, zaznacz pozycję field. Usuń zaznaczenie opcji Użyj oryginalnej
nazwy kolumny jako prefiksu i kliknij OK.
W miejscu oryginalnej kolumny connections pojawi się kolumna z komentarzami, zawierająca
w każdym wierszu obiekt Table. W każdym z nich znajdują się komentarze do danego wpisu.
Uwaga. Po wykonaniu kroku 7. w panelu widoczna będzie również pozycja likes (polubienia).
Kolumna ta będzie zawierać jednak puste obiekty Table, dlatego że za pomocą konektora do
Facebooka nie można odczytywać liczby polubień danego wpisu. Aby można było to robić, musiałbyś
napisać własny konektor lub skomplikowaną formułę M, co wykracza poza zakres tej książki.
353
4650570396d9eb2765da56c12eb840b5
4
Dobrą praktyką jest usuwanie duplikatów z kolumny ID. Jeżeli tego nie zrobisz, zapytanie
zakończy się błędem. Gdy dalej w tym ćwiczeniu będziesz tworzył relację pomiędzy tabelami
Wpisy i Komentarze, przyjmiesz założenie, że kolumna ID w tabeli Wpisy zawiera unikatowe
wartości.
8. Zaznacz kolumnę ID, a następnie w karcie Strona główna kliknij ikonę Usuń wiersze
i wybierz polecenie Usuń duplikaty.
9. Zmień nazwę zapytania na Wpisy — baza.
10. Kliknij zapytanie prawym przyciskiem myszy i z podręcznego menu wybierz polecenie
Odwołanie. Zmień nazwę nowego zapytania na Wpisy.
11. Zaznacz zapytanie Wpisy i usuń z niego kolumnę comments.
12. Kliknij prawym przyciskiem myszy zapytanie Wpisy — baza i z podręcznego menu wybierz
polecenie Odwołanie. Zmień nazwę nowego zapytania na Komentarze.
13. Zaznacz zapytanie Komentarze, a następnie w karcie Strona główna kliknij ikonę Wybieranie
kolumn. W oknie o tej samej nazwie, które się pojawi, zaznacz kolumny ID oraz comments
i kliknij OK.
14. Rozwiń kolumnę comments i w panelu, który się pojawi, usuń zaznaczenie wszystkich
kolumn oprócz id. Usuń zaznaczenie opcji Użyj oryginalnej nazwy kolumny jako prefiksu
(patrz rysunek 13.7) i kliknij OK.
RYSUNEK 13.7. Aby odczytać komentarze do wpisów, rozwiń kolumnę comments i zaznacz pola message oraz id
15. Zmień nazwę kolumny id.1 na ID komentarza, a kolumny message na Komentarz.

Zauważ, że w niektórych wierszach obie powyższe kolumny zawierają puste komórki.
Oznacza to, że niektóre wpisy nie mają komentarzy. Usuń je teraz.
354
4650570396d9eb2765da56c12eb840b5
4
16. Aby usunąć wiersze wpisów bez komentarzy, w nagłówku kolumny Komentarz kliknij ikonę
filtru i wybierz polecenie Usuń puste.
Teraz dodaj do tabel Wpisy i Komentarze kolumny z adresami URL.
17. Zaznacz zapytanie Wpisy i wykonaj poniższe kroki.
W kolumnie Dodaj kolumnę kliknij ikonę Kolumna niestandardowa. Pojawi się okno o tej
samej nazwie.
W polu Nazwa nowej kolumny wpisz Profil.
W polu Formuła kolumny niestandardowej wpisz następujący kod:
"https://www.facebook.com/" & [ID]
18. Zaznacz zapytanie Komentarze i wykonaj kroki od 17a do 17d, ale tym razem w kodzie pasku
formuły zamiast ID użyj ID komentarza, tak jak niżej:
"https://www.facebook.com/" & [Comment ID]
19. Zanim załadujesz zapytania do raportu, zaznacz zapytanie Wpisy — baza, a następnie usuń
z panelu Zastosowane kroki krok Zachowano pierwsze wiersze. Jak pamiętasz, w kroku 5.
ograniczyłeś liczbę wierszy do 100, aby podczas przygotowywania zapytania skrócić jego czas
przetwarzania w panelu podglądu i uniknąć komunikatu o błędzie.
20. Załaduj zapytania do skoroszytu Excela lub raportu Power BI. W tym celu wykonaj
poniższe kroki.
a. Wyłącz ładowanie zapytania Wpisy — baza (w sposób opisany w rozdziale 3.,
w ćwiczeniu 3.1).
b. W diagramie relacji utwórz relacje pomiędzy kolumną ID w tabeli Wpisy a kolumną ID
w tabeli Komentarze.
21. Zapisz raport, ponieważ będzie Ci potrzebny dalej w tym rozdziale, kiedy dowiesz się,
jak ładować dane za ustalony okres i skrócić czas przetwarzania zapytania.
Krótka dygresja: pobieranie danych za wybrany okres

W ćwiczeniu 13.4 przekonałeś się, że ładowanie danych z Facebooka jest długotrwałą operacją
szczególnie wtedy, kiedy analizowana strona jest popularna i zawiera dużo wpisów oraz komentarzy.
Aby uwzględnić w raporcie dane obejmujące określony przedział czasu i przyspieszyć w ten sposób
jego odświeżanie, zmodyfikuj zapytanie tak, aby wykorzystywało parametry since (od) i until (do),
dostępne w adresie URL. Zrób to, wykorzystując plik, który utworzyłeś w ćwiczeniu 13.4.
1. Otwórz plik R13-04 - rozwiązanie.xlsx oraz R13-04 - rozwiązanie.pbix.
3. W panelu Zapytania zaznacz zapytanie Wpisy — baza.
4. W panelu Zastosowane kroki zaznacz krok Źródło. W pasku formuły pojawi się następujący kod:
= Facebook.Graph("https://graph.facebook.com/v2.10/microsoftpress/posts")
355
4650570396d9eb2765da56c12eb840b5
4
5. Aby odczytać wyłącznie wpisy z 2019 r. i nowsze, dopisz do adresu URL znak zapytania
i parametr since=2019-01-01, tak jak niżej (całą formułę wpisz w jednym wierszu):
= Facebook.Graph("https://graph.facebook.com/v2.10/microsoftpress/posts?since=2019-01-01")
Aby odczytać wyłącznie wpisy z 2019 r., dopisz dodatkowo do adresu URL parametr
until=2019-12-31, tak jak niżej (formułę wpisz w jednym wierszu):
= Facebook.Graph("https://graph.facebook.com/v2.10/microsoftpress/posts?since=2017-01-
01&until=2019-12-31")
6. W panelu podglądu pojawią się wpisy wyłącznie z 2019 r.
Ćwiczenie 13.5. Analiza aktywności użytkowników:

zliczanie komentarzy i udostępnień
W tym ćwiczeniu przeanalizujesz popularność wybranej strony na Facebooku i poznasz lepszy sposób
odczytywania danych. W poprzednim ćwiczeniu importowałeś wpisy i komentarze umieszczone
na wybranej stronie. Kolejnym krokiem jest zliczanie komentarzy i udostępnień każdego wpisu.
Obecnie ze względu na zmiany wprowadzone w interfejsie API Facebooka i ograniczenia konektora
nie można odczytywać liczby polubień poszczególnych wpisów. Dlatego w tym ćwiczeniu skupimy
się na komentarzach i udostępnieniach. Rysunek 13.8 przedstawia przykład analizy aktywności
użytkowników na stronie na przestrzeni czasu.
RYSUNEK 13.8. Za pomocą konektora do Facebooka można analizować aktywność użytkowników

na stronach, zliczając udostępnienia wpisów
356
4650570396d9eb2765da56c12eb840b5
4
Uwaga. Istnieją zaawansowane metody pozyskiwania liczby polubień i reakcji użytkowników

(Super, Ha ha, Wow, Przykro mi i Wrr) na wpisy na publicznych stronach, które nie zostały
opisane w tej książce, ponieważ wymagają głębszej znajomości interfejsu Graph API i wpisania
dość skomplikowanego kodu M.
1. Otwórz plik R13-04 - rozwiązanie.xlsx lub R13-04 - rozwiązanie.pbix.

3. W panelu Zapytania zaznacz zapytanie Wpisy — baza.
4. W panelu Zastosowane kroki zaznacz krok Źródło. W pasku formuły pojawi się następujący kod:
= Facebook.Graph("https://graph.facebook.com/v2.10/microsoftpress/posts")
5. Do adresu URL użytego w funkcji Facebook.Graph dopisz znak zapytania i następujący
parametr:
fields=message,created_time,comments,story,shares
Formuła po zmianach wygląda następująco (wpisz ją w jednym wierszu):
= Facebook.Graph("https://graph.facebook.com/v2.10/microsoftpress/
posts?fields=message,created_time,comments,story,shares")
Dodatkowo zmień wersję interfejsu API na najnowszą 4.0:
posts?fields=message,created_time,comments,story,shares")
Wskazówka. Umieszczając w adresie URL numer najnowszej wersji interfejsu API, możesz
uzyskać dostęp do dodatkowych danych. Przykładowo za pomocą parametru shares możesz
odczytać informacje niedostępne w standardowym interfejsie edytora Power Query.
Za pomocą parametru fields w adresie URL jawnie określa się rodzaje informacji, które mają
być odczytane i umieszczone w raporcie. W tym przypadku są to message (komunikat),
created_time (data i godzina utworzenia), comments (komentarze) i story (relacja). Można
również użyć pola likes (polubienia), jednak zawsze będzie ono zawierało puste wyniki.
6. Ponieważ w kroku 5. jawnie wymieniłeś pola w adresie URL, nie musisz rozwijać kolumny
object_link. Dlatego w panelu Zastosowane kroki usuń kroki Rozwinięty element object_link
oraz Rozwinięty element connections. Jeżeli utworzyłeś krok Zachowano pierwsze wiersze,
również go usuń.
7. W panelu Zapytania zaznacz zapytanie Wpisy.
8. Usuń kolumnę object_link.
9. Rozwiń kolumnę shares. W panelu, który się pojawi, zaznacz pozycję count oraz opcję
Użyj oryginalnej nazwy kolumny jako prefiksu i kliknij OK.
10. Zmień nazwę nowej kolumny z shares.count na Liczba udostępnień, a jej typ na
Liczba całkowita.
Teraz, po utworzeniu kolumny Liczba udostępnień zawierającej liczby udostępnień
poszczególnych wpisów zajmij się komentarzami. Liczby komentarzy do każdego wpisu
możesz odczytać na kilka sposobów. Jeżeli znasz dodatek Power Pivot do Excela lub
357
4650570396d9eb2765da56c12eb840b5
4
funkcjonalności karty Modelowanie w Power BI, możesz utworzyć prostą miarę DAX zliczającą
liczbę wierszy w tabeli Komentarze. Jeżeli wolisz zrobić to w Power Query, wykonaj opisane
niżej kroki.
11. W panelu Zastosowane kroki zaznacz krok Źródło.
12. Zwróć uwagę, że kolumna comments zawiera obiekty Table lub wartości null. Teraz utwórz
niestandardową kolumnę zawierającą liczby wierszy w poszczególnych obiektach lub zera, jeżeli
komórka w kolumnie comments zawiera wartość null. W tym celu wykonaj następujące kroki.
a. W karcie Dodaj kolumnę kliknij ikonę Kolumna niestandardowa. W oknie Wstawianie
kroku, które się pojawi, kliknij przycisk Wstaw. Pojawi się okno Kolumna niestandardowa.
b. W polu Nazwa nowej kolumny wpisz Liczba komentarzy.
c. W polu Formuła kolumny niestandardowej wpisz następujący kod:
if [comments] = null then 0 else Table.RowCount([comments])
13. Zmień typ kolumny Liczba komentarzy na Liczba całkowita.
14. Zapisz skoroszyt lub raport. Wykorzystasz go w ćwiczeniu 13.6.
Teraz, gdy wiesz już, jak zliczać komentarze i udostępnienia wpisów, możesz analizować aktywność
użytkowników na dowolnej stronie serwisu (po uprzednim uzyskaniu akceptacji Facebooka).
Ćwiczenie 13.6. Analiza porównawcza stron

W tym ćwiczeniu rozszerzysz analizę na dwie strony Facebooka:
 oficjalną stronę Microsoft Excel: https://www.facebook.com/microsoftexcel,
 oficjalną stronę Power BI: https://www.facebook.com/microsoftbi.
Wykorzystaj raport, który utworzyłeś w ćwiczeniu 13.5, albo jeden z plików: R13-05 - rozwiązanie.xlsx
lub R13-05 - rozwiązanie.pbix.
1. Otwórz plik i uruchom edytor Power Query.
2. Utwórz puste zapytanie, a następnie w pasku formuły wpisz poniższy kod i naciśnij Enter:
= #table({"NazwaObiektuStrony", "Strona"}, {{"microsoftexcel", "Excel"}, {"microsoftbi",

"Power BI"}})
3. Zmień nazwę zapytania na Strony.
4. W panelu Zapytania zaznacz zapytanie Wpisy — baza. Do analizy każdej ze stron zastosujesz
kroki zdefiniowane w tym zapytaniu.
5. Kliknij prawym przyciskiem myszy zapytanie Wpisy — baza i wybierz polecenie Duplikuj.
Zmień nazwę nowego zapytania na Ładowanie wpisów.
6. W karcie Strona główna rozwiń ikonę Zarządzaj parametrami i wybierz polecenie Nowy
parametr. W oknie parametry, które się pojawi, wprowadź następujące zmiany.
a. W polu Nazwa wpisz NazwaStrony.
b. W polu Wartość bieżąca wpisz microsoftpress.
358
4650570396d9eb2765da56c12eb840b5
4
Uwaga. Nazwa microsoftpress wpisana w polu Wartość bieżąca jest tymczasową wartością,
z której będziesz korzystał tylko przez chwilę. Dzięki niej w kroku 8. przyspieszysz wyświetlanie
danych w panelu podglądu, ponieważ edytor Power Query wykorzysta informacje, które
odczytał wcześniej ze strony Microsoft Press i zapisał w pamięci podręcznej.
7. W panelu Zapytania zaznacz zapytanie Ładowanie wpisów, a następnie w panelu

Zastosowane kroki zaznacz krok Źródło.
8. W pasku formuły zastąp fragment microsoftpress ciągiem " & NazwaStrony & ". Oryginalna
formuła ma następującą postać:
posts?fields=message,created_time,comments,story,shares")
Poniżej jest przedstawiona jej zmodyfikowana wersja:
= Facebook.Graph("https://graph.facebook.com/v2.10/"& NazwaStrony &
"/posts?fields=message,created_time,comments,story,shares")
9. Aby przekształcić zapytanie Ładowanie wpisów w funkcję, kliknij je prawym przyciskiem
myszy i wybierz polecenie Utwórz funkcję. W oknie o tej samej nazwie, które się pojawi,
w polu Nazwa funkcji wpisz FnŁadowanieWpisów. Kliknij OK, aby zamknąć okno.
Jak pokazuje rysunek 13.9, Ładowanie wpisów jest teraz zapytaniem odniesienia. Wszystkie
zmiany, jakie w nim wprowadzisz, zostaną odzwierciedlone w funkcji FnŁadowanieWpisów.
Nie musisz modyfikować żadnych elementów w folderze FnŁadowanieWpisów.
RYSUNEK 13.9. Funkcję FnŁadowanieWpisów, utworzoną w kroku 9., możesz wykorzystywać do analizowania
różnych stron Facebooka; aby ją zmodyfikować, wprowadź zmiany w zapytaniu „Ładowanie wpisów”
10. Kliknij prawym przyciskiem myszy zapytanie Strony i wybierz polecenie Odwołanie.
Zmień nazwę nowego zapytania na Wpisy — wszystkie strony.
11. W panelu Zapytania zaznacz nowe zapytanie, a następnie w karcie Dodaj kolumnę kliknij
ikonę Wywołaj funkcję niestandardową.
359
4650570396d9eb2765da56c12eb840b5
4
12. W oknie o tej samej nazwie, które się pojawi, wybierz w rozwijanej liście Zapytanie funkcji
pozycję FnŁadowanieWpisów. W rozwijanej liście NazwaStrony wybierz pozycję
NazwaObiektuStrony i kliknij OK.
Obok kolumny Strona pojawi się kolumna FnŁadowanieWpisów z obiektami Table,
z których każdy zawiera dane strony Facebooka.
13. Rozwiń kolumnę FnŁadowanieWpisów. W panelu, który się pojawi, sprawdź, czy zaznaczone
są wszystkie pozycje. Usuń zaznaczenie opcji Użyj oryginalnej nazwy kolumny jako prefiksu
i kliknij OK.
Teraz zapytanie Wpisy — wszystkie strony zawiera wszystkie potrzebne wpisy.
14. Niestety, w kroku 13. zmieniły się typy danych w kolumnach. Dlatego w zapytaniu Wpisy
— wszystkie strony zmień typ kolumny Data na Data, typ kolumny Czas na Godzina,
a kolumny Godzina na Liczba całkowita.
Jak pamiętasz, zapytania Wpisy i Komentarze odwołują się do oryginalnego zapytania
Wpisy — baza odczytującego wpisy wydawnictwa Microsoft Press. Zmień powyższe dwa
zapytania tak, aby odwoływały się do Wpisy — wszystkie strony.
15. W panelu Zapytania zaznacz zapytanie Wpisy. W panelu Zastosowane kroki zaznacz krok
Źródło i w pasku formuły wpisz następujący kod:
= #"Wpisy - wszystkie strony"
16. W panelu Zapytania zaznacz zapytanie Komentarze. W panelu Zastosowane kroki zaznacz
krok Źródło i w pasku formuły wpisz kod z kroku 15.
Teraz zapytania Wpisy i Komentarze będą odwoływały się do zapytania Wpisy — wszystkie
strony. Zapytanie Wpisy — baza nie będzie już potrzebne i możesz je bezpiecznie usunąć.
17. Aby załadować zmienione zapytania do raportu, wykonaj poniższe kroki.
W Excelu: w karcie Strona główna rozwiń ikonę Zamknij i załaduj i wybierz polecenie
Zamknij i załaduj do. W oknie Importowanie danych, które się pojawi, zaznacz opcję
Utwórz tylko połączenie. Dzięki temu do modelu danych zostaną załadowane tylko
zapytania Wpisy i Komentarze.
W Power BI Desktop: w panelu Zapytania kliknij prawym przyciskiem myszy zapytanie
Ładowanie wpisów i z podręcznego menu wybierz polecenie Wyłącz ładowanie.
Analogicznie zmień zapytanie Wpisy — wszystkie strony.
18. Załaduj zapytanie Strony do modelu danych w Excelu lub Power BI, a następnie utwórz relację
pomiędzy kolumną NazwaObiektuStrony w tabeli Strony a kolumną NazwaObiektuStrony
w tabeli Wpisy.
Teraz możesz sprawdzić, na której ze stron użytkownicy są bardziej aktywni i częściej
udostępniają wpisy. Rysunek 13.10 przedstawia przykładowe porównanie.
360
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 13.10. Porównanie popularności stron Excela i Power BI na Facebooku
Podsumowanie
W tym rozdziale poznałeś graf społecznościowy i dowiedziałeś się, jak importować z Facebooka
dane, dzięki którym można znaleźć odpowiedzi na różne pytania osobiste i biznesowe. Nauczyłeś się
łączyć za pomocą Excela i Power BI z punktami końcowymi Facebooka i odczytywać różne informacje,
np. profil, polubienia, dane znajomych, wpisy i komentarze.
Poznałeś kilka technik korzystania z konektora do Facebooka, analizowania swojego profilu
i stron publicznych. W ćwiczeniu 13.1 zaimportowałeś z Facebooka informacje o ulubionych
stronach. W ćwiczeniu 13.2 nauczyłeś się poruszać po grafie społecznościowym i wyszukiwać
znajomych, bezpośrednich i pośrednich, którzy używają Power Query i Power BI. W ćwiczeniu 13.3
wyszukałeś strony, które polubili Twoi znajomi (ale tylko ci, którzy używają Power Query
z konektorem do Facebooka). W ćwiczeniu 13.4 zastosowałeś metodę odczytywania wpisów
i komentarzy, a w ćwiczeniu 13.5 usprawniłeś zapytania i zaimportowałeś liczby udostępnień
wpisów. Na koniec, w ćwiczeniu 13.6 rozszerzyłeś zapytania o możliwość importowania danych
różnych stron Facebooka za pomocą niestandardowej funkcji.
Teraz, wykorzystując posiadane umiejętności analizowania stron, wpisów i komentarzy na
Facebooku oraz zaawansowane techniki analizy tekstu z rozdziałów 11. i 12., możesz tworzyć
przydatne, efektowne raporty o popularności dowolnej marki w serwisie Facebook.
W następnym i ostatnim rozdziale, wykorzystasz swoje świeżo nabyte umiejętności przetwarzania
danych do wykonania kilku ćwiczeń obejmujących różne zagadnienia opisane w tej książce. Wiem,
że jesteś do tego gotów.
361
4650570396d9eb2765da56c12eb840b5
4
362
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 14.
Końcowy projekt: wszystko razem
Napisanie tego zajęło mi trzy miesiące, wymyślenie trzy minuty, a zebranie danych
całe życie.
— F. Scott Fitzgerald
W TYM ROZDZIALE:
 wcielisz się w szefa działu analiz fikcyjnej firmy Światowi Importerzy,
 podejmiesz się wyzwania przygotowania nieuporządkowanych danych do analizy,
 zagregujesz i zdekomponujesz tabele w skomplikowanym scenariuszu przetwarzania
danych z kilku plików,
 wykorzystasz różne metody scalania zapytań do porównania zawartości dwóch tabel.
Gratulacje! Dotarłeś do ostatniego rozdziału. Nadszedł czas, abyś sprawdził swoje umiejętności
przetwarzania danych w finałowym projekcie.
Przeszedłeś długą drogę. W poprzednich rozdziałach nauczyłeś się oczyszczać nieuporządkowane
dane, scalać tabele, ujednolicać niezgodne nazwy kolumn, agregować i dekomponować tabele oraz
wykonywać wiele innych przekształceń. Nadeszła pora, abyś sprawdził nabytą wiedzę i wykorzystał
ją do wykonania poważnego zadania.
Ćwiczenie 14.1.
Ratowanie sytuacji u Światowych Importerów
Wyobraź sobie, że jesteś nowym szefem działu analiz w firmie Światowi Importerzy. W ubiegły
weekend miał miejsce zmasowany cyberatak na firmową bazę danych. Zespół specjalistów pracuje
nad odzyskaniem danych o przychodach, a Ty dostałeś zadanie odtworzenia na podstawie starych
danych, które nie ucierpiały podczas ataku, raportu podsumowującego przychody. Twój poprzednik
zapisał dane za lata 2015 – 2017 w trzech skoroszytach Excela, z których każdy zawiera 12 arkuszy,
po jednym dla każdego miesiąca. Oprócz tego są dostępne dane za 2018 r., zapisane w nowym,
skomplikowanym formacie.
4650570396d9eb2765da56c12eb840b5
4
Czy zdołasz zaimportować wszystkie 36 arkuszy i scalić je z danymi za 2018 r. w jednej tabeli,
podobnej do pokazanej na rysunku 14.1?
RYSUNEK 14.1. Twoje zadanie polega na połączeniu danych o przychodach firmy Światowi Importerzy za
lata 2015 – 2017, zapisanych z trzech skoroszytach (każdy zawierający 12 arkuszy po jednym dla każdego
miesiąca) i danych za rok 2018 zapisanych w pliku CSV w wielowierszowych rekordach
Przejrzyj pliki 2015.xlsx, 2016.xlsx i 2017.xlsx zapisane w katalogu C:\Dane\R14\Przychody.

Każdy arkusz zawiera zagregowaną tabelę z poziomami hierarchii 2×3. W wierszach znajdują się
kategorie klientów i nazwy miast, a w kolumnach kolory, kategorie dostawców oraz ich nazwy.
Przychody za rok 2018 są zapisane w pliku CSV zawierającym dwie kolumny o nazwach Atrybut
i Wartość, tak jak na rysunku 14.1. Twoim celem jest scalenie wszystkich danych w jeden spójny
raport, taki jak w pliku R14-01 - cel.xlsx.
Uwaga. Zachęcam, abyś w tym miejscu przerwał lekturę i spróbował samodzielnie wykonać
zadanie. Może Ci to zająć kilka godzin. Gdy będziesz potrzebował pomocy, skorzystaj ze
wskazówek zawartych w kolejnym punkcie.
Wskazówki
Nie wiesz, co robić? Podziel zadanie na następujące części.
1. Zaimportuj skoroszyty Excela zapisane w folderze C:\Dane\R14\Przychody.
2. Utwórz nową kolumnę zawierającą 36 obiektów Table, reprezentujących 36 arkuszy
z przychodami za lata 2015 – 2017.
364
4650570396d9eb2765da56c12eb840b5
4
ROZDZIAŁ 14.  KOŃCOWY PROJEKT: WSZYSTKO RAZEM
3. W każdym arkuszu pomiń pierwszy wiersz, jak również kolumnę i wiersz zawierające sumy
przychodów.
4. W każdym arkuszu zastosuj funkcję FnDekompozycjaTabeli
(patrz rozdział 7., „Zaawansowane metody dekomponowania i agregowania tabel”).
5. Zaimportuj plik 2018.csv i zagreguj dane w sposób opisany w rozdziale 7.
6. Dołącz do zdekomponowanych danych przychody za 2018 r. Zwróć uwagę na niezgodność
nazw kolumn. Aby przypomnieć sobie sposób ujednolicania nazw kolumn, wróć do
rozdziału 3., „Łączenie danych z kilku źródeł”.
Uwaga. Przerwij lekturę w tym miejscu i spróbuj samodzielnie kontynuować zadanie. Poświęć
na to kilka dodatkowych godzin. Jeżeli będziesz potrzebował pomocy, przeczytaj ponownie
rozdział 7. Jeżeli mimo wszystko będzie Ci potrzebne dodatkowe wsparcie, wykonaj ćwiczenie
krok po kroku.
Część I. Przygotowanie danych

Aby przekształcić tabele zawierające zagregowane dane za lata 2015 – 2017 i dołączyć do nich
wielowierszowe rekordy z danymi za rok 2018, wykonaj poniższe kroki.
1. Utwórz nowy skoroszyt w Excelu lub raport w Power BI Desktop.
W Excelu: w karcie Dane kliknij ikonę Pobierz dane i wybierz polecenia Z pliku/Z folderu.
W Power BI Desktop: w karcie Dane kliknij ikonę Pobierz dane i wybierz polecenia
Plik/Folder.
2. Odszukaj folder c:\Dane\R14\Przychody i kliknij OK. W kolejnym oknie kliknij przycisk
Przekształć dane. Otworzy się edytor Power Query.
3. Aby wykluczyć plik 2018.csv, który ma inny format niż pozostałe pliki (zajmiesz się nim
później), kliknij ikonę filtru w nagłówku kolumny Name i usuń zaznaczenie pozycji 2018.csv.
Kliknij OK, aby zamknąć panel filtru.
4. W nagłówku kolumny Content kliknij ikonę Połącz pliki.
5. W oknie Połącz pliki, które się pojawi, kliknij prawym przyciskiem myszy folder Parametr1
i wybierz polecenie Przekształć dane.
6. Usuń z zapytania Przychody trzy ostatnie kolumny.
7. Z wartości w kolumnie Source.Name usuń rozszerzenie .xlsx. (Istnieje wiele sposobów
usunięcia rozszerzenia. Jeżeli nie wiesz, jak to zrobić, zajrzyj do rozdziału 3.). Zmień nazwę
kolumny na Rok.
8. Zmień nazwę kolumny Name na Miesiąc.
Kolumna Data zawiera obiekty Table reprezentujące zagregowane tabele. Zanim je
zdekomponujesz, usuń z każdej z nich pierwszy wiersz, który nie zawiera żadnych
wartościowych danych i zakłócałby dalszą pracę. Usuń również ostatnią kolumnę i ostatni
wiersz zawierające sumy przychodów. Kolejne kroki opisują, jak to zrobić.
9. W karcie Dodaj kolumnę kliknij ikonę Kolumna niestandardowa. W oknie o tej samej
nazwie, które się pojawi, wprowadź następujące zmiany.
365
4650570396d9eb2765da56c12eb840b5
4
a. W polu Nazwa nowej kolumny wpisz Pominięty pierwszy wiersz.

= Table.Skip([Data], 1)
c. Kliknij OK. Nowa kolumna będzie zawierała obiekty Table pozbawione pierwszych wierszy.
d. Usuń kolumnę Data.
a. W polu Nazwa nowej kolumny wpisz Pominięta kolumna sumująca.
= Table.RemoveColumns(
[Pominięty pierwszy wiersz], {
List.Last(Table.ColumnNames([Pominięty pierwszy wiersz]))
}
)
c. Kliknij OK. Powyższa formuła usuwa ostatnią kolumnę tabeli. Wykorzystana jest w niej
funkcja Table.ColumnNames zwracająca nazwy kolumn w każdym obiekcie w kolumnie
Pominięty pierwszy wiersz oraz funkcja List.Last zwracająca nazwę ostatniej kolumny.
d. Usuń kolumnę Pominięty pierwszy wiersz.
a. W polu Nazwa nowej kolumny wpisz Tabela podsumowująca.
= Table.RemoveLastN([Pominięta kolumna sumująca], 1)

c. Kliknij OK.
d. Usuń kolumnę Pominięta kolumna sumująca.
Uwaga. Inny niż opisany w krokach od 9. do 11. sposób uporządkowania tabel podsumowujących
polega na użyciu jednej funkcji. Utwórz puste zapytanie i wpisz następujący kod:
(tabelaWejściowa) =>
let
PominiętyPierwszyWiersz = Table.Skip(tabelaWejściowa, 1),
PominiętaKolumnaSumująca = Table.RemoveColumns(
PominiętyPierwszyWiersz, {
List.Last(Table.ColumnNames(PominiętyPierwszyWiersz))
}
),
Wynik = Table.RemoveLastN(PominiętaKolumnaSumująca, 1)
in
Wynik
Zmień nazwę zapytania na FnOczyszczenieTabeli, a następnie w karcie Dodaj kolumnę kliknij

ikonę Wywołaj funkcję niestandardową. W oknie, które się pojawi, wybierz powyższą funkcję
i kolumnę Data.
366
4650570396d9eb2765da56c12eb840b5
4
Część II. Dekompozycja tabel

W tej części ćwiczenia zastosujesz niestandardową funkcję FnDekomponujTabelę. Przypomnij sobie,
jak w ćwiczeniu 7.3 utworzyłeś funkcję dekomponującą tabelę. Teraz za pomocą funkcji przekształcisz
tabele zawierające przychody firmy Światowi Importerzy za lata 2015 – 2017. W tym celu wykonaj
poniższe kroki.
12. Skopiuj funkcję FnDekomponujTabelę, którą utworzyłeś w ćwiczeniu 7.3.
a. Zapisz raport, ale nie zamykaj go.
b. Otwórz skoroszyt R07-03 - rozwiązanie.xlsx.
c. W karcie Dane kliknij ikonę Zapytania i połączenia.
d. W panelu o tej samej nazwie kliknij prawym przyciskiem myszy funkcję
FnDekomponujTabelę i wybierz polecenie Kopiuj.
e. Wróć do skoroszytu lub raportu z ćwiczeniem 14.1 i otwórz edytor Power Query.
f. Kliknij prawym przyciskiem myszy puste miejsce w panelu Zapytania i z podręcznego
menu wybierz polecenie Wklej. W ten sposób skopiujesz funkcję FnDekomponujTabelę.
13. W panelu Zapytania zaznacz zapytanie Przychody.
a. W polu Nazwa nowej kolumny wpisz Zdekomponowana.
b. W polu Formuła kolumny niestandardowej wpisz poniższą formułę (patrz rysunek 14.2):
= FnDekomponujTabelę([Tabela podsumowująca], {"Kategoria klienta", "Miasto"},

{"Kolor", "Kategoria dostawcy", "Nazwa dostawcy"}, "Przychód")
c. Kliknij OK.
d. Usuń kolumnę Tabela podsumowująca.
RYSUNEK 14.2. Aby zdekomponować tabelę podsumowującą, użyj kolumny niestandardowej

z funkcją FnDekomponujTabelę
367
4650570396d9eb2765da56c12eb840b5
4
15. Rozwiń kolumnę Zdekomponowana. W panelu, który się pojawi, usuń zaznaczenie opcji
Użyj oryginalnej nazwy kolumny jako prefiksu i kliknij OK.
W panelu podglądu pojawią się dane ze wszystkich zdekomponowanych tabel. Teraz czas zająć
się przychodami za 2018 r.
Część III. Agregacja danych za 2018 r.

Jak pamiętasz, w kroku 3. ćwiczenia wykluczyłeś plik 2018.csv zawierający pary danych atrybut-wartość
oddzielone średnikami. Przyjmijmy założenie, że w każdym wielowierszowym rekordzie pierwszy
atrybut ma nazwę Data. W tej części ćwiczenia zaimportujesz ten plik i zagregujesz dane w sposób
opisany w rozdziale 7. W tym celu wykonaj poniższe kroki.
16. W karcie Strona główna rozwiń ikonę Nowe źródło, wybierz polecenia Plik/Plik tekstowy lub
CSV i zaimportuj plik 2018.csv. Zmień nazwę utworzonego zapytania na Przychody 2018.
17. W kolumnie Przekształć kliknij ikonę Użyj pierwszego wiersza jako nagłówków.
18. W kolumnie Dodaj kolumnę kliknij ikonę Kolumna indeksu.
19. W kolumnie Dodaj kolumnę kliknij ikonę Kolumna warunkowa. W oknie Dodawanie
kolumny warunkowej, które się pojawi, wprowadź następujące zmiany.
a. W polu Nazwa nowej kolumny wpisz ID wiersza.
b. W rozwijanej liście Nazwa kolumny wybierz pozycję Atrybut.
c. W rozwijanej liście Operator wybierz pozycję równa się.
d. W polu Wartość wpisz Data.
e. W pierwszej rozwijanej liście Wartość wyjściowa wskaż pozycję Wybierz kolumnę,
a w drugiej liście wybierz pozycję Indeks.
f. W polu W przeciwnym razie wpisz null.
g. Kliknij OK.
20. Zaznacz kolumnę ID wiersza, a następnie w karcie Przekształć kliknij ikonę Wypełnij
i wybierz polecenie W dół. Usuń kolumnę Indeks.
21. Zaznacz kolumnę Atrybut, a następnie w karcie Przekształć kliknij ikonę Kolumna
przestawna. W oknie o tej samej nazwie, które się pojawi, wprowadź następujące zmiany.
d. Kliknij OK.
22. Usuń kolumnę ID wiersza.
Zagregowałeś przychody za 2018 r., więc teraz pora scalić wszystkie dane.
368
4650570396d9eb2765da56c12eb840b5
4
Część IV. Scalenie przychodów za lata 2015 – 2017 i za rok 2018

Kroki, które wykonasz w tej części ćwiczenia, zostały opisane w rozdziale 4., „Łączenie niezgodnych
tabel”. W tej chwili masz dwie tabele z kolumnami o niezgodnych nazwach. Zwróć uwagę, że
zapytanie Przychody zawiera kolumny Rok i Miesiąc, a zapytanie Przychody 2018 kolumnę Data.
Wykonaj teraz poniższe kroki.
23. Zaznacz w zapytaniu Przychody kolumny Rok i Miesiąc, a następnie w karcie Przekształć
kliknij ikonę Scal kolumny.
24. W oknie o tej samej nazwie, które się pojawi, w rozwijanej liście wybierz pozycję Spacja,
a w polu Nazwa nowej kolumny (opcjonalnie) wpisz Data. Kliknij OK.
25. W karcie Strona główna kliknij ikonę Dołącz zapytania. W oknie Dołączanie, które się
pojawi, w rozwijanej liście Tabela do dołączenia wybierz pozycję Przychody 2018 i kliknij OK.
Uwaga. W kroku 14. określiłeś nazwy kolumn w zdekomponowanej tabeli zawierającej dane za
lata 2015 – 2017. Jeżeli nazwy te są inne niż podane w argumentach PolaWierszy i PolaKolumn
funkcji FnDekomponujTabelę, w tym kroku pojawią się dodatkowe kolumny o niezgodnych
nazwach. Aby to poprawić, użyj odpowiednich nazw w kroku 14. lub zmień nazwy kolumn
w zapytaniu Przychody 2018.
26. Zmień typ danych w kolumnie Przychód na Waluta lub Liczba dziesiętna, a kolumny Data
na typ Data.
27. Na koniec załaduj zapytanie Przychody do raportu i wyłącz ładowanie zapytania
Przychody 2018.
W Excelu: w karcie Dane kliknij ikonę Zapytania i połączenia. W panelu o tej samej nazwie
kliknij prawym przyciskiem myszy zapytanie Przychody 2018 i wybierz polecenie Załaduj do.
W oknie Importowanie danych, które się pojawi, zaznacz opcję Utwórz tylko połączenie
i kliknij OK.
W Power BI Desktop: w edytorze Power Query kliknij prawym przyciskiem myszy
zapytanie Przychody 2018 i usuń zaznaczenie opcji Włącz ładowanie.
Ćwiczenie 14.2. Porównanie tabel i śledzenie hakera

W ćwiczeniu 14.1 pomyślnie odtworzyłeś raport przychodów, dzięki czemu zarząd mógł podjąć
decyzje oparte na racjonalnych przesłankach, a firma Światowi Importerzy mogła kontynuować
swoją działalność po ataku hakera.
Zespół Cybersecurity poinformował, że haker zmienił dane o przychodach. Twoim kolejnym
zadaniem jest porównanie wyników ćwiczenia 14.1 ze zhakowanymi danymi zapisanymi w pliku
R14-02 - zhakowane dane.xlsx. Czy potrafisz znaleźć wiersze zmienione przez hakera i komunikat,
jaki pozostawił w tabeli?
Wykonaj to zadanie za pomocą zapytania porównującego dane zapisane w plikach
R14-01 - rozwiązanie.xlsx i R14-02 - zhakowane dane.xlsx. Na razie nie możesz wyszukać różnic
za pomocą tabel przestawnych ani miar DAX, dlatego wykorzystaj do tego celu edytor Power Query.
369
4650570396d9eb2765da56c12eb840b5
4
Wskazówki
Jeżeli nie wiesz, jak wykonać to zadanie, skorzystaj z poniższych wskazówek.
1. Haker zmienił dane w kolumnie Przychód. Aby znaleźć różnice, scal dwa zapytania,
wykorzystując wszystkie kolumny oprócz powyższej. Następnie rozwiń kolumnę Przychód
z drugiego zapytania i zastosuj filtr wyszukujący różnice w tej kolumnie w obu zapytaniach.
2. Aby znaleźć wiersze dodane przez hakera, scal kolumny w tabeli uzyskanej w ćwiczeniu 14.1
ze zhakowaną tabelą za pomocą prawego antysprzężenia. Dzięki temu po rozwinięciu
kolumny pojawią się wiersze, które istnieją tylko w zhakowanej tabeli.
Rozwiązanie
Aby wyszukać wiersze ze zmienionymi przychodami, scal dwie tabele za pomocą wszystkich kolumn
oprócz Przychód. Jeżeli nie wiesz, jak to zrobić, wykonaj poniższe kroki.
1. Zaimportuj do edytora Power Query w Excelu lub Power BI Desktop dane z pliku
R14-01 - rozwiązanie.xlsx. Zmień nazwę nowego zapytania na Poprawne.
2. Zaimportuj dane z pliku R14-02 - zhakowane dane.xlsx. Zmień nazwę nowego zapytania
na Zhakowane.
3. W panelu Zapytania zaznacz zapytanie Poprawne, a następnie w karcie Strona główna
rozwiń ikonę Scal zapytania i wybierz polecenie Scal zapytania jako nowe.
4. W oknie Scalanie, które się pojawi, wprowadź następujące zmiany.
a. W pierwszej tabeli zaznacz, trzymając przyciśnięty klawisz Ctrl, kolumny Data, Kolor,
Kategoria dostawcy, Nazwa dostawcy, Kategoria klienta i Miasto. Ważna jest kolejność kolumn.
b. W rozwijanej liście poniżej wybierz pozycję Zhakowane. W drugiej tabeli zaznacz,
trzymając przyciśnięty klawisz Ctrl, kolumny Data, Kolor, Kategoria dostawcy,
Nazwa dostawcy, Kategoria klienta i Miasto. Ważna jest kolejność kolumn.
c. W rozwijanej liście Rodzaj sprzężenia wybierz Wewnętrzne (tylko pasujące wiersze),
tak jak na rysunku 14.3. Kliknij OK, aby zamknąć okno.
5. Zmień nazwę nowego zapytania na Zmienione wiersze, a następnie rozwiń kolumnę
Zhakowane. W panelu, który się pojawi, usuń zaznaczenie wszystkich pozycji oprócz
Przychód. Zaznacz opcję Użyj oryginalnej nazwy kolumny jako prefiksu i kliknij OK.
Aby wyszukać wiersze z niezgodnymi wartościami, musisz zastosować warunek, którego nie
można zdefiniować za pomocą interfejsu programu. Dlatego zdefiniuj przejściowy warunek,
a następnie zmień go w pasku formuły.
6. W nagłówku kolumny Przychód kliknij ikonę filtru i wybierz polecenia Filtry liczb i Nie
równa się. W oknie Filtrowanie wierszy, które się pojawi, wpisz w polu obok rozwijanej listy
nie równa się liczbę 12345 i kliknij OK. W pasku formuły pojawi się następujący kod:
= Table.SelectRows(#"Rozwinięty element Zhakowane", each [Przychód] <> 12345)
7. Aby znaleźć wiersze, które w kolumnach Przychód i Zhakowane.Przychód zawierają różne
wartości, zmień formułę, tak jak niżej:
= Table.SelectRows(#"Rozwinięty element Zhakowane", each [Przychód] <> [Zhakowane.Przychód])
Powinno pojawić się siedem wierszy z różnymi wartościami w kolumnach Przychód
i Zhakowane.Przychód.
370
4650570396d9eb2765da56c12eb840b5
4
RYSUNEK 14.3. Za pomocą przekształcenia Scal zapytania możesz porównywać dwie tabele i wyszukiwać
różnice w wartościach
Szukanie śladów hakera w zmienionej tabeli

W kolejnym zadaniu zastosujesz prawe antysprzężenie, aby wyszukać wiersze dodane do tabeli
przez hakera. W tym celu wykonaj poniższe kroki.
8. W panelu Zapytania zaznacz zapytanie Poprawne, a następnie w karcie Strona główna
rozwiń ikonę Scal zapytania i wybierz polecenie Scal zapytania jako nowe.
9. W oknie Scalanie, które się pojawi, wprowadź następujące zmiany.
a. W pierwszej tabeli zaznacz, trzymając przyciśnięty klawisz Ctrl, kolumny Data, Kolor,
Kategoria dostawcy, Nazwa dostawcy, Kategoria klienta i Miasto. Ważna jest kolejność
kolumn.
b. W rozwijanej liście poniżej wybierz pozycję Zhakowane. W drugiej tabeli zaznacz,
trzymając przyciśnięty klawisz Ctrl, kolumny Data, Kolor, Kategoria dostawcy,
Nazwa dostawcy, Kategoria klienta i Miasto. Ważna jest kolejność kolumn.
c. W rozwijanej liście Rodzaj sprzężenia wybierz Prawe anty (wiersze tylko w drugiej)
i kliknij OK.
371
4650570396d9eb2765da56c12eb840b5
4
10. Zmień nazwę nowego zapytania na Ślad hakera.

11. Zaznacz kolumnę Zhakowane i usuń pozostałe kolumny.
12. Rozwiń wszystkie pola w kolumnie Zhakowane.
13. Odczytaj komunikat hakera.
14. Załaduj komunikat hakera do skoroszytu Excela lub raportu Power BI.
Zobacz też. Zaawansowane zapytania porównujące tabele opisane są w następujących wpisach

na blogu:
 https://datachant.com/downloads/compare-tables-excel-power-bi
 https://datachant.com/2017/08/10/compare-tables-excel-power-bi-part-2
Podsumowanie
Zakończyłeś swój ostatni projekt i oficjalnie stałeś się profesjonalnym analitykiem danych. Od teraz,
wyposażony w edytor Power Query, będziesz w stanie wywierać istotny wpływ na biznes swój
i Twojej firmy. W tym projekcie wykorzystałeś różne przekształcenia, m.in. łączenie kilku
skoroszytów, agregowanie i dekomponowanie tabel oraz scalanie zapytań.
Zachęcam, abyś tę książkę traktował jak przewodnik. Zachowaj pliki z rozwiązaniami do
ewentualnego wykorzystania w przyszłości, gdy będziesz się mierzył z nowymi zadaniami. Dane,
które będziesz przetwarzał, mogą być zupełnie inne niż użyte w tej książce, ale będziesz mógł
wykorzystywać opisane techniki i dostosowywać je do indywidualnych wymagań.
Poznawanie narzędzia Power Query jest ciągłym procesem. Aby rozwijać swoje umiejętności
przetwarzania danych, warto analizować za pomocą Power Query różne nieuporządkowane zbiory
i wciąż robić coś nowego. Teraz jest dobry moment, abyś wrócił do rozdziału 9., „Wprowadzenie
do języka M”, i sprawdził, jakie elementy języka M i jego składni znasz już lepiej i jak możesz go
wykorzystać do rozszerzenia zapytań, które utworzyłeś za pomocą interfejsu programu.
Na pewno w trakcie pracy z tą książką odkryłeś wiele nowych funkcjonalności narzędzia Power
Query w Excelu i Power BI, poznałeś ich zastosowania i przekonałeś się, że dzięki nim możesz
oszczędzić setki godzin pracy. Teraz jest dobry moment, abyś sprawdził, jak możesz wykorzystać
nabyte umiejętności w takich programach jak Microsoft Analysis Services, Microsoft Flows i Power
Apps, które również zawierają narzędzie Power Query. Twoja podróż dopiero się rozpoczęła.
Wierzę, że będzie Ci się podobać.
372
4650570396d9eb2765da56c12eb840b5
4
4650570396d9eb2765da56c12eb840b5
4

Power Query W Excelu I Power Bi Zbieranie I Przeksztalcanie Danych Gil Raviv Ebookpoint - PL

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Power Query W Excelu I Power Bi Zbieranie I Przeksztalcanie Danych Gil Raviv Ebookpoint - PL

Uploaded by

Copyright:

Available Formats

Tytuł oryginału: Collect, Combine, and Transform Data Using Power Query in Excel

and Power BI (Business Skills)

Tłumaczenie: Andrzej Watrak

Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej

Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi

 Poleć książkę na Facebook.com  Księgarnia internetowa

Rozdział 2. Podstawowe operacje przygotowywania danych ............................................45

Operacje na datach ........................................................................................................................69

Rozdział 3. Łączenie danych z kilku źródeł .........................................................................81

Rozdział 4. Łączenie niezgodnych tabel .............................................................................99

Rozdział 5. Pozyskiwanie kontekstu .................................................................................123

Rozdział 6. Dekomponowanie tabel .................................................................................145

Rozdział 7. Zaawansowane metody dekomponowania i agregowania tabel ...................163

Rozdział 8. Praca grupowa ...............................................................................................185

Rozdział 9. Wprowadzenie do języka M ...........................................................................205

Funkcje niestandardowe ............................................................................................................ 235

Rozdział 10. Od złych do dobrych zapytań .........................................................................245

Rozdział 11. Podstawy analizy tekstu .................................................................................273

Jakiej metody użyć: zwykłego wyszukiwania, iloczynu kartezjańskiego

Rozdział 12. Zaawansowana analiza tekstu: rozpoznawanie znaczenia .............................305

Rozdział 13. Analiza sieci społecznościowych ....................................................................341

Rozdział 14. Końcowy projekt: wszystko razem .................................................................363

Gil Raviv jest certyfikowanym specjalistą Microsoft, prowadzi

Dla kogo jest ta książka?

W rozdziale 1., „Wprowadzenie do Power Query”, poznasz podstawy tego narzędzia

Pliki dołączone do książki

Wprowadzenie do Power Query

Rzecz jasna dzisiaj, w dobie ciągłych aktualizacji oprogramowania i technologii

Czym jest Power Query?

Historia Power Query w skrócie

W lutym 2013 r. Microsoft przekształcił narzędzie w dodatek do Excela i odłączył je od SQL

Zespół rozwijający Power Query rozpoczął wydawanie comiesięcznych aktualizacji dodatku, co

Gdzie znajduje się Power Query?

Główne komponenty Power Query

Pobieranie danych i tworzenie połączeń

RYSUNEK 1.5. Dane można importować z wielu różnych źródeł

Więcej szczegółowych informacji na temat dostępności źródeł danych w różnych

Najważniejsze elementy edytora Power Query

Wskazówka. Z kontekstowego menu w panelu podglądu możesz dowiadywać się o nowych

 Przekształć: w tej karcie można przekształcać wybrane kolumny. W zależności od typu

W tej książce poznasz na praktycznych, z życia wziętych przykładach najczęściej stosowane i

Ustawienia zapytań i zastosowane kroki

Pasek formuły, zaawansowany edytor i język M

Opcje zapytania w Excelu i Power BI Desktop

Ćwiczenie 1.1. Pierwsze kroki z Power Query

Po rozpakowaniu archiwum otwórz skoroszyt R01-01.xlsx i przejrzyj zawartą w nim tabelę

RYSUNEK 1.9. W oknie Nawigator można wybierać tabele do załadowania

Jeżeli w trzecim argumencie funkcji Text.Contains podasz Comparer.OrdinalIgnoreCase,

= Table.SelectRows(#"Usunięto kolumny", each Text.Contains([Produkt], "górski",

15. Zmień zapytanie, wykonując następując kroki.

Kluczem do sukcesu jest przede wszystkim dobre przygotowanie.

W TYM ROZDZIALE NAUCZYSZ SIĘ:

Praca z nieuporządkowanymi danymi może pochłaniać mnóstwo czasu. W przeszłości analitycy

Wyodrębnianie informacji z zakodowanych danych

RYSUNEK 2.1. W katalogu produktów Fabryki Przygód informacje o kategorii,

Ćwiczenie 2.1. Stary sposób: formuły Excela

1. Otwórz plik R02-01 - rozwiązanie.xlsx.

5. Kliknij komórkę H2. W pasku formuły pojawi się formuła:

=PODSTAW(FRAGMENT.TEKSTU(C2;SZUKAJ.TEKST("-";C2; 8); 3); "-"; "")

Ćwiczenie 2.2. Część I. Nowy sposób

b. Wskaż plik R02-02.xlsx i kliknij Importuj.

b. W panelu Zapytania zaznacz Kolory i wykonaj te same kroki, co poprzednio. Kolumny

 Wybrana jest opcja Niestandardowe i myślnik jako ogranicznik. Te ustawienia zostały