Permalink
Browse files

praca z bazami danych

  • Loading branch information...
pbiecek committed Mar 13, 2016
1 parent 55bdea7 commit d87020e7cc8d2958cc9e712bc2c06ddf516c3155
Showing with 3,342 additions and 750 deletions.
  1. BIN .rmdbuild
  2. +4 −0 Analiza/wizualizacja.md
  3. +1 −0 Programowanie/jak_pobierac_dane_z_twittera.Rmd
  4. +1 −0 Programowanie/jak_pobierac_dane_z_twittera.md
  5. +182 −0 Programowanie/jak_pracowac_z_bazami_danych.Rmd
  6. +361 −0 Programowanie/jak_pracowac_z_bazami_danych.md
  7. BIN Programowanie/zabawka.db
  8. +1 −0 SUMMARY.md
  9. BIN _book/.rmdbuild
  10. +32 −17 _book/Analiza/analizadanych_z_programem_r_md.html
  11. +32 −17 _book/Analiza/eksploracja.html
  12. +32 −17 _book/Analiza/jak_badac_rozklad_dwoch_zmiennych.html
  13. +32 −17 _book/Analiza/jak_badac_rozklad_jednej_zmiennej.html
  14. +32 −17 _book/Analiza/jak_badac_wlasciwosci_jednej_zmiennej.html
  15. +32 −17 _book/Analiza/jak_badac_zaleznosci_pomiedzy_para_zmiennych.html
  16. +32 −17 _book/Analiza/jak_rozpoznac_rodzaj_zmiennej.html
  17. +32 −17 _book/Analiza/jak_tworzyc_wykresy_ggplot2.html
  18. +32 −17 _book/Analiza/weryfikacja.html
  19. +2 −1 _book/Analiza/wizualizacja.Rmd
  20. +36 −17 _book/Analiza/wizualizacja.html
  21. +32 −17 _book/Programowanie/arrange.html
  22. +32 −17 _book/Programowanie/czyscic_przetwarzac.html
  23. +32 −17 _book/Programowanie/filter.html
  24. +33 −18 _book/Programowanie/generatory_1.html
  25. +33 −18 _book/Programowanie/generatory_2.html
  26. +33 −18 _book/Programowanie/generatory_3.html
  27. +33 −18 _book/Programowanie/generatory_4.html
  28. +33 −18 _book/Programowanie/generatory_5.html
  29. +35 −20 _book/Programowanie/generatory_llosowych.html
  30. +32 −17 _book/Programowanie/groupby.html
  31. +33 −18 _book/Programowanie/jak_korzystac_z_serwisu_github_i_waffle.html
  32. +33 −18 _book/Programowanie/jak_korzystac_z_serwisu_waffle.html
  33. +1 −0 _book/Programowanie/jak_pobierac_dane_z_twittera.Rmd
  34. +33 −17 _book/Programowanie/jak_pobierac_dane_z_twittera.html
  35. +32 −17 _book/Programowanie/jak_pobrac_dane_z.html
  36. +182 −0 _book/Programowanie/jak_pracowac_z_bazami_danych.Rmd
  37. +1,208 −0 _book/Programowanie/jak_pracowac_z_bazami_danych.html
  38. +34 −19 _book/Programowanie/jak_tworzyc_raporty.html
  39. +32 −17 _book/Programowanie/jak_wczytac_dane_z_excela.html
  40. +32 −17 _book/Programowanie/jak_wczytac_tabele_danych_z_pliku_csv_lub_txt.html
  41. +32 −17 _book/Programowanie/jak_wczytywac_korpusy_tekstu.html
  42. +32 −17 _book/Programowanie/jak_wczytywac_tabele_z_formatu_html.html
  43. +32 −17 _book/Programowanie/jak_zeskrobywac_dane_ze_stron_www_uzywajac_pakietu.html
  44. +32 −17 _book/Programowanie/mutate.html
  45. +32 −17 _book/Programowanie/potoki.html
  46. +32 −17 _book/Programowanie/select.html
  47. +32 −17 _book/Programowanie/tidyr.html
  48. BIN _book/Programowanie/zabawka.db
  49. +32 −17 _book/Programowanie/zadania.html
  50. +32 −17 _book/Programowanie/zadaniaDplyr.html
  51. +32 −17 _book/Programowanie/zapisywac.html
  52. +32 −17 _book/Wizualizacja/jak_tworzyc_interaktywne_wykresy.html
  53. +32 −17 _book/co_nowego.html
  54. +32 −17 _book/contribute.html
  55. +32 −17 _book/index.html
  56. +1 −1 _book/mytheme/templates/ebook/footer.html
  57. +1 −1 _book/mytheme/templates/ebook/header.html
  58. +1 −1 _book/mytheme/templates/website/includes/book/progress.html
  59. +1 −1 _book/mytheme/templates/website/includes/book/summary.html
  60. +1 −1 _book/mytheme/templates/website/langs.html
  61. +32 −17 _book/puste.html
  62. +32 −17 _book/references.html
  63. +1 −1 _book/search_index.json
View
BIN .rmdbuild
Binary file not shown.
View
@@ -5,3 +5,7 @@ Wizualizacja danych to dalece więcej niż zbiór technik do rysowania wykresów
Aby rozwijać ten sposób myślenia potrzebne są narzędzia, pozwalające na eksperymentowanie z danymi. W tym rozdziale przedstawimy dobre narzędzia, takie jak pakiet `ggplot2` oparty o gramatykę języka wizualizacji danych, pakiet `rCharts` do tworzenia interaktywnych wykresów czy kilka innych przydatnych rozwiązań.
## Węcej źródeł
* *Graphical Data Analysis with R*, Antony Unwin http://www.gradaanwr.net/
@@ -139,3 +139,4 @@ Poza filtrowaniem twittera w poszukiwaniu wiadomości pasujących do określonyc
* Funkcja `mentions()` pozwala na pobieranie wiadomości, w których określony użytkownik został mieniony.
* Funkcja `retweetsOfMe()` pozwala na zliczanie liczby retwittów kolejnych wiadomości.
Aby korzystać z powyżej opisanych pakietów należy pobrać z konta odpowiednie klucze. Szczegółowa instrukacj jak to zrobić, krok po kroku po stronie Twittera, znajduje się na stronie http://bigcomputing.blogspot.com/2016/02/the-twitter-r-package-by-jeff-gentry-is.html.
@@ -144,3 +144,4 @@ Poza filtrowaniem twittera w poszukiwaniu wiadomości pasujących do określonyc
* Funkcja `mentions()` pozwala na pobieranie wiadomości, w których określony użytkownik został mieniony.
* Funkcja `retweetsOfMe()` pozwala na zliczanie liczby retwittów kolejnych wiadomości.
Aby korzystać z powyżej opisanych pakietów należy pobrać z konta odpowiednie klucze. Szczegółowa instrukacj jak to zrobić, krok po kroku po stronie Twittera, znajduje się na stronie http://bigcomputing.blogspot.com/2016/02/the-twitter-r-package-by-jeff-gentry-is.html.
@@ -0,0 +1,182 @@
# Jak pracować z bazami danych?
Zdecydowana większość funkcji w programie R wymaga by dane na których pracujemy były w pamięci RAM.
A jeżeli chcemy pracować z dużymi zbiorami danych, które zajmują dużo miejsca, to mamy dwie możliwości:
* pracować na ,,tłustych’’ komputerach z dużą ilością RAM (jednak na dzień dzisiejszy dzisiaj trudno wyjść poza 1 TB RAM, chyba że ma się baaardzo duży budżet),
* trzymać dane poza R, możliwie dużo przetwarzania wykonywać poza R, a do R wczytywać tylko takie dane, które są naprawdę niezbędne. Poza R, oznacza tutaj w bazie danych.
Nawet jeżeli danych nie jest bardzo dużo, to bazy dane mogą być używany by zapewnić jednolity sposób dostępu do danych z różnych narzędzi, by efektywnie zarządzać danymi, by zapewnić skalowalność operacji na danych.
Poniżej przedstawiamy dwa przykłady komunikacji R z bazami danych.
Pierwszy przykład będzie dotyczył prostej bazy danych `SQLite` bazującej na jednym pliku. Są to najczęściej zabawkowe przykłady pozwalające na przećwiczenie podstawowych operacji. Drugi przykład będzie dotyczył pracy z popularną bazą PostgreSQL. Sposób pracy z nią jest bardzo podobny do większości popularnie stosowanych baz relacyjnych.
## Jak pracować z bazą danych SQLite?
SQLite to lekka baza danych oparta o jeden plik. Ma ona dosyć ograniczone funkcjonalności, ale tak prosto ją zainstalować, że wręcz trudno powiedzieć w którym momencie się to robi. Łatwo też tę bazę skopiować czy komuś wysłać. Dlatego pomimo ograniczonych możliwości ma ona sporo zastosowań w których liczby się prostota nad skalowalnością.
Aby korzystać z tej bazy danych potrzebny jest pakiet `RSQLite`.
Korzystanie z tej bazy składa się z następujących kroków
* Należy wczytać sterownik do łączenia się z bazą danych, najczęściej funkcją `dbDriver()`.
* Należy nawiązać połączenie z bazą danych, najczęściej funkcją `dbConnect()`. W przypadku bazy SQLite wystarczy wskazać ścieżkę do pliku z bazą danych.
* Operacje na bazie danych wykonuje się poprzez nawiązane połączenie.
* Po zakończeniu pracy z bazą danych należy zwolnić połączenie (funkcja `dbDisconnect()`) i sterownik.
Przykładowa sesja z bazą danych jest następująca.
Ładujemy sterownik do bazy danych i inicjujemy połączenie z serwerem bazodanowym. Jeżeli wskazany plik nie istnieje, to zostanie stworzony z pustą bazą danych.
```{r, message=FALSE, warning=FALSE}
library("RSQLite")
sterownik <- dbDriver("SQLite")
polaczenie <- dbConnect(sterownik, "zabawka.db")
```
Wyświetlamy tabele widoczne w bazie danych pod wskazanym połączeniem a następnie wyświetlamy kolumny w określonej tabeli.
```{r}
dbListTables(polaczenie)
dbListFields(polaczenie, "auta2012")
```
Używając funkcji `dbGetQuery()` możemy wykonać na bazie zapytanie SQL.
```{r}
pierwsze5 <- dbGetQuery(polaczenie,
"select Cena, Waluta, Marka, Model from auta2012 limit 5")
pierwsze5
agregat <- dbGetQuery(polaczenie,
"select count(*) as liczba, avg(`Cena.w.PLN`) as cena, Marka from auta2012 group by Marka limit 10")
agregat
```
Używając funkcji `dbDisconnect()` możemy się z bazą danych rozłączyć. Ważne jest by po sobie sprzątać na wypadek gdyby dane z pamięci nie zostały zapisane do pliku.
```{r}
dbDisconnect(polaczenie)
```
Funkcja `dbGetQuery()` tworzy zapytanie i pobiera jego wyniki. Tą operacje można robić na części. Funkcja `dbSendQuery()` jedynie tworzy i wysyła zapytanie SQL do bazy, a funkcja `fetch()` pobiera kolejne porcje danych.
Funkcja `dbWriteTable()` zapisuje wskazany obiekt `data.table` jako tabelę w bazie danych.
## Jak pracować z relacyjnymi bazami danych?
SQLite to baza zabawka. Do przechowywania większych danych w produkcyjnych rozwiązaniach wykorzystywać można otwarte rozwiązania typu PostgreSQL czy MySQL lub komercyjnie rozwijane silniki bazodanowe takie jak Oracle, RedShift, Teradata, Netezza i inne.
O ile te bazy różnią się funkcjonalnością, skalowalnością i prędkością, to z perspektywy użytkownika R korzystanie z nich jest dosyć podobne. Poniżej pokażemy jak korzystać z PostgreSQL.
Jako przykład, wykorzystamy bazę PostgreSQL dostępną na serwerze `services.mini.pw.edu.pl`. PostgreSQL pozwala na zarządzanie wieloma użytkownikami i wieloma bazami danych, tutaj wykorzystamy bazę `sejmrp` przechowującą dane z Sejmu RP 7 i 8 kadencji (głosowania i stenogramy). Dane te są uzupełniane za pomocą pakietu [sejmRP](https://github.com/mi2-warsaw/sejmRP).
Aby korzystać z bazy danych potrzebny jest użytkownik i hasło. Poniżej przedstawimy przykład dla użytkownika `reader` i hasła `qux94874`. Ten użytkownik ma wyłącznie uprawnienia do czytania.
Aby połączyć się z bazą PostgreSQL potrzebujemy sterownika, który jest dostępny w pakiecie `RPostgreSQL`. Wczytajmy ten pakiet i nawiążmy połączenie z bazą danych.
```{r, message=FALSE, warning=FALSE}
library(RPostgreSQL)
dbname = "sejmrp"
user = "reader"
password = "qux94874"
host = "services.mini.pw.edu.pl"
sterownik <- dbDriver("PostgreSQL")
polaczenie <- dbConnect(sterownik, dbname = dbname, user = user, password = password, host = host)
```
Możemy teraz zadawać dowolne zapytania SQL, pobierać i wysyłać całe tabele z danymi.
```{r}
gadki <- dbGetQuery(polaczenie, "SELECT * FROM statements ORDER BY nr_term_of_office, id_statement limit 1")
gadki
glosy <- dbGetQuery(polaczenie, "SELECT club, vote, count(*) FROM votes GROUP BY club, vote limit 12")
glosy
```
Na koniec pracy należy rozłączyć się z bazą danych i zwolnić połączenie.
```{r}
dbDisconnect(polaczenie)
```
## Jak używać pakietu dplyr w pracy z bazami danych?
Standardów i implementacji SQLa jest tak wiele, że zastanawiające jest dlaczego nazywane są standardami. Praktycznie każda baza danych różni się listą zaimplementowanych funkcjonalności czy agregatów. Jeżeli pracujemy z jedną bazą danych to ta różnorodność może nam to nie doskwierać. Ale jeżeli przyjdzie nam jednocześnie korzystać z MSSQL’a, MySQLa, RedShifta i Postgresa? Lub gdy okaże się, że dane zostały zmigrowane na nową bazę danych?
Wielu problemów można sobie oszczędzić używając pośrednika do komunikacji z bazą danych. Takim pośrednikiem może być pakiet `dplyr` omówiony w poprzednim rozdziale.
Pozwala on do pewnego stopnia na pracę z danymi bez zastanawiania się gdzie te dane aktualnie są i jak nazywa się w tym systemie bazodanowym potrzebna nam funkcja.
W pakiecie `dplyr` połączenia ze źródłem danych (tabelą z liczbami lub bazą danych) tworzy się funkcjami `src_*`.
Poniżej skorzystamy z funkcji `src_sqlite()` i `src_postgres()`.
Zainicjujmy połączenie z bazą SQLite i pobierzmy kilka pierwszych wierszy z tabeli `auta2012`.
```{r}
library(dplyr)
polaczenie <- src_sqlite(path = 'zabawka.db')
auta1 <- tbl(polaczenie, "auta2012")
```
Mając taki obiekt, reszta operacji wygląda tak jak w zwykłym `dplyr`.
```{r}
auta1 %>%
head(2)
```
A teraz pokażmy przykład dla bazy PostgreSQL. Zainicjujmy połączenie do tabeli `votes`.
```{r}
polaczenie <- src_postgres(dbname = dbname,
host = host, user = user, password = password)
src_tbls(polaczenie)
glosy <- tbl(polaczenie, "votes")
```
Zdefiniowawszy połączenie możemy na tej tabeli robić dosyć zaawansowane rzeczy używając już znanych funkcji z pakietu `dplyr`.
```{r}
glosy %>%
group_by(club, vote) %>%
summarise(liczba = n()) ->
liczba_glosow
class(liczba_glosow)
```
Wynikiem tych operacji jest obiekt klasy `tbl_sql`. Nie przechowuje on jednak danych, ale instrukcje pozwalające na dostęp do danych (zapytanie SQL). Można to zapytanie i plan zapytania wyłuskać
```{r}
liczba_glosow$query
explain(liczba_glosow)
```
Leniwość ale nie lenistwo. Operacje na tych obiektach nie są materializowane o ile nie muszą być materializowane (użytkownik wprost tego zażąda). Gdy już jest jasne co użytkownik chce zrobić i gdy jawnie zażąda wyniku, wszystkie operacje są wykonywane w możliwie małej liczbie (=jeden) kroków.
Materializować wyniki można na dwa sposoby
* `collect()` - wyznacza wynik oraz pobiera do R,
* `compute()` - wyznacza wynik i zapisuje w tymczasowej tabeli w bazie danych.
Poniższa instrukcja pobierze wyliczone agregaty ze zbioru danych.
```{r}
collect(liczba_glosow)
```
Więcej informacji o funkcjach z pakietu `dplyr`, które można stosowac do baz danych znaleźć można na stronie http://cran.rstudio.com/web/packages/dplyr/vignettes/databases.html.
## Do ćwiczeń
Czego potrzebuje użytkownik `mi2user`?
```{r}
digest::digest("All you need is R")
```
I funkcji `copy_to`, która zapisuje lokalną tabelę do bazy danych.
Oops, something went wrong.

0 comments on commit d87020e

Please sign in to comment.