Wypełnij lukę SQL-NoSQL dzięki Apache Phoenix

Apache Phoenix to stosunkowo nowy projekt Java typu open source, który zapewnia sterownik JDBC i dostęp SQL do bazy danych NoSQL Hadoop: HBase. Został stworzony jako wewnętrzny projekt w Salesforce, otwarty w GitHub i stał się projektem najwyższego poziomu Apache w maju 2014. Jeśli masz duże umiejętności programowania SQL i chciałbyś móc ich używać z potężną bazą danych NoSQL, Phoenix może być dokładnie tym, czego szukasz!

Ten samouczek wprowadza deweloperów Java do Apache Phoenix. Ponieważ Phoenix działa na bazie HBase, zaczniemy od przeglądu HBase i tego, jak różni się on od relacyjnych baz danych. Dowiesz się, jak Phoenix wypełnia lukę między SQL i NoSQL oraz jak jest zoptymalizowany pod kątem wydajnej interakcji z HBase. Po usunięciu tych podstaw, resztę artykułu poświęcimy na naukę pracy z Phoenix. Skonfigurujesz i zintegrujesz HBase i Phoenix, utworzysz aplikację Java, która łączy się z HBase przez Phoenix, a także napiszesz pierwszą tabelę, wstawisz dane i uruchomisz na niej kilka zapytań.

Cztery typy magazynów danych NoSQL

To interesujące (i nieco ironiczne), że magazyny danych NoSQL są podzielone na kategorie według funkcji, której im brakuje, a mianowicie SQL. Magazyny danych NoSQL są dostępne w czterech głównych wersjach:

  1. Magazyny klucz / wartość odwzorowują określony klucz na wartość, która może być dokumentem, tablicą lub typem prostym. Przykłady magazynów klucz / wartość to Memcached, Redis i Riak.
  2. Magazyny dokumentów zarządzają dokumentami, które zwykle są strukturami bez schematu, takimi jak JSON, które mogą mieć dowolną złożoność. Większość magazynów dokumentów zapewnia obsługę indeksów głównych, a także indeksów pomocniczych i złożonych zapytań. Przykłady magazynów dokumentów obejmują MongoDB i CouchBase.
  3. Grafowe bazy danych koncentrują się przede wszystkim na relacjach między obiektami, w których dane są przechowywane w węzłach, oraz na relacjach między węzłami. Przykładem bazy danych grafów jest Neo4j.
  4. Bazy danych zorientowane na kolumny przechowują dane jako sekcje kolumn danych, a nie jako wiersze danych. HBase to baza danych zorientowana na kolumny, podobnie jak Cassandra.

HBase: podkład

Apache HBase to baza danych NoSQL, która działa na platformie Hadoop jako rozproszony i skalowalny magazyn dużych zbiorów danych. HBase to baza danych zorientowana na kolumny, która wykorzystuje możliwości przetwarzania rozproszonego Hadoop Distributed File System (HDFS) i paradygmatu programowania MapReduce firmy Hadoop. Został zaprojektowany do obsługi dużych tabel z miliardami wierszy i potencjalnie milionami kolumn, wszystkie działające w klastrze podstawowego sprzętu.

Apache HBase łączy w sobie moc i skalowalność platformy Hadoop z możliwością wykonywania zapytań dotyczących poszczególnych rekordów i wykonywania procesów MapReduce.

Oprócz możliwości odziedziczonych po Hadoop, HBase jest samą w sobie potężną bazą danych: łączy zapytania w czasie rzeczywistym z szybkością magazynu kluczy / wartości, solidną strategią skanowania tabel w celu szybkiego lokalizowania rekordów i obsługuje przetwarzanie wsadowe przy użyciu MapReduce. W związku z tym Apache HBase łączy w sobie moc i skalowalność Hadoop z możliwością wykonywania zapytań o poszczególne rekordy i wykonywania procesów MapReduce.

Model danych HBase

HBase organizuje dane inaczej niż tradycyjne relacyjne bazy danych, obsługując czterowymiarowy model danych, w którym każda „komórka” jest reprezentowana przez cztery współrzędne:

  1. Klucz wiersza : każdy wiersz ma unikalny klucz wiersza, który jest reprezentowany wewnętrznie przez tablicę bajtów, ale nie ma żadnego formalnego typu danych.
  2. Rodzina kolumn : dane zawarte w wierszu są podzielone na rodziny kolumn ; każdy wiersz ma ten sam zestaw rodzin kolumn, ale każda rodzina kolumn nie musi zachowywać tego samego zestawu kwalifikatorów kolumn. Można myśleć o rodzinach kolumn jak o tabelach w relacyjnej bazie danych.
  3. Kwalifikator kolumny : są podobne do kolumn w relacyjnej bazie danych.
  4. Wersja : każda kolumna może mieć konfigurowalną liczbę wersji . Jeśli zażądasz danych zawartych w kolumnie bez określania wersji, otrzymasz najnowszą wersję, ale możesz poprosić o starsze wersje, podając numer wersji.

Rysunek 1 pokazuje, jak te czterowymiarowe współrzędne są powiązane.

Steven Haines

Model na rysunku 1 pokazuje, że wiersz składa się z klucza wiersza i dowolnej liczby rodzin kolumn. Każdy klucz wiersza jest powiązany z kolekcją „wierszy w tabelach”, z których każdy ma własne kolumny. Chociaż każda tabela musi istnieć, kolumny w tabelach mogą być różne w różnych wierszach. Każda rodzina kolumn ma zestaw kolumn, a każda kolumna ma zestaw wersji, które są mapowane na rzeczywiste dane w wierszu.

Gdybyśmy modelowali osobę, kluczem wiersza mógłby być numer ubezpieczenia społecznego tej osoby (aby ją jednoznacznie zidentyfikować) i moglibyśmy mieć rodziny kolumn, takie jak adres, zatrudnienie, wykształcenie i tak dalej. Wewnątrz rodziny kolumn adresowych możemy mieć kolumny ulicy, miasta, stanu i kodu pocztowego, a każda wersja może odpowiadać miejscu zamieszkania danej osoby w danym czasie. Najnowsza wersja może zawierać nazwę miasta „Los Angeles”, a poprzednia może zawierać nazwę „Nowy Jork”. Ten przykładowy model można zobaczyć na rysunku 2.

Steven Haines

Podsumowując, HBase to zorientowana na kolumny baza danych, która reprezentuje dane w czterowymiarowym modelu. Jest zbudowany na bazie rozproszonego systemu plików Hadoop (HDFS), który dzieli dane na potencjalnie tysiące maszyn towarowych. Deweloperzy korzystający z HBase mogą uzyskiwać dostęp do danych bezpośrednio, uzyskując dostęp do klucza wiersza, skanując zakres kluczy wierszy lub korzystając z przetwarzania wsadowego za pośrednictwem MapReduce.

Badania fundamentalne

Być może znasz znane (dla maniaków) białe księgi dotyczące Big Data lub nie. Opublikowane przez Google Research w latach 2003-2006, te białe księgi przedstawiają badania trzech filarów ekosystemu Hadoop, jaki znamy:

  • System plików Google (GFS): rozproszony system plików Hadoop (HDFS) to implementacja GFS typu open source, która definiuje sposób dystrybucji danych w klastrze maszyn towarowych.
  • MapReduce: funkcjonalny paradygmat programowania służący do analizowania danych dystrybuowanych w klastrze HDFS.
  • Bigtable: rozproszony system pamięci masowej do zarządzania danymi strukturalnymi, który został zaprojektowany z myślą o skalowaniu do bardzo dużych rozmiarów - petabajtów danych na tysiącach maszyn towarowych. HBase to otwarta implementacja Bigtable.

Wypełnienie luki NoSQL: Apache Phoenix

Apache Phoenix to projekt Apache najwyższego poziomu, który zapewnia interfejs SQL do HBase, mapując modele HBase do świata relacyjnych baz danych. Oczywiście HBase zapewnia własne API i powłokę do wykonywania funkcji, takich jak skanowanie, pobieranie, wysyłanie, lista i tak dalej, ale więcej programistów zna SQL niż NoSQL. Celem Phoenix jest zapewnienie powszechnie zrozumiałego interfejsu dla HBase.

Pod względem funkcji Phoenix wykonuje następujące czynności:

  • Udostępnia sterownik JDBC do interakcji z HBase.
  • Obsługuje większość standardu ANSI SQL.
  • Obsługuje operacje DDL, takie jak CREATE TABLE, DROP TABLE i ALTER TABLE.
  • Obsługuje operacje DML, takie jak UPSERT i DELETE.
  • Kompiluje zapytania SQL do natywnych skanów HBase, a następnie mapuje odpowiedź na zestawy wyników JDBC.
  • Obsługuje wersje schematów.

Oprócz obsługi szerokiego zestawu operacji SQL, Phoenix jest również bardzo wydajny. Analizuje zapytania SQL, dzieli je na wiele skanów HBase i uruchamia je równolegle, używając natywnego interfejsu API zamiast procesów MapReduce.

Phoenix stosuje dwie strategie - koprocesory i niestandardowe filtry - w celu przybliżenia obliczeń do danych:

  • Koprocesory wykonują operacje na serwerze, co minimalizuje transfer danych klient / serwer.
  • Filtry niestandardowe zmniejszają ilość danych zwracanych w odpowiedzi na zapytanie z serwera, co dodatkowo zmniejsza ilość przesyłanych danych. Filtry niestandardowe są używane na kilka sposobów:
    1. Podczas wykonywania zapytania można użyć filtru niestandardowego, aby zidentyfikować tylko podstawowe rodziny kolumn wymagane do pomyślnego wyszukiwania.
    2. Pominąć filtr skanowania wykorzystuje SEEK_NEXT_USING_HINT HBase by szybko przejść z jednego rekordu do następnego, który przyspiesza zapytania punktowych.
    3. Filtr niestandardowy może „posolić dane”, co oznacza, że ​​dodaje bajt skrótu na początku klucza wiersza, dzięki czemu może szybko zlokalizować rekordy.

Podsumowując, Phoenix wykorzystuje bezpośredni dostęp do interfejsów API HBase, koprocesorów i niestandardowych filtrów, aby zapewnić wydajność na poziomie milisekund w przypadku małych zestawów danych i wydajność drugiego poziomu w przypadku dużych. Przede wszystkim Phoenix udostępnia te możliwości programistom za pośrednictwem znanego interfejsu JDBC i SQL.

Zacznij korzystać z Phoenix

Aby korzystać z Phoenix, musisz pobrać i zainstalować zarówno HBase, jak i Phoenix. Możesz znaleźć stronę pobierania Phoenix (i uwagi dotyczące zgodności HBase) tutaj.

Pobierz i skonfiguruj

W chwili pisania tego tekstu najnowsza wersja Phoenix to 4.6.0, a strona pobierania mówi, że 4.x jest kompatybilny z HBase w wersji 0.98.1+. Na przykład pobrałem najnowszą wersję Phoenix, która jest skonfigurowana do pracy z HBase 1.1. Można go znaleźć w folderze: phoenix-4.6.0-HBase-1.1/.

Oto konfiguracja:

  1. Download and decompress this archive and then use one of the recommended mirror pages here to download HBase. For instance, I selected a mirror, navigated into the 1.1.2 folder, and downloaded hbase-1.1.2-bin.tar.gz.
  2. Decompress this file and create an HBASE_HOME environment variable that points to it; for example, I added the following to my ~/.bash_profile file (on Mac): export HBASE_HOME=/Users/shaines/Downloads/hbase-1.1.2.

Integrate Phoenix with HBase

The process to integrate Phoenix into HBase is simple:

  1. Copy the following file from the Phoenix root directory to the HBase lib directory: phoenix-4.6.0-HBase-1.1-server.jar.
  2. Start HBase by executing the following script from HBase's bin directory:./start-hbase.sh.
  3. With HBase running, test that Phoenix is working by executing the SQLLine console, by executing following command from Phoenix's bin directory: ./sqlline.py localhost.

The SQLLine console

sqlline.py is a Python script that starts a console that connects to HBase's Zookeeper address; localhost in this case. You can walk through an example that I am going to summarize in this section here.

First, let's view all of the tables in HBase by executing !table:

 0: jdbc:phoenix:localhost> !tables +------------------------------------------+------------------------------------------+------------------------------------------+------------------------------------------+--------------------------+ | TABLE_CAT | TABLE_SCHEM | TABLE_NAME | TABLE_TYPE | REMARKS | +------------------------------------------+------------------------------------------+------------------------------------------+------------------------------------------+--------------------------+ | | SYSTEM | CATALOG | SYSTEM TABLE | | | | SYSTEM | FUNCTION | SYSTEM TABLE | | | | SYSTEM | SEQUENCE | SYSTEM TABLE | | | | SYSTEM | STATS | SYSTEM TABLE | | +------------------------------------------+------------------------------------------+------------------------------------------+------------------------------------------+--------------------------+ 

Because this is a new instance of HBase the only tables that exist are system tables. You can create a table by executing a create table command:

 0: jdbc:phoenix:localhost>create table test (mykey integer not null primary key, mycolumn varchar); No rows affected (2.448 seconds) 

This command creates a table named test, with an integer primary key named mykey and a varchar column named mycolumn. Now insert a couple rows by using the upsert command:

 0: jdbc:phoenix:localhost>upsert into test values (1,'Hello'); 1 row affected (0.142 seconds) 0: jdbc:phoenix:localhost>upsert into test values (2,'World!'); 1 row affected (0.008 seconds) 

UPSERTto polecenie SQL służące do wstawiania rekordu, jeśli nie istnieje, lub aktualizowania rekordu, jeśli istnieje. W tym przypadku wstawiliśmy (1, „Hello”) i (2, „World!”). Pełną listę poleceń programu Phoenix można znaleźć tutaj. Na koniec zapytaj swoją tabelę, aby zobaczyć wartości, które zwiększyłeś, wykonując select * from test:

 0: jdbc:phoenix:localhost>select * from test; +------------------------------------------+------------------------------------------+ | MYKEY | MYCOLUMN | +------------------------------------------+------------------------------------------+ | 1 | Hello | | 2 | World! | +------------------------------------------+------------------------------------------+ 2 rows selected (0.111 seconds) 

Zgodnie z oczekiwaniami zobaczysz właśnie wstawione wartości. Jeśli chcesz wyczyścić tabelę, wykonaj drop table testpolecenie.