Menjembatani kesenjangan SQL-NoSQL dengan Apache Phoenix

Apache Phoenix adalah proyek Java open source yang relatif baru yang menyediakan driver JDBC dan akses SQL ke database NoSQL Hadoop: HBase. Itu dibuat sebagai proyek internal di Salesforce, bersumber terbuka di GitHub, dan menjadi proyek Apache tingkat atas pada Mei 2014. Jika Anda memiliki keterampilan pemrograman SQL yang kuat dan ingin dapat menggunakannya dengan database NoSQL yang kuat, Phoenix bisa jadi persis seperti yang Anda cari!

Tutorial ini memperkenalkan developer Java ke Apache Phoenix. Karena Phoenix berjalan di atas HBase, kita akan mulai dengan gambaran umum tentang HBase dan perbedaannya dari database relasional. Anda akan mempelajari bagaimana Phoenix menjembatani kesenjangan antara SQL dan NoSQL, dan bagaimana itu dioptimalkan untuk berinteraksi secara efisien dengan HBase. Dengan mengetahui dasar-dasar tersebut, kita akan menghabiskan sisa artikel ini untuk mempelajari cara bekerja dengan Phoenix. Anda akan menyiapkan dan mengintegrasikan HBase dan Phoenix, membuat aplikasi Java yang terhubung ke HBase melalui Phoenix, dan Anda akan menulis tabel pertama Anda, menyisipkan data, dan menjalankan beberapa kueri di atasnya.

Empat jenis penyimpanan data NoSQL

Sangat menarik (dan agak ironis) bahwa penyimpanan data NoSQL dikategorikan berdasarkan fitur yang kurang, yaitu SQL. Penyimpanan data NoSQL hadir dalam empat bentuk umum:

  1. Penyimpanan kunci / nilai memetakan kunci tertentu ke suatu nilai, yang bisa berupa dokumen, larik, atau tipe sederhana. Contoh penyimpanan kunci / nilai termasuk Memcached, Redis, dan Riak.
  2. Penyimpanan dokumen mengelola dokumen, yang biasanya merupakan struktur tanpa skema, seperti JSON, yang dapat memiliki kompleksitas arbitrer. Sebagian besar penyimpanan dokumen menyediakan dukungan untuk indeks utama serta indeks sekunder dan kueri kompleks. Contoh penyimpanan dokumen termasuk MongoDB dan CouchBase.
  3. Database grafik berfokus terutama pada hubungan antara objek di mana data disimpan dalam node dan dalam hubungan antar node. Contoh database grafik adalah Neo4j.
  4. Basis data berorientasi kolom menyimpan data sebagai bagian dari kolom data dan bukan sebagai baris data. HBase adalah database berorientasi kolom, dan begitu pula Cassandra.

HBase: Primer

Apache HBase adalah database NoSQL yang berjalan di atas Hadoop sebagai penyimpanan data besar yang terdistribusi dan dapat diskalakan. HBase adalah database berorientasi kolom yang memanfaatkan kemampuan pemrosesan terdistribusi dari Hadoop Distributed File System (HDFS) dan paradigma pemrograman MapReduce Hadoop. Itu dirancang untuk menampung tabel besar dengan miliaran baris dan berpotensi jutaan kolom, semuanya berjalan di sekelompok perangkat keras komoditas.

Apache HBase menggabungkan kekuatan dan skalabilitas Hadoop dengan kemampuan untuk meminta catatan individu dan menjalankan proses MapReduce.

Selain kemampuan yang diwarisi dari Hadoop, HBase adalah basis data yang kuat dalam dirinya sendiri: ia menggabungkan kueri waktu nyata dengan kecepatan penyimpanan kunci / nilai, strategi pemindaian tabel yang kuat untuk menemukan catatan dengan cepat, dan mendukung pemrosesan batch menggunakan MapReduce. Dengan demikian, Apache HBase menggabungkan kekuatan dan skalabilitas Hadoop dengan kemampuan untuk meminta catatan individu dan menjalankan proses MapReduce.

Model data HBase

HBase mengatur data secara berbeda dari database relasional tradisional, mendukung model data empat dimensi di mana setiap "sel" diwakili oleh empat koordinat:

  1. Kunci baris : Setiap baris memiliki kunci baris unik yang diwakili secara internal oleh larik byte, tetapi tidak memiliki tipe data formal.
  2. Keluarga kolom : Data yang terdapat dalam satu baris dipartisi menjadi keluarga kolom ; setiap baris memiliki kumpulan keluarga kolom yang sama, tetapi setiap keluarga kolom tidak perlu mempertahankan kumpulan kualifikasi kolom yang sama. Anda dapat menganggap keluarga kolom mirip dengan tabel dalam database relasional.
  3. Pengualifikasi kolom : Ini mirip dengan kolom dalam database relasional.
  4. Versi : Setiap kolom dapat memiliki jumlah versi yang dapat dikonfigurasi . Jika Anda meminta data yang terdapat dalam kolom tanpa menentukan versi, maka Anda menerima versi terbaru, tetapi Anda dapat meminta versi yang lebih lama dengan menentukan nomor versi.

Gambar 1 menunjukkan bagaimana koordinat empat dimensi ini terkait.

Steven Haines

Model pada Gambar 1 menunjukkan bahwa baris terdiri dari kunci baris dan sejumlah keluarga kolom. Setiap kunci baris dikaitkan dengan kumpulan "baris dalam tabel", yang masing-masing memiliki kolomnya sendiri. Meskipun setiap tabel harus ada, kolom dalam tabel mungkin berbeda antar baris. Setiap kelompok kolom memiliki sekumpulan kolom, dan setiap kolom memiliki sekumpulan versi yang memetakan ke data aktual di baris.

Jika kita menjadi model seseorang, kunci barisnya mungkin nomor jaminan sosial orang tersebut (untuk mengidentifikasinya secara unik), dan kita mungkin memiliki kolom keluarga seperti alamat, pekerjaan, pendidikan, dan sebagainya. Di dalam kelompok kolom alamat, kami mungkin memiliki kolom jalan, kota, negara bagian, dan kode pos, dan setiap versi mungkin sesuai dengan tempat tinggal orang tersebut pada waktu tertentu. Versi terbaru mungkin mencantumkan kota "Los Angeles", sedangkan versi sebelumnya mungkin mencantumkan "New York". Anda dapat melihat model contoh ini pada Gambar 2.

Steven Haines

Singkatnya, HBase adalah database berorientasi kolom yang mewakili data dalam model empat dimensi. Itu dibangun di atas Hadoop Distributed File System (HDFS), yang mempartisi data di ribuan mesin komoditas yang berpotensi. Pengembang yang menggunakan HBase dapat mengakses data secara langsung dengan mengakses kunci baris, dengan memindai berbagai kunci baris, atau dengan menggunakan pemrosesan batch melalui MapReduce.

Riset dasar

Anda mungkin atau mungkin tidak akrab dengan Buku Putih Data Besar yang terkenal (bagi para geek). Diterbitkan oleh Google Research antara 2003 dan 2006, kertas putih ini mempresentasikan penelitian untuk tiga pilar ekosistem Hadoop seperti yang kita kenal:

  • Google File System (GFS): Hadoop Distributed File System (HDFS) adalah implementasi open source dari GFS dan menentukan bagaimana data didistribusikan ke seluruh cluster mesin komoditas.
  • MapReduce: Paradigma pemrograman fungsional untuk menganalisis data yang didistribusikan di seluruh cluster HDFS.
  • Bigtable: Sistem penyimpanan terdistribusi untuk mengelola data terstruktur yang dirancang untuk diskalakan ke ukuran yang sangat besar - petabyte data di ribuan mesin komoditas. HBase adalah implementasi open source dari Bigtable.

Menjembatani kesenjangan NoSQL: Apache Phoenix

Apache Phoenix adalah proyek Apache tingkat atas yang menyediakan antarmuka SQL ke HBase, memetakan model HBase ke dunia database relasional. Tentu saja, HBase menyediakan API dan shellnya sendiri untuk menjalankan fungsi-fungsi seperti scan, get, put, list, dan sebagainya, tetapi lebih banyak pengembang yang terbiasa dengan SQL daripada NoSQL. Tujuan Phoenix adalah menyediakan antarmuka yang dipahami secara umum untuk HBase.

Dalam hal fitur, Phoenix melakukan hal berikut:

  • Menyediakan driver JDBC untuk berinteraksi dengan HBase.
  • Mendukung banyak standar ANSI SQL.
  • Mendukung operasi DDL seperti CREATE TABLE, DROP TABLE, dan ALTER TABLE.
  • Mendukung operasi DML seperti UPSERT dan DELETE.
  • Mengompilasi kueri SQL ke dalam pemindaian HBase asli dan kemudian memetakan respons ke JDBC ResultSets.
  • Mendukung skema berversi.

Selain mendukung serangkaian besar operasi SQL, Phoenix juga berkinerja sangat tinggi. Ini menganalisis kueri SQL, memecahnya menjadi beberapa pemindaian HBase, dan menjalankannya secara paralel, menggunakan API asli alih-alih proses MapReduce.

Phoenix menggunakan dua strategi - pemroses bersama dan filter khusus - untuk mendekatkan penghitungan dengan data:

  • Co-prosesor melakukan operasi di server, yang meminimalkan transfer data klien / server.
  • Filter ubahsuaian mengurangi jumlah data yang dikembalikan dalam respons kueri dari server, yang selanjutnya mengurangi jumlah data yang ditransfer. Filter ubahsuaian digunakan dalam beberapa cara:
    1. Saat menjalankan kueri, filter kustom dapat digunakan untuk mengidentifikasi hanya keluarga kolom penting yang diperlukan untuk memenuhi pencarian.
    2. Sebuah skip scan Filter menggunakan SEEK_NEXT_USING_HINT HBase untuk cepat menavigasi dari satu record ke yang berikutnya, yang mempercepat query titik.
    3. Filter kustom dapat "mengasinkan data", artinya filter tersebut menambahkan byte hash di awal kunci baris sehingga dapat dengan cepat menemukan record.

Singkatnya, Phoenix memanfaatkan akses langsung ke HBase API, ko-prosesor, dan filter khusus untuk memberi Anda kinerja tingkat milidetik untuk kumpulan data kecil dan kinerja tingkat kedua untuk kumpulan data yang sangat besar. Di atas segalanya, Phoenix memperlihatkan kemampuan ini kepada pengembang melalui antarmuka JDBC dan SQL yang sudah dikenal.

Mulailah dengan Phoenix

Untuk menggunakan Phoenix, Anda perlu mengunduh dan menginstal HBase dan Phoenix. Anda dapat menemukan halaman unduhan Phoenix (dan catatan kompatibilitas HBase) di sini.

Unduh dan siapkan

Pada saat penulisan ini, versi terbaru Phoenix adalah 4.6.0 dan halaman unduhan menyatakan bahwa 4.x kompatibel dengan HBase versi 0.98.1+. Sebagai contoh, saya mengunduh Phoenix versi terbaru yang dikonfigurasi untuk bekerja dengan HBase 1.1. Anda dapat menemukannya di folder: phoenix-4.6.0-HBase-1.1/.

Berikut pengaturannya:

  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) 

UPSERTadalah perintah SQL untuk memasukkan catatan jika tidak ada atau memperbarui catatan jika ada. Dalam hal ini, kami memasukkan (1, 'Hello') dan (2, 'World!'). Anda dapat menemukan referensi perintah Phoenix lengkap di sini. Terakhir, buat kueri tabel Anda untuk melihat nilai yang Anda tambahkan dengan menjalankan select * from test:

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

Seperti yang diharapkan, Anda akan melihat nilai yang baru saja Anda sisipkan. Jika Anda ingin membersihkan tabel, jalankan drop table testperintah.