ArangoDB - Panduan Cepat
ArangoDB dipuji sebagai database multi-model asli oleh pengembangnya. Ini tidak seperti database NoSQL lainnya. Dalam database ini, data dapat disimpan sebagai dokumen, key / value pair, atau grafik. Dan dengan satu bahasa kueri deklaratif, salah satu atau semua data Anda dapat diakses. Selain itu, model yang berbeda dapat digabungkan dalam satu kueri. Dan, karena gaya multi-modelnya, seseorang dapat membuat aplikasi ramping, yang dapat diskalakan secara horizontal dengan salah satu atau semua dari tiga model data.
Basis Data Multi-Model Berlapis vs. Asli
Di bagian ini, kami akan menyoroti perbedaan penting antara database multimodel asli dan berlapis.
Banyak vendor database menyebut produk mereka "multi-model", tetapi menambahkan lapisan grafik ke penyimpanan kunci / nilai atau dokumen tidak memenuhi syarat sebagai multi-model asli.
Dengan ArangoDB, inti yang sama dengan bahasa kueri yang sama, seseorang dapat menggabungkan model data dan fitur yang berbeda dalam satu kueri, seperti yang telah kami nyatakan di bagian sebelumnya. Di ArangoDB, tidak ada "peralihan" antara model data, dan tidak ada pergeseran data dari A ke B untuk menjalankan kueri. Ini mengarah pada keunggulan kinerja untuk ArangoDB dibandingkan dengan pendekatan "berlapis".
Kebutuhan Database Multimodal
Menginterpretasikan ide dasar [Fowler] menuntun kita untuk menyadari manfaat menggunakan berbagai model data yang sesuai untuk bagian berbeda dari lapisan persistensi, lapisan tersebut merupakan bagian dari arsitektur perangkat lunak yang lebih besar.
Menurut ini, seseorang mungkin, misalnya, menggunakan database relasional untuk mempertahankan data tabular yang terstruktur; penyimpanan dokumen untuk data tidak terstruktur, seperti objek; penyimpanan kunci / nilai untuk tabel hash; dan database grafik untuk data referensial yang sangat terkait.
Namun, implementasi tradisional dari pendekatan ini akan mengarahkan seseorang untuk menggunakan beberapa database dalam proyek yang sama. Ini dapat menyebabkan beberapa gesekan operasional (penerapan yang lebih rumit, peningkatan yang lebih sering) serta masalah konsistensi dan duplikasi data.
Tantangan berikutnya setelah menyatukan data untuk tiga model data, adalah merancang dan menerapkan bahasa kueri umum yang memungkinkan administrator data untuk mengekspresikan berbagai kueri, seperti kueri dokumen, pencarian kunci / nilai, kueri grafi, dan kombinasi arbitrer. ini.
Oleh graphy queries, yang kami maksud adalah kueri yang melibatkan pertimbangan teoretis grafik. Secara khusus, ini mungkin melibatkan fitur konektivitas tertentu yang berasal dari tepi. Sebagai contoh,ShortestPath, GraphTraversal, dan Neighbors.
Grafik sangat cocok sebagai model data untuk relasi. Dalam banyak kasus dunia nyata seperti jaringan sosial, sistem pemberi rekomendasi, dll., Model data yang sangat alami adalah grafik. Ini menangkap hubungan dan dapat menyimpan informasi label dengan setiap tepi dan dengan setiap simpul. Lebih lanjut, dokumen JSON sangat cocok untuk menyimpan jenis data simpul dan tepi ini.
ArangoDB ─ Fitur
Ada berbagai fitur penting dari ArangoDB. Kami akan menyoroti fitur-fitur utama di bawah -
- Paradigma Multi Model
- Properti ACID
- API HTTP
ArangoDB mendukung semua model database populer. Berikut adalah beberapa model yang didukung oleh ArangoDB -
- Model dokumen
- Model Kunci / Nilai
- Model grafik
Satu bahasa kueri cukup untuk mengambil data dari database
Empat sifat Atomicity, Consistency, Isolation, dan Durability(ACID) menjelaskan jaminan transaksi database. ArangoDB mendukung transaksi yang sesuai dengan ACID.
ArangoDB memungkinkan klien, seperti browser, untuk berinteraksi dengan database dengan HTTP API, API yang berorientasi pada sumber daya dan dapat diperpanjang dengan JavaScript.
Berikut adalah keuntungan menggunakan ArangoDB -
Konsolidasi
Sebagai database multi-model asli, ArangoDB menghilangkan kebutuhan untuk menyebarkan banyak database, dan dengan demikian mengurangi jumlah komponen dan pemeliharaannya. Akibatnya, ini mengurangi kompleksitas tumpukan teknologi untuk aplikasi. Selain mengkonsolidasikan kebutuhan teknis Anda secara keseluruhan, penyederhanaan ini menghasilkan total biaya kepemilikan yang lebih rendah dan meningkatkan fleksibilitas.
Penskalaan Performa yang Disederhanakan
Dengan aplikasi yang berkembang dari waktu ke waktu, ArangoDB dapat menangani kebutuhan kinerja dan penyimpanan yang terus meningkat, dengan penskalaan independen menggunakan model data yang berbeda. Karena ArangoDB dapat menskalakan secara vertikal dan horizontal, jadi jika kinerja Anda menuntut penurunan (perlambatan yang diinginkan dan disengaja), sistem back-end Anda dapat dengan mudah diperkecil untuk menghemat perangkat keras serta biaya operasional.
Mengurangi Kompleksitas Operasional
Keputusan Polyglot Persistence adalah menggunakan alat terbaik untuk setiap pekerjaan yang Anda lakukan. Tugas-tugas tertentu membutuhkan database dokumen, sementara yang lain mungkin memerlukan database grafik. Sebagai hasil dari bekerja dengan database model tunggal, ini dapat menyebabkan banyak tantangan operasional. Mengintegrasikan database model tunggal adalah pekerjaan yang sulit. Tetapi tantangan terbesar adalah membangun struktur kohesif yang besar dengan konsistensi data dan toleransi kesalahan antara sistem database yang terpisah dan tidak terkait. Ini mungkin terbukti hampir tidak mungkin.
Persistensi Polyglot dapat ditangani dengan database multi-model asli, karena memungkinkan untuk memiliki data poliglot dengan mudah, tetapi pada saat yang sama dengan konsistensi data pada sistem yang toleran terhadap kesalahan. Dengan ArangoDB, kita dapat menggunakan model data yang benar untuk pekerjaan yang kompleks.
Konsistensi Data yang Kuat
Jika seseorang menggunakan beberapa database model tunggal, konsistensi data dapat menjadi masalah. Basis data ini tidak dirancang untuk berkomunikasi satu sama lain, oleh karena itu beberapa bentuk fungsionalitas transaksi perlu diterapkan untuk menjaga data Anda tetap konsisten di antara model yang berbeda.
Mendukung transaksi ACID, ArangoDB mengelola berbagai model data Anda dengan satu back-end, memberikan konsistensi yang kuat pada satu instance, dan operasi atomik saat beroperasi dalam mode cluster.
Toleransi kesalahan
Merupakan tantangan untuk membangun sistem toleransi kesalahan dengan banyak komponen yang tidak terkait. Tantangan ini menjadi lebih kompleks saat bekerja dengan cluster. Keahlian diperlukan untuk menyebarkan dan memelihara sistem seperti itu, menggunakan teknologi yang berbeda dan / atau tumpukan teknologi. Selain itu, mengintegrasikan beberapa subsistem, yang dirancang untuk berjalan secara independen, menimbulkan biaya teknis dan operasional yang besar.
Sebagai tumpukan teknologi yang terkonsolidasi, database multi-model menyajikan solusi yang elegan. Dirancang untuk memungkinkan arsitektur modular modern dengan model data berbeda, ArangoDB juga berfungsi untuk penggunaan cluster.
Total Biaya Kepemilikan yang Lebih Rendah
Setiap teknologi database membutuhkan pemeliharaan berkelanjutan, perbaikan bug, dan perubahan kode lainnya yang disediakan oleh vendor. Menggunakan database multi-model secara signifikan mengurangi biaya pemeliharaan terkait hanya dengan menghilangkan jumlah teknologi database dalam mendesain aplikasi.
Transaksi
Memberikan jaminan transaksional di beberapa mesin merupakan tantangan nyata, dan beberapa database NoSQL memberikan jaminan ini. Menjadi multi-model asli, ArangoDB memberlakukan transaksi untuk menjamin konsistensi data.
Pada bab ini, kita akan membahas konsep dasar dan terminologi ArangoDB. Sangat penting untuk memiliki pengetahuan tentang terminologi dasar yang mendasari terkait dengan topik teknis yang kita hadapi.
Terminologi untuk ArangoDB tercantum di bawah ini -
- Document
- Collection
- Pengenal Koleksi
- Nama Koleksi
- Database
- Nama Database
- Organisasi Database
Dari perspektif model data, ArangoDB dapat dianggap sebagai database yang berorientasi pada dokumen, karena pengertian dokumen adalah ide matematis dari yang terakhir. Database berorientasi dokumen adalah salah satu kategori utama database NoSQL.
Hirarki berjalan seperti ini: Dokumen dikelompokkan ke dalam koleksi, dan Koleksi ada di dalam database
Jelas terlihat bahwa Identifier dan Name adalah dua atribut untuk collection dan database.
Biasanya, dua dokumen (simpul) yang disimpan dalam koleksi dokumen dihubungkan dengan dokumen (tepi) yang disimpan dalam koleksi tepi. Ini adalah model data grafik ArangoDB. Ini mengikuti konsep matematika dari grafik berarah dan berlabel, kecuali bahwa tepi tidak hanya memiliki label, tetapi juga dokumen yang lengkap.
Setelah terbiasa dengan istilah inti untuk database ini, kita mulai memahami model data grafik ArangoDB. Dalam model ini terdapat dua jenis koleksi: koleksi dokumen dan koleksi tepi. Koleksi tepi menyimpan dokumen dan juga menyertakan dua atribut khusus: pertama adalah_from atribut, dan yang kedua adalah _toatribut. Atribut ini digunakan untuk membuat edge (relasi) antar dokumen penting untuk database graph. Koleksi dokumen juga disebut koleksi simpul dalam konteks grafik (lihat buku teori grafik).
Sekarang mari kita lihat betapa pentingnya database. Mereka penting karena koleksi ada di dalam database. Dalam satu contoh ArangoDB, mungkin ada satu atau banyak database. Basis data yang berbeda biasanya digunakan untuk penyiapan multi-penyewa, karena kumpulan data yang berbeda di dalamnya (koleksi, dokumen, dll.) Diisolasi satu sama lain. Basis data default_systemspesial, karena tidak bisa dilepas. Pengguna dikelola dalam database ini, dan kredensial mereka valid untuk semua database instance server.
Dalam bab ini, kita akan membahas persyaratan sistem untuk ArangoDB.
Persyaratan sistem untuk ArangoDB adalah sebagai berikut -
- Server VPS dengan Instalasi Ubuntu
- RAM: 1 GB; CPU: 2,2 GHz
Untuk semua perintah dalam tutorial ini, kami telah menggunakan instance Ubuntu 16.04 (xenial) dari RAM 1GB dengan satu cpu yang memiliki kekuatan pemrosesan 2,2 GHz. Dan semua perintah arangosh dalam tutorial ini telah diuji untuk ArangoDB versi 3.1.27.
Bagaimana cara menginstal ArangoDB?
Di bagian ini, kita akan melihat cara menginstal ArangoDB. ArangoDB sudah dibuat sebelumnya untuk banyak sistem operasi dan distribusi. Untuk lebih jelasnya, silakan merujuk ke dokumentasi ArangoDB. Seperti yang sudah disebutkan, untuk tutorial ini kita akan menggunakan Ubuntu 16.04x64.
Langkah pertama adalah mengunduh kunci publik untuk repositori -
# wget https://www.arangodb.com/repositories/arangodb31/
xUbuntu_16.04/Release.keyKeluaran
--2017-09-03 12:13:24-- https://www.arangodb.com/repositories/arangodb31/xUbuntu_16.04/Release.key
Resolving https://www.arangodb.com/
(www.arangodb.com)... 104.25.1 64.21, 104.25.165.21,
2400:cb00:2048:1::6819:a415, ...
Connecting to https://www.arangodb.com/
(www.arangodb.com)|104.25. 164.21|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 3924 (3.8K) [application/pgpkeys]
Saving to: ‘Release.key’
Release.key 100%[===================>] 3.83K - .-KB/s in 0.001s
2017-09-03 12:13:25 (2.61 MB/s) - ‘Release.key’ saved [39 24/3924]Poin pentingnya adalah Anda harus melihat file Release.key disimpan di akhir keluaran.
Mari kita instal kunci yang disimpan menggunakan baris kode berikut -
# sudo apt-key add Release.keyKeluaran
OKJalankan perintah berikut untuk menambahkan repositori apt dan memperbarui indeks -
# sudo apt-add-repository 'deb
https://www.arangodb.com/repositories/arangodb31/xUbuntu_16.04/ /'
# sudo apt-get updateSebagai langkah terakhir, kita dapat menginstal ArangoDB -
# sudo apt-get install arangodb3Keluaran
Reading package lists... Done
Building dependency tree
Reading state information... Done
The following package was automatically installed and is no longer required:
grub-pc-bin
Use 'sudo apt autoremove' to remove it.
The following NEW packages will be installed:
arangodb3
0 upgraded, 1 newly installed, 0 to remove and 17 not upgraded.
Need to get 55.6 MB of archives.
After this operation, 343 MB of additional disk space will be used.tekan Enter. Sekarang proses instalasi ArangoDB akan dimulai -
Get:1 https://www.arangodb.com/repositories/arangodb31/xUbuntu_16.04
arangodb3 3.1.27 [55.6 MB]
Fetched 55.6 MB in 59s (942 kB/s)
Preconfiguring packages ...
Selecting previously unselected package arangodb3.
(Reading database ... 54209 files and directories currently installed.)
Preparing to unpack .../arangodb3_3.1.27_amd64.deb ...
Unpacking arangodb3 (3.1.27) ...
Processing triggers for systemd (229-4ubuntu19) ...
Processing triggers for ureadahead (0.100.0-19) ...
Processing triggers for man-db (2.7.5-1) ...
Setting up arangodb3 (3.1.27) ...
Database files are up-to-date.Ketika penginstalan ArangoDB akan selesai, layar berikut akan muncul -
Di sini, Anda akan diminta untuk memberikan kata sandi untuk ArangoDB rootpengguna. Catat dengan cermat.
Pilih yes pilihan ketika kotak dialog berikut muncul -
Saat Anda mengklik Yesseperti pada kotak dialog di atas, kotak dialog berikut akan muncul. KlikYes sini.
Anda juga dapat memeriksa status ArangoDB dengan perintah berikut -
# sudo systemctl status arangodb3Keluaran
arangodb3.service - LSB: arangodb
Loaded: loaded (/etc/init.d/arangodb3; bad; vendor pre set: enabled)
Active: active (running) since Mon 2017-09-04 05:42:35 UTC;
4min 46s ago
Docs: man:systemd-sysv-generator(8)
Process: 2642 ExecStart=/etc/init.d/arangodb3 start (code = exited,
status = 0/SUC
Tasks: 22
Memory: 158.6M
CPU: 3.117s
CGroup: /system.slice/arangodb3.service
├─2689 /usr/sbin/arangod --uid arangodb
--gid arangodb --pid-file /va
└─2690 /usr/sbin/arangod --uid arangodb
--gid arangodb --pid-file /va
Sep 04 05:42:33 ubuntu-512 systemd[1]: Starting LSB: arangodb...
Sep 04 05:42:33 ubuntu-512 arangodb3[2642]: * Starting arango database server a
Sep 04 05:42:35 ubuntu-512 arangodb3[2642]: {startup} starting up in daemon mode
Sep 04 05:42:35 ubuntu-512 arangodb3[2642]: changed working directory for child
Sep 04 05:42:35 ubuntu-512 arangodb3[2642]: ...done.
Sep 04 05:42:35 ubuntu-512 systemd[1]: StartedLSB: arang odb.
Sep 04 05:46:59 ubuntu-512 systemd[1]: Started LSB: arangodb. lines 1-19/19 (END)ArangoDB sekarang siap digunakan.
Untuk memanggil terminal arangosh, ketik perintah berikut di terminal -
# arangoshKeluaran
Please specify a password:Pasokan root kata sandi dibuat pada saat instalasi -
_
__ _ _ __ __ _ _ __ __ _ ___ | |
/ | '__/ _ | ’ \ / ` |/ _ / | ’
| (| | | | (| | | | | (| | () _ \ | | |
_,|| _,|| ||_, |_/|/| ||
|__/arangosh (ArangoDB 3.1.27 [linux] 64bit, using VPack 0.1.30, ICU 54.1, V8
5.0.71.39, OpenSSL 1.0.2g 1 Mar 2016)
Copyright (c) ArangoDB GmbH
Pretty printing values.
Connected to ArangoDB 'http+tcp://127.0.0.1:8529' version: 3.1.27 [server],
database: '_system', username: 'root'
Please note that a new minor version '3.2.2' is available
Type 'tutorial' for a tutorial or 'help' to see common examples
127.0.0.1:8529@_system> exit
Untuk keluar dari ArangoDB, ketik perintah berikut -
127.0.0.1:8529@_system> exitKeluaran
Uf wiederluege! Na shledanou! Auf Wiedersehen! Bye Bye! Adiau! ¡Hasta luego!
Εις το επανιδείν!
להתראות ! Arrivederci! Tot ziens! Adjö! Au revoir! さようなら До свидания! Até
Breve! !خداحافظPada bab ini, kita akan membahas bagaimana Arangosh bekerja sebagai Command Line untuk ArangoDB. Kita akan mulai dengan mempelajari cara menambahkan pengguna Database.
Note - Ingat keypad numerik mungkin tidak berfungsi di Arangosh.
Mari kita asumsikan bahwa pengguna tersebut "harry" dan kata sandinya adalah "hpwdb".
127.0.0.1:8529@_system> require("org/arangodb/users").save("harry", "hpwdb");Keluaran
{
"user" : "harry",
"active" : true,
"extra" : {},
"changePassword" : false,
"code" : 201
}Dalam bab ini, kita akan mempelajari cara mengaktifkan / menonaktifkan Otentikasi, dan cara mengikat ArangoDB ke Antarmuka Jaringan Publik.
# arangosh --server.endpoint tcp://127.0.0.1:8529 --server.database "_system"Ini akan meminta Anda untuk kata sandi yang disimpan sebelumnya -
Please specify a password:Gunakan kata sandi yang Anda buat untuk root, di konfigurasi.
Anda juga dapat menggunakan curl untuk memeriksa apakah Anda benar-benar mendapatkan respons server HTTP 401 (Tidak Sah) untuk permintaan yang memerlukan otentikasi -
# curl --dump - http://127.0.0.1:8529/_api/versionKeluaran
HTTP/1.1 401 Unauthorized
X-Content-Type-Options: nosniff
Www-Authenticate: Bearer token_type = "JWT", realm = "ArangoDB"
Server: ArangoDB
Connection: Keep-Alive
Content-Type: text/plain; charset = utf-8
Content-Length: 0Untuk menghindari memasukkan kata sandi setiap kali selama proses pembelajaran kami, kami akan menonaktifkan otentikasi. Untuk itu, buka file konfigurasi -
# vim /etc/arangodb3/arangod.confAnda harus mengubah skema warna jika kode tidak terlihat dengan benar.
:colorscheme desertSetel otentikasi ke false seperti yang ditunjukkan pada gambar di bawah.
Mulai ulang layanan -
# service arangodb3 restartSaat membuat otentikasi salah, Anda akan dapat masuk (baik dengan root atau pengguna yang dibuat seperti Harry dalam kasus ini) tanpa memasukkan kata sandi apa pun please specify a password.
Mari kita periksa api versi ketika otentikasi dimatikan -
# curl --dump - http://127.0.0.1:8529/_api/versionKeluaran
HTTP/1.1 200 OK
X-Content-Type-Options: nosniff
Server: ArangoDB
Connection: Keep-Alive
Content-Type: application/json; charset=utf-8
Content-Length: 60
{"server":"arango","version":"3.1.27","license":"community"}Dalam bab ini, kita akan membahas dua contoh skenario. Contoh-contoh ini lebih mudah dipahami dan akan membantu kami memahami cara kerja fungsionalitas ArangoDB.
Untuk mendemonstrasikan API, ArangoDB sudah dimuat sebelumnya dengan serangkaian grafik yang mudah dimengerti. Ada dua metode untuk membuat contoh grafik ini di ArangoDB Anda -
- Tambahkan tab Contoh di jendela buat grafik di antarmuka web,
- atau memuat modul @arangodb/graph-examples/example-graph di Arangosh.
Untuk memulai, mari kita muat grafik dengan bantuan antarmuka web. Untuk itu, luncurkan antarmuka web dan klikgraphs tab.
Itu Create Graphkotak dialog muncul. Wizard berisi dua tab -Examples dan Graph. ItuGraphtab terbuka secara default; misalkan kita ingin membuat grafik baru, maka akan ditanyakan nama dan definisi lain untuk grafik tersebut.
Sekarang, kita akan mengunggah grafik yang sudah dibuat. Untuk ini, kami akan memilihExamples tab.
Kita bisa melihat tiga contoh grafik. PilihKnows_Graph dan klik tombol hijau Buat.
Setelah Anda membuatnya, Anda dapat memeriksanya di antarmuka web - yang digunakan untuk membuat gambar di bawah ini.
Knows_Graph
Sekarang mari kita lihat bagaimana Knows_Graphbekerja. Pilih Knows_Graph, dan itu akan mengambil data grafik.
Knows_Graph terdiri dari satu kumpulan titik persons terhubung melalui satu koleksi tepi knows. Ini akan berisi lima orang Alice, Bob, Charlie, Dave dan Eve sebagai simpul. Kami akan memiliki hubungan terarah berikut
Alice knows Bob
Bob knows Charlie
Bob knows Dave
Eve knows Alice
Eve knows Bob
Jika Anda mengklik sebuah node (vertex), katakan 'bob', itu akan menampilkan nama atribut ID (orang / bob).
Dan saat mengklik salah satu tepi, itu akan menunjukkan atribut ID (know / 4590).
Beginilah cara kami membuatnya, memeriksa simpul dan tepinya.
Mari kita tambahkan grafik lain, kali ini menggunakan Arangosh. Untuk itu, kita perlu memasukkan titik akhir lain di file konfigurasi ArangoDB.
Cara Menambahkan Beberapa Titik Akhir
Buka file konfigurasi -
# vim /etc/arangodb3/arangod.confTambahkan titik akhir lain seperti yang ditunjukkan pada tangkapan layar terminal di bawah.
Mulai ulang ArangoDB -
# service arangodb3 restartLuncurkan Arangosh -
# arangosh
Please specify a password:
_
__ _ _ __ __ _ _ __ __ _ ___ ___| |__
/ _` | '__/ _` | '_ \ / _` |/ _ \/ __| '_ \
| (_| | | | (_| | | | | (_| | (_) \__ \ | | |
\__,_|_| \__,_|_| |_|\__, |\___/|___/_| |_|
|___/
arangosh (ArangoDB 3.1.27 [linux] 64bit, using VPack 0.1.30, ICU 54.1, V8
5.0.71.39, OpenSSL 1.0.2g 1 Mar 2016)
Copyright (c) ArangoDB GmbH
Pretty printing values.
Connected to ArangoDB 'http+tcp://127.0.0.1:8529' version: 3.1.27
[server], database: '_system', username: 'root'
Please note that a new minor version '3.2.2' is available
Type 'tutorial' for a tutorial or 'help' to see common examples
127.0.0.1:8529@_system>The Social_Graph
Sekarang mari kita memahami apa itu Social_Graph dan cara kerjanya. Grafik menunjukkan sekumpulan orang dan hubungannya -
Contoh ini memiliki orang perempuan dan laki-laki sebagai simpul dalam dua kumpulan simpul - perempuan dan laki-laki. Tepi adalah koneksi mereka dalam kumpulan tepi relasi. Kami telah menjelaskan cara membuat grafik ini menggunakan Arangosh. Pembaca dapat menyiasatinya dan menjelajahi atributnya, seperti yang kita lakukan dengan Knows_Graph.
Dalam bab ini, kami akan fokus pada topik berikut -
- Interaksi Database
- Model data
- Penerimaan data
ArangoDB mendukung model data berbasis dokumen serta model data berbasis grafik. Mari kita gambarkan model data berbasis dokumen.
Dokumen ArangoDB sangat mirip dengan format JSON. Nol atau lebih atribut terkandung dalam dokumen, dan nilai yang dilampirkan dengan setiap atribut. Nilai adalah salah satu dari tipe atom, seperti angka, Boolean atau null, string literal, atau tipe data gabungan, seperti dokumen / objek yang disematkan atau array. Array atau sub-objek dapat terdiri dari tipe data ini, yang menyiratkan bahwa satu dokumen dapat mewakili struktur data non-trivial.
Lebih jauh dalam hierarki, dokumen disusun menjadi koleksi, yang mungkin tidak berisi dokumen (dalam teori) atau lebih dari satu dokumen. Seseorang dapat membandingkan dokumen ke baris dan koleksi ke tabel (Di sini tabel dan baris mengacu pada sistem manajemen basis data relasional - RDBMS).
Namun, dalam RDBMS, menentukan kolom merupakan prasyarat untuk menyimpan rekaman ke dalam tabel, memanggil skema definisi ini. Namun, sebagai fitur baru, ArangoDB tidak memiliki skema - tidak ada alasan apriori untuk menentukan atribut apa yang akan dimiliki dokumen tersebut.
Dan tidak seperti RDBMS, setiap dokumen dapat disusun dengan cara yang sangat berbeda dari dokumen lain. Dokumen-dokumen ini dapat disimpan bersama dalam satu koleksi. Secara praktis, karakteristik umum mungkin ada di antara dokumen dalam koleksi, namun sistem database, yaitu ArangoDB itu sendiri, tidak mengikat Anda ke struktur data tertentu.
Sekarang kita akan mencoba untuk memahami ArangoDB's [graph data model], yang membutuhkan dua jenis koleksi - yang pertama adalah koleksi dokumen (dikenal sebagai koleksi simpul dalam bahasa teori-kelompok), yang kedua adalah koleksi tepi. Ada perbedaan halus antara kedua jenis ini. Koleksi tepi juga menyimpan dokumen, tetapi mereka dicirikan dengan memasukkan dua atribut unik,_from dan _tountuk membuat hubungan antar dokumen. Dalam prakteknya, sebuah dokumen (tepi baca) menghubungkan dua dokumen (simpul baca), keduanya disimpan dalam koleksinya masing-masing. Arsitektur ini diturunkan dari konsep teori-grafik dari grafik berarah yang berlabel, tidak termasuk edge yang tidak hanya memiliki label, tetapi juga bisa menjadi dokumen JSON yang lengkap.
Untuk menghitung data baru, menghapus dokumen atau memanipulasinya, kueri digunakan, yang memilih atau memfilter dokumen sesuai kriteria yang diberikan. Entah sesederhana "kueri contoh" atau serumit "gabungan", kueri dikodekan dalam AQL - Bahasa Kueri ArangoDB.
Pada bab ini, kita akan membahas berbagai Metode Database di ArangoDB.
Untuk memulai, mari kita dapatkan properti dari Database -
- Name
- ID
- Path
Pertama, kami memanggil Arangosh. Setelah Arangosh dipanggil, kami akan membuat daftar database yang kami buat sejauh ini -
Kami akan menggunakan baris kode berikut untuk memanggil Arangosh -
127.0.0.1:8529@_system> db._databases()Keluaran
[
"_system",
"song_collection"
]Kami melihat dua database, satu _system dibuat secara default, dan yang kedua song_collection yang kami buat.
Sekarang mari kita beralih ke database song_collection dengan baris kode berikut -
127.0.0.1:8529@_system> db._useDatabase("song_collection")Keluaran
true
127.0.0.1:8529@song_collection>Kami akan menjelajahi properti database song_collection kami.
Untuk menemukan namanya
Kami akan menggunakan baris kode berikut untuk menemukan nama.
127.0.0.1:8529@song_collection> db._name()Keluaran
song_collectionUntuk menemukan id -
Kami akan menggunakan baris kode berikut untuk menemukan id.
song_collectionKeluaran
4838Untuk menemukan jalan -
Kami akan menggunakan baris kode berikut untuk menemukan jalurnya.
127.0.0.1:8529@song_collection> db._path()Keluaran
/var/lib/arangodb3/databases/database-4838Sekarang mari kita periksa apakah kita berada dalam database sistem atau tidak dengan menggunakan baris kode berikut -
127.0.0.1:8529@song_collection&t; db._isSystem()Keluaran
falseArtinya kita tidak berada di database sistem (seperti yang telah kita buat dan bergeser ke song_collection). Tangkapan layar berikut akan membantu Anda memahami ini.
Untuk mendapatkan koleksi tertentu, ucapkan lagu -
Kami akan menggunakan baris kode berikut untuk mendapatkan koleksi tertentu.
127.0.0.1:8529@song_collection> db._collection("songs")Keluaran
[ArangoCollection 4890, "songs" (type document, status loaded)]Baris kode mengembalikan satu koleksi.
Mari kita beralih ke esensi operasi database dengan bab-bab berikutnya.
Dalam bab ini, kita akan mempelajari berbagai operasi dengan Arangosh.
Berikut ini adalah kemungkinan operasi dengan Arangosh -
- Membuat Koleksi Dokumen
- Membuat Dokumen
- Membaca Dokumen
- Memperbarui Dokumen
Mari kita mulai dengan membuat database baru. Kami akan menggunakan baris kode berikut untuk membuat database baru -
127.0.0.1:8529@_system> db._createDatabase("song_collection")
trueBaris kode berikut akan membantu Anda beralih ke database baru -
127.0.0.1:8529@_system> db._useDatabase("song_collection")
truePerintah akan bergeser ke "@@ song_collection"
127.0.0.1:8529@song_collection>
Dari sini kita akan mempelajari Operasi CRUD. Mari kita buat koleksi ke dalam database baru -
127.0.0.1:8529@song_collection> db._createDocumentCollection('songs')Keluaran
[ArangoCollection 4890, "songs" (type document, status loaded)]
127.0.0.1:8529@song_collection>Mari kita tambahkan beberapa dokumen (objek JSON) ke koleksi 'lagu' kita.
Kami menambahkan dokumen pertama dengan cara berikut -
127.0.0.1:8529@song_collection> db.songs.save({title: "A Man's Best Friend",
lyricist: "Johnny Mercer", composer: "Johnny Mercer", Year: 1950, _key:
"A_Man"})Keluaran
{
"_id" : "songs/A_Man",
"_key" : "A_Man",
"_rev" : "_VjVClbW---"
}Mari kita tambahkan dokumen lain ke database. Ini akan membantu kami mempelajari proses kueri data. Anda dapat menyalin kode-kode ini dan menempelkannya di Arangosh untuk meniru prosesnya -
127.0.0.1:8529@song_collection> db.songs.save(
{
title: "Accentchuate The Politics",
lyricist: "Johnny Mercer",
composer: "Harold Arlen", Year: 1944,
_key: "Accentchuate_The"
}
)
{
"_id" : "songs/Accentchuate_The",
"_key" : "Accentchuate_The",
"_rev" : "_VjVDnzO---"
}
127.0.0.1:8529@song_collection> db.songs.save(
{
title: "Affable Balding Me",
lyricist: "Johnny Mercer",
composer: "Robert Emmett Dolan",
Year: 1950,
_key: "Affable_Balding"
}
)
{
"_id" : "songs/Affable_Balding",
"_key" : "Affable_Balding",
"_rev" : "_VjVEFMm---"
}Bagaimana Membaca Dokumen
Itu _keyatau pegangan dokumen dapat digunakan untuk mengambil dokumen. Gunakan pegangan dokumen jika tidak perlu melintasi koleksi itu sendiri. Jika Anda memiliki koleksi, fungsi dokumen mudah digunakan -
127.0.0.1:8529@song_collection> db.songs.document("A_Man");
{
"_key" : "A_Man",
"_id" : "songs/A_Man",
"_rev" : "_VjVClbW---",
"title" : "A Man's Best Friend",
"lyricist" : "Johnny Mercer",
"composer" : "Johnny Mercer",
"Year" : 1950
}Cara Memperbarui Dokumen
Tersedia dua opsi untuk memperbarui data yang disimpan - replace dan update.
Fungsi update menambal dokumen, menggabungkannya dengan atribut yang diberikan. Di sisi lain, fungsi replace akan menggantikan dokumen sebelumnya dengan yang baru. Penggantian akan tetap terjadi meskipun atribut yang sama sekali berbeda disediakan. Pertama-tama kita akan mengamati pembaruan non-destruktif, memperbarui atribut Production` dalam sebuah lagu -
127.0.0.1:8529@song_collection> db.songs.update("songs/A_Man",{production:
"Top Banana"});Keluaran
{
"_id" : "songs/A_Man",
"_key" : "A_Man",
"_rev" : "_VjVOcqe---",
"_oldRev" : "_VjVClbW---"
}Mari kita sekarang membaca atribut lagu yang diperbarui -
127.0.0.1:8529@song_collection> db.songs.document('A_Man');Keluaran
{
"_key" : "A_Man",
"_id" : "songs/A_Man",
"_rev" : "_VjVOcqe---",
"title" : "A Man's Best Friend",
"lyricist" : "Johnny Mercer",
"composer" : "Johnny Mercer",
"Year" : 1950,
"production" : "Top Banana"
}Dokumen besar dapat dengan mudah diperbarui dengan update berfungsi, terutama bila atributnya sangat sedikit.
Sebaliknya, file replace fungsi akan menghapus data Anda saat menggunakannya dengan dokumen yang sama.
127.0.0.1:8529@song_collection> db.songs.replace("songs/A_Man",{production:
"Top Banana"});Sekarang mari kita periksa lagu yang baru saja kita perbarui dengan baris kode berikut -
127.0.0.1:8529@song_collection> db.songs.document('A_Man');Keluaran
{
"_key" : "A_Man",
"_id" : "songs/A_Man",
"_rev" : "_VjVRhOq---",
"production" : "Top Banana"
}Sekarang, Anda dapat mengamati bahwa dokumen tersebut tidak lagi memiliki data asli.
Cara Menghapus Dokumen
Fungsi hapus digunakan dalam kombinasi dengan pegangan dokumen untuk menghapus dokumen dari koleksi -
127.0.0.1:8529@song_collection> db.songs.remove('A_Man');Sekarang mari kita periksa atribut lagu yang baru saja kita hapus dengan menggunakan baris kode berikut -
127.0.0.1:8529@song_collection> db.songs.document('A_Man');Kami akan mendapatkan kesalahan pengecualian seperti berikut sebagai output -
JavaScript exception in file
'/usr/share/arangodb3/js/client/modules/@arangodb/arangosh.js' at 97,7:
ArangoError 1202: document not found
! throw error;
! ^
stacktrace: ArangoError: document not found
at Object.exports.checkRequestResult
(/usr/share/arangodb3/js/client/modules/@arangodb/arangosh.js:95:21)
at ArangoCollection.document
(/usr/share/arangodb3/js/client/modules/@arangodb/arango-collection.js:667:12)
at <shell command>:1:10
Di bab sebelumnya, kita belajar bagaimana melakukan berbagai operasi pada dokumen dengan Arangosh, baris perintah. Sekarang kita akan belajar bagaimana melakukan operasi yang sama menggunakan antarmuka web. Untuk memulainya, masukkan alamat berikut - http: // your_server_ip: 8529 / _db / song_collection / _admin / aardvark / index.html # login di bilah alamat browser Anda. Anda akan diarahkan ke halaman login berikut.
Sekarang, masukkan nama pengguna dan kata sandi.
Jika berhasil, layar berikut akan muncul. Kita perlu membuat pilihan untuk database untuk dikerjakan, yaitu_systemdatabase menjadi yang default. Mari kita pilihsong_collection database, dan klik pada tab hijau -
Membuat Koleksi
Pada bagian ini, kita akan belajar bagaimana membuat sebuah koleksi. Tekan tab Koleksi di bilah navigasi di bagian atas.
Baris perintah kami menambahkan koleksi lagu terlihat. Mengklik itu akan menampilkan entri. Kami sekarang akan menambahkanartists’koleksi menggunakan antarmuka web. Koleksisongsyang kami buat dengan Arangosh sudah ada di sana. Di kolom Name, tulisartists dalam New Collectionkotak dialog yang muncul. Opsi lanjutan dapat dengan aman diabaikan dan jenis koleksi default, yaitu Dokumen, baik-baik saja.
Mengklik tombol Simpan akhirnya akan membuat koleksi, dan sekarang kedua koleksi akan terlihat di halaman ini.
Mengisi Koleksi yang Baru Dibuat dengan Dokumen
Anda akan disajikan dengan koleksi kosong saat mengklik artists koleksi -
Untuk menambahkan dokumen, Anda perlu mengklik tanda + yang ditempatkan di sudut kanan atas. Saat Anda diminta untuk file_key, masuk Affable_Balding sebagai kuncinya.
Sekarang, sebuah form akan muncul untuk menambah dan mengedit atribut dokumen tersebut. Ada dua cara untuk menambahkan atribut:Graphical dan Tree. Cara grafisnya intuitif tetapi lambat, oleh karena itu, kami akan beralih keCode lihat, menggunakan menu tarik-turun Pohon untuk memilihnya -
Untuk mempermudah prosesnya, kami telah membuat contoh data dalam format JSON, yang dapat Anda salin lalu tempelkan ke area editor kueri -
{"artist": "Johnny Mercer", "title": "Affable Balding Me", "composer": "Robert Emmett Dolan", "Year": 1950}
(Catatan: Hanya sepasang kurung kurawal harus digunakan; lihat gambar di bawah)
Anda dapat mengamati bahwa kami telah mengutip kunci dan juga nilai-nilai dalam mode tampilan kode. Sekarang, klikSave. Setelah berhasil diselesaikan, kilatan hijau muncul di halaman sebentar.
Bagaimana Membaca Dokumen
Untuk membaca dokumen, kembali ke halaman Koleksi.
Ketika seseorang mengklik file artist koleksi, entri baru muncul.
Cara Memperbarui Dokumen
Sangat mudah untuk mengedit entri dalam dokumen; Anda hanya perlu mengklik baris yang ingin Anda edit di ikhtisar dokumen. Di sini sekali lagi editor kueri yang sama akan disajikan seperti saat membuat dokumen baru.
Menghapus Dokumen
Anda dapat menghapus dokumen dengan menekan ikon '-'. Setiap baris dokumen memiliki tanda ini di bagian akhir. Ini akan meminta Anda untuk mengonfirmasi untuk menghindari penghapusan yang tidak aman.
Selain itu, untuk koleksi tertentu, operasi lain seperti memfilter dokumen, mengelola indeks, dan mengimpor data juga ada di Collections Overview halaman.
Pada bab selanjutnya, kita akan membahas fitur penting dari Antarmuka Web, yaitu Editor kueri AQL.
Pada bab ini, kita akan membahas bagaimana melakukan query data dengan AQL. Kita telah membahas di bab-bab sebelumnya bahwa ArangoDB telah mengembangkan bahasa kuerinya sendiri dan menggunakan nama AQL.
Mari kita mulai berinteraksi dengan AQL. Seperti yang ditunjukkan pada gambar di bawah ini, di antarmuka web, tekanAQL Editortab ditempatkan di bagian atas bilah navigasi. Editor kueri kosong akan muncul.
Bila perlu, Anda dapat beralih ke editor dari tampilan hasil dan sebaliknya, dengan mengklik tab Kueri atau Hasil di sudut kanan atas seperti yang ditunjukkan pada gambar di bawah -
Antara lain, editor memiliki penyorotan sintaks, fungsi undo / redo, dan penyimpanan kueri. Untuk referensi detailnya, bisa dilihat di dokumentasi resminya. Kami akan menyoroti beberapa fitur dasar dan umum digunakan dari editor kueri AQL.
Dasar-dasar AQL
Di AQL, kueri mewakili hasil akhir yang ingin dicapai, tetapi bukan proses untuk mencapai hasil akhir. Fitur ini umumnya dikenal sebagai properti deklaratif bahasa. Selain itu, AQL dapat melakukan kueri serta memodifikasi data, dan dengan demikian kueri kompleks dapat dibuat dengan menggabungkan kedua proses tersebut.
Harap dicatat bahwa AQL sepenuhnya sesuai dengan ACID. Membaca atau mengubah kueri akan berakhir seluruhnya atau tidak sama sekali. Bahkan membaca data dokumen akan selesai dengan unit data yang konsisten.
Kami menambahkan dua yang baru songsuntuk koleksi lagu yang telah kami buat. Alih-alih mengetik, Anda dapat menyalin kueri berikut, dan menempelkannya di editor AQL -
FOR song IN [
{
title: "Air-Minded Executive", lyricist: "Johnny Mercer",
composer: "Bernie Hanighen", Year: 1940, _key: "Air-Minded"
},
{
title: "All Mucked Up", lyricist: "Johnny Mercer", composer:
"Andre Previn", Year: 1974, _key: "All_Mucked"
}
]
INSERT song IN songsTekan tombol Execute di kiri bawah.
Ini akan menulis dua dokumen baru di songs koleksi.
Query ini menjelaskan bagaimana loop FOR bekerja di AQL; itu mengulangi daftar dokumen yang dikodekan JSON, melakukan operasi berkode pada masing-masing dokumen dalam koleksi. Operasi yang berbeda dapat membuat struktur baru, memfilter, memilih dokumen, memodifikasi, atau menyisipkan dokumen ke dalam database (lihat contoh instan). Intinya, AQL dapat melakukan operasi CRUD secara efisien.
Untuk menemukan semua lagu dalam database kita, mari kita sekali lagi menjalankan query berikut, setara dengan a SELECT * FROM songs dari database tipe SQL (karena editor mengingat kueri terakhir, tekan *New* tombol untuk membersihkan editor) -
FOR song IN songs
RETURN songKumpulan hasil akan menampilkan daftar lagu yang sejauh ini disimpan di songs koleksi seperti yang ditunjukkan pada gambar di bawah.
Operasi seperti FILTER, SORT dan LIMIT dapat ditambahkan ke For loop tubuh untuk mempersempit dan mengurutkan hasilnya.
FOR song IN songs
FILTER song.Year > 1940
RETURN songPermintaan di atas akan memberikan lagu yang dibuat setelah tahun 1940 di tab Hasil (lihat gambar di bawah).
Kunci dokumen digunakan dalam contoh ini, tetapi atribut lainnya juga dapat digunakan sebagai padanan untuk pemfilteran. Karena kunci dokumen dijamin unik, tidak lebih dari satu dokumen yang cocok dengan filter ini. Untuk atribut lain mungkin tidak demikian. Untuk mengembalikan subset pengguna aktif (ditentukan oleh atribut yang disebut status), diurutkan berdasarkan nama dalam urutan menaik, kami menggunakan sintaks berikut -
FOR song IN songs
FILTER song.Year > 1940
SORT song.composer
RETURN song
LIMIT 2Kami sengaja memasukkan contoh ini. Di sini, kami mengamati pesan kesalahan sintaks kueri yang disorot dengan warna merah oleh AQL. Sintaks ini menyoroti kesalahan dan membantu dalam men-debug kueri Anda seperti yang ditunjukkan pada gambar di bawah.
Mari kita sekarang menjalankan kueri yang benar (perhatikan koreksi) -
FOR song IN songs
FILTER song.Year > 1940
SORT song.composer
LIMIT 2
RETURN song
Query Kompleks di AQL
AQL dilengkapi dengan banyak fungsi untuk semua tipe data yang didukung. Penugasan variabel dalam kueri memungkinkan untuk membangun konstruksi bersarang yang sangat kompleks. Dengan cara ini, operasi intensif data bergerak lebih dekat ke data di backend daripada ke klien (seperti browser). Untuk memahami hal ini, pertama-tama mari kita tambahkan durasi (durasi) yang berubah-ubah pada lagu.
Mari kita mulai dengan fungsi pertama, yaitu fungsi Perbarui -
UPDATE { _key: "All_Mucked" }
WITH { length: 180 }
IN songs
Kita dapat melihat satu dokumen telah ditulis seperti yang ditunjukkan pada gambar di atas.
Mari kita perbarui dokumen lain (lagu) juga.
UPDATE { _key: "Affable_Balding" }
WITH { length: 200 }
IN songsKami sekarang dapat memeriksa apakah semua lagu kami memiliki atribut baru length -
FOR song IN songs
RETURN songKeluaran
[
{
"_key": "Air-Minded",
"_id": "songs/Air-Minded",
"_rev": "_VkC5lbS---",
"title": "Air-Minded Executive",
"lyricist": "Johnny Mercer",
"composer": "Bernie Hanighen",
"Year": 1940,
"length": 210
},
{
"_key": "Affable_Balding",
"_id": "songs/Affable_Balding",
"_rev": "_VkC4eM2---",
"title": "Affable Balding Me",
"lyricist": "Johnny Mercer",
"composer": "Robert Emmett Dolan",
"Year": 1950,
"length": 200
},
{
"_key": "All_Mucked",
"_id": "songs/All_Mucked",
"_rev": "_Vjah9Pu---",
"title": "All Mucked Up",
"lyricist": "Johnny Mercer",
"composer": "Andre Previn",
"Year": 1974,
"length": 180
},
{
"_key": "Accentchuate_The",
"_id": "songs/Accentchuate_The",
"_rev": "_VkC3WzW---",
"title": "Accentchuate The Politics",
"lyricist": "Johnny Mercer",
"composer": "Harold Arlen",
"Year": 1944,
"length": 190
}
]Untuk mengilustrasikan penggunaan kata kunci AQL lain seperti LET, FILTER, SORT, dll., Sekarang kami memformat durasi lagu di mm:ss format.
Pertanyaan
FOR song IN songs
FILTER song.length > 150
LET seconds = song.length % 60
LET minutes = FLOOR(song.length / 60)
SORT song.composer
RETURN
{
Title: song.title,
Composer: song.composer,
Duration: CONCAT_SEPARATOR(':',minutes, seconds)
}
Kali ini kami akan mengembalikan judul lagu beserta durasinya. ItuReturn fungsi memungkinkan Anda membuat objek JSON baru untuk dikembalikan untuk setiap dokumen masukan.
Sekarang kita akan berbicara tentang fitur 'Bergabung' dari database AQL.
Mari kita mulai dengan membuat koleksi composer_dob. Selanjutnya, kami akan membuat empat dokumen dengan hipotesis tanggal lahir para komposer dengan menjalankan kueri berikut di kotak kueri -
FOR dob IN [
{composer: "Bernie Hanighen", Year: 1909}
,
{composer: "Robert Emmett Dolan", Year: 1922}
,
{composer: "Andre Previn", Year: 1943}
,
{composer: "Harold Arlen", Year: 1910}
]
INSERT dob in composer_dob
Untuk menyoroti kesamaan dengan SQL, kami menyajikan kueri FOR-loop bersarang di AQL, yang mengarah ke operasi REPLACE, melakukan iterasi pertama di loop dalam, di atas semua komposer dan kemudian pada semua lagu terkait, membuat dokumen baru yang berisi atribut song_with_composer_key alih-alih song atribut.
Ini dia kueri -
FOR s IN songs
FOR c IN composer_dob
FILTER s.composer == c.composer
LET song_with_composer_key = MERGE(
UNSET(s, 'composer'),
{composer_key:c._key}
)
REPLACE s with song_with_composer_key IN songs
Sekarang mari kita menjalankan kueri FOR song IN songs RETURN song sekali lagi untuk melihat bagaimana koleksi lagu telah berubah.
Keluaran
[
{
"_key": "Air-Minded",
"_id": "songs/Air-Minded",
"_rev": "_Vk8kFoK---",
"Year": 1940,
"composer_key": "5501",
"length": 210,
"lyricist": "Johnny Mercer",
"title": "Air-Minded Executive"
},
{
"_key": "Affable_Balding",
"_id": "songs/Affable_Balding",
"_rev": "_Vk8kFoK--_",
"Year": 1950,
"composer_key": "5505",
"length": 200,
"lyricist": "Johnny Mercer",
"title": "Affable Balding Me"
},
{
"_key": "All_Mucked",
"_id": "songs/All_Mucked",
"_rev": "_Vk8kFoK--A",
"Year": 1974,
"composer_key": "5507",
"length": 180,
"lyricist": "Johnny Mercer",
"title": "All Mucked Up"
},
{
"_key": "Accentchuate_The",
"_id": "songs/Accentchuate_The",
"_rev": "_Vk8kFoK--B",
"Year": 1944,
"composer_key": "5509",
"length": 190,
"lyricist": "Johnny Mercer",
"title": "Accentchuate The Politics"
}
]Kueri di atas menyelesaikan proses migrasi data, menambahkan composer_key untuk setiap lagu.
Sekarang query berikutnya adalah query FOR-loop bertingkat, tapi kali ini mengarah ke operasi Join, menambahkan nama komposer terkait (memilih dengan bantuan `composer_key`) ke setiap lagu -
FOR s IN songs
FOR c IN composer_dob
FILTER c._key == s.composer_key
RETURN MERGE(s,
{ composer: c.composer }
)Keluaran
[
{
"Year": 1940,
"_id": "songs/Air-Minded",
"_key": "Air-Minded",
"_rev": "_Vk8kFoK---",
"composer_key": "5501",
"length": 210,
"lyricist": "Johnny Mercer",
"title": "Air-Minded Executive",
"composer": "Bernie Hanighen"
},
{
"Year": 1950,
"_id": "songs/Affable_Balding",
"_key": "Affable_Balding",
"_rev": "_Vk8kFoK--_",
"composer_key": "5505",
"length": 200,
"lyricist": "Johnny Mercer",
"title": "Affable Balding Me",
"composer": "Robert Emmett Dolan"
},
{
"Year": 1974,
"_id": "songs/All_Mucked",
"_key": "All_Mucked",
"_rev": "_Vk8kFoK--A",
"composer_key": "5507",
"length": 180,
"lyricist": "Johnny Mercer",
"title": "All Mucked Up",
"composer": "Andre Previn"
},
{
"Year": 1944,
"_id": "songs/Accentchuate_The",
"_key": "Accentchuate_The",
"_rev": "_Vk8kFoK--B",
"composer_key": "5509",
"length": 190,
"lyricist": "Johnny Mercer",
"title": "Accentchuate The Politics",
"composer": "Harold Arlen"
}
]
Pada bab ini, kita akan membahas beberapa Contoh Query AQL di file Actors and MoviesDatabase. Kueri ini didasarkan pada grafik.
Masalah
Diberikan koleksi aktor dan koleksi film, dan koleksi actIn edge (dengan properti tahun) untuk menghubungkan simpul seperti yang ditunjukkan di bawah ini -
[Actor] <- act in -> [Movie]
Bagaimana kita mendapatkan -
- Semua aktor yang berakting di "movie1" ATAU "movie2"?
- Semua aktor yang berakting di "movie1" DAN "movie2”?
- Semua film umum antara "actor1" dan "actor2”?
- Semua aktor yang berakting di 3 film atau lebih?
- Semua film di mana tepatnya 6 aktor berakting?
- Jumlah aktor menurut film?
- Jumlah film menurut aktor?
- Jumlah film yang diputar antara tahun 2005 dan 2010 menurut aktornya?
Larutan
Selama proses pemecahan dan mendapatkan jawaban atas pertanyaan di atas, kami akan menggunakan Arangosh untuk membuat kumpulan data dan menjalankan kueri tentang itu. Semua kueri AQL adalah string dan dapat dengan mudah disalin ke driver favorit Anda, bukan Arangosh.
Mari kita mulai dengan membuat Set Data Pengujian di Arangosh. Pertama, unduh file ini -
# wget -O dataset.js
https://drive.google.com/file/d/0B4WLtBDZu_QWMWZYZ3pYMEdqajA/view?usp=sharingKeluaran
...
HTTP request sent, awaiting response... 200 OK
Length: unspecified [text/html]
Saving to: ‘dataset.js’
dataset.js [ <=> ] 115.14K --.-KB/s in 0.01s
2017-09-17 14:19:12 (11.1 MB/s) - ‘dataset.js’ saved [117907]Anda dapat melihat pada output di atas bahwa kami telah mengunduh file JavaScript dataset.js.File ini berisi perintah Arangosh untuk membuat dataset di database. Alih-alih menyalin dan menempelkan perintah satu per satu, kami akan menggunakan--javascript.executeopsi di Arangosh untuk menjalankan beberapa perintah secara non-interaktif. Anggap saja perintah penyelamat hidup!
Sekarang jalankan perintah berikut di shell -
$ arangosh --javascript.execute dataset.js
Berikan kata sandi saat diminta seperti yang Anda lihat pada gambar di atas. Sekarang kami telah menyimpan data, jadi kami akan membuat kueri AQL untuk menjawab pertanyaan spesifik yang muncul di awal bab ini.
Pertanyaan pertama
Mari kita ambil pertanyaan pertama: All actors who acted in "movie1" OR "movie2". Misalkan, kami ingin menemukan nama semua aktor yang berakting di "TheMatrix" ATAU "TheDevilsAdvocate" -
Kami akan mulai dengan satu film pada satu waktu untuk mendapatkan nama-nama aktornya -
127.0.0.1:8529@_system> db._query("FOR x IN ANY 'movies/TheMatrix' actsIn
OPTIONS {bfs: true, uniqueVertices: 'global'} RETURN x._id").toArray();Keluaran
Kami akan menerima output berikut -
[
"actors/Hugo",
"actors/Emil",
"actors/Carrie",
"actors/Keanu",
"actors/Laurence"
]
Sekarang kita melanjutkan untuk membentuk UNION_DISTINCT dari dua query NEIGHBORS yang akan menjadi solusi -
127.0.0.1:8529@_system> db._query("FOR x IN UNION_DISTINCT ((FOR y IN ANY
'movies/TheMatrix' actsIn OPTIONS {bfs: true, uniqueVertices: 'global'} RETURN
y._id), (FOR y IN ANY 'movies/TheDevilsAdvocate' actsIn OPTIONS {bfs: true,
uniqueVertices: 'global'} RETURN y._id)) RETURN x").toArray();Keluaran
[
"actors/Charlize",
"actors/Al",
"actors/Laurence",
"actors/Keanu",
"actors/Carrie",
"actors/Emil",
"actors/Hugo"
]
Pertanyaan Kedua
Sekarang mari kita bahas pertanyaan kedua: All actors who acted in both "movie1" AND "movie2". Ini hampir sama dengan pertanyaan di atas. Tapi kali ini kami tidak tertarik pada UNION tetapi pada INTERSECTION -
127.0.0.1:8529@_system> db._query("FOR x IN INTERSECTION ((FOR y IN ANY
'movies/TheMatrix' actsIn OPTIONS {bfs: true, uniqueVertices: 'global'} RETURN
y._id), (FOR y IN ANY 'movies/TheDevilsAdvocate' actsIn OPTIONS {bfs: true,
uniqueVertices: 'global'} RETURN y._id)) RETURN x").toArray();Keluaran
Kami akan menerima output berikut -
[
"actors/Keanu"
]
Pertanyaan Ketiga
Sekarang mari kita pertimbangkan pertanyaan ketiga: All common movies between "actor1" and "actor2". Ini sebenarnya identik dengan pertanyaan tentang aktor biasa di movie1 dan movie2. Kami hanya perlu mengubah simpul awal. Sebagai contoh, mari kita temukan semua film yang dibintangi oleh Hugo Weaving ("Hugo") dan Keanu Reeves -
127.0.0.1:8529@_system> db._query(
"FOR x IN INTERSECTION (
(
FOR y IN ANY 'actors/Hugo' actsIn OPTIONS
{bfs: true, uniqueVertices: 'global'}
RETURN y._id
),
(
FOR y IN ANY 'actors/Keanu' actsIn OPTIONS
{bfs: true, uniqueVertices:'global'} RETURN y._id
)
)
RETURN x").toArray();Keluaran
Kami akan menerima output berikut -
[
"movies/TheMatrixReloaded",
"movies/TheMatrixRevolutions",
"movies/TheMatrix"
]
Pertanyaan Keempat
Sekarang mari kita bahas pertanyaan keempat. All actors who acted in 3 or more movies. Pertanyaan ini berbeda; kita tidak bisa menggunakan fungsi tetangga di sini. Sebagai gantinya kita akan menggunakan indeks tepi dan pernyataan KUMPULKAN dari AQL untuk pengelompokan. Ide dasarnya adalah untuk mengelompokkan semua sisi dengan merekastartVertex(yang dalam dataset ini selalu menjadi aktornya). Kemudian kami menghapus semua aktor dengan kurang dari 3 film dari hasil karena di sini kami telah memasukkan jumlah film yang dimainkan aktor -
127.0.0.1:8529@_system> db._query("FOR x IN actsIn COLLECT actor = x._from WITH
COUNT INTO counter FILTER counter >= 3 RETURN {actor: actor, movies:
counter}"). toArray()Keluaran
[
{
"actor" : "actors/Carrie",
"movies" : 3
},
{
"actor" : "actors/CubaG",
"movies" : 4
},
{
"actor" : "actors/Hugo",
"movies" : 3
},
{
"actor" : "actors/Keanu",
"movies" : 4
},
{
"actor" : "actors/Laurence",
"movies" : 3
},
{
"actor" : "actors/MegR",
"movies" : 5
},
{
"actor" : "actors/TomC",
"movies" : 3
},
{
"actor" : "actors/TomH",
"movies" : 3
}
]
Untuk pertanyaan yang tersisa, kita akan membahas formasi query, dan hanya menyediakan query. Pembaca harus menjalankan kueri itu sendiri di terminal Arangosh.
Pertanyaan Kelima
Sekarang mari kita bahas pertanyaan kelima: All movies where exactly 6 actors acted in. Ide yang sama seperti di kueri sebelumnya, tetapi dengan filter kesetaraan. Namun, sekarang kami membutuhkan film dan bukan aktornya, jadi kami mengembalikan file_to attribute -
db._query("FOR x IN actsIn COLLECT movie = x._to WITH COUNT INTO counter FILTER
counter == 6 RETURN movie").toArray()Jumlah aktor menurut film?
Kami ingat dalam dataset kami _to di tepi sesuai dengan film, jadi kami menghitung seberapa sering sama _tomuncul. Ini jumlah aktornya. Kueri hampir identik dengan yang sebelumnya tetapiwithout the FILTER after COLLECT -
db._query("FOR x IN actsIn COLLECT movie = x._to WITH COUNT INTO counter RETURN
{movie: movie, actors: counter}").toArray()Pertanyaan Keenam
Sekarang, mari kita pertimbangkan pertanyaan keenam: The number of movies by an actor.
Cara kami menemukan solusi untuk kueri kami di atas akan membantu Anda menemukan solusi untuk kueri ini juga.
db._query("FOR x IN actsIn COLLECT actor = x._from WITH COUNT INTO counter
RETURN {actor: actor, movies: counter}").toArray()Dalam bab ini, kami akan menjelaskan berbagai kemungkinan untuk menerapkan ArangoDB.
Penerapan: Satu Instance
Kami telah mempelajari cara menerapkan satu instance Linux (Ubuntu) di salah satu bab kami sebelumnya. Sekarang mari kita lihat cara membuat penerapan menggunakan Docker.
Penerapan: Docker
Untuk penyebaran menggunakan buruh pelabuhan, kami akan menginstal Docker di komputer kami. Untuk informasi lebih lanjut tentang Docker, silakan lihat tutorial kami di Docker .
Setelah Docker diinstal, Anda dapat menggunakan perintah berikut -
docker run -e ARANGO_RANDOM_ROOT_PASSWORD = 1 -d --name agdb-foo -d
arangodb/arangodbIni akan membuat dan meluncurkan instance Docker dari ArangoDB dengan nama pengenal agdbfoo sebagai proses latar belakang Docker.
Terminal juga akan mencetak pengenal proses.
Secara default, port 8529 dicadangkan untuk ArangoDB untuk mendengarkan permintaan. Juga port ini secara otomatis tersedia untuk semua wadah aplikasi Docker yang mungkin telah Anda tautkan.