- ArangoDB 教程
- ArangoDB - 首頁
- 一款多模型優先資料庫
- ArangoDB – 優勢
- 基本概念和術語
- ArangoDB – 系統要求
- ArangoDB – 命令列
- ArangoDB - Web 介面
- ArangoDB - 案例場景
- 資料模型和建模
- ArangoDB - 資料庫方法
- ArangoDB - CRUD 操作
- 使用 Web 介面進行 CRUD 操作
- 使用 AQL 查詢資料
- ArangoDB - AQL 示例查詢
- ArangoDB – 如何部署
- ArangoDB 有用資源
- ArangoDB 快速指南
- ArangoDB - 有用資源
- ArangoDB - 討論
ArangoDB 快速指南
ArangoDB - 一款多模型優先資料庫
ArangoDB 被其開發者譽為原生多模型資料庫。這與其他 NoSQL 資料庫不同。在這個資料庫中，資料可以儲存為文件、鍵值對或圖。並且可以使用單一的宣告式查詢語言訪問所有或任何資料。此外，不同的模型可以在單個查詢中組合。而且，由於其多模型風格，可以建立精簡的應用程式，這些應用程式可以使用所有或任何三種資料模型進行水平擴充套件。
分層與原生多模型資料庫
在本節中，我們將重點介紹原生多模型資料庫和分層多模型資料庫之間的關鍵區別。
許多資料庫廠商稱他們的產品為“多模型”，但是向鍵值或文件儲存新增圖層並不算作原生多模型。
使用 ArangoDB，可以使用相同的核心和相同的查詢語言，將不同的資料模型和特性組合到單個查詢中，正如我們在上一節中已經提到的那樣。在 ArangoDB 中，資料模型之間沒有“切換”，並且沒有將資料從 A 移動到 B 來執行查詢。與“分層”方法相比，這帶來了 ArangoDB 的效能優勢。
對多模型資料庫的需求
解釋 [Fowler 的] 基本思想使我們認識到，對持久層（它是更大軟體架構的一部分）的不同部分使用各種合適的資料模型的好處。
根據此，例如，可以使用關係資料庫來持久化結構化的表格資料；使用文件儲存來儲存非結構化的、類似物件的資料；使用鍵值儲存來儲存雜湊表；使用圖資料庫來儲存高度關聯的引用資料。
但是，這種方法的傳統實現會導致在同一個專案中使用多個數據庫。這會導致一些操作摩擦（更復雜的部署，更頻繁的升級），以及資料一致性和重複性問題。
在統一三種資料模型的資料之後，下一個挑戰是設計和實現一種通用的查詢語言，允許資料管理員表達各種查詢，例如文件查詢、鍵值查詢、圖查詢以及這些查詢的任意組合。
透過 **圖查詢**，我們的意思是涉及圖論考慮的查詢。特別是，這些可能涉及來自邊的特定連線特性。例如，**最短路徑、圖遍歷**和**鄰居**。
圖是作為關係資料模型的完美選擇。在許多現實世界的案例中，例如社交網路、推薦系統等，一個非常自然的資料模型是一個圖。它捕獲關係，並且可以在每個邊和每個頂點上儲存標籤資訊。此外，JSON 文件非常適合儲存這種型別的頂點和邊資料。
ArangoDB ─ 特性
ArangoDB 有各種顯著的特性。我們將在下面重點介紹突出的特性：
- 多模型範式
- ACID 屬性
- HTTP API
ArangoDB 支援所有流行的資料庫模型。以下是 ArangoDB 支援的一些模型：
- 文件模型
- 鍵值模型
- 圖模型
只需要一種查詢語言就可以從資料庫中檢索資料
四個屬性 **原子性、一致性、隔離性** 和 **永續性** (ACID) 描述了資料庫事務的保證。ArangoDB 支援符合 ACID 的事務。
ArangoDB 允許客戶端（例如瀏覽器）使用 HTTP API 與資料庫互動，該 API 是面向資源的，並且可以使用 JavaScript 進行擴充套件。
ArangoDB - 優勢
以下是使用 ArangoDB 的優勢：
整合
作為一個原生多模型資料庫，ArangoDB 消除了部署多個數據庫的需要，從而減少了元件數量及其維護。因此，它降低了應用程式的技術棧複雜性。除了整合您的整體技術需求之外，這種簡化還導致更低的總擁有成本和更高的靈活性。
簡化的效能擴充套件
隨著應用程式隨著時間的推移而增長，ArangoDB 可以透過使用不同的資料模型獨立擴充套件來應對不斷增長的效能和儲存需求。由於 ArangoDB 可以垂直和水平擴充套件，因此當您的效能需求下降（故意、期望的減速）時，您的後端系統可以輕鬆縮減規模以節省硬體和運營成本。
降低運營複雜性
多語言持久化的法令是為您承擔的每一項工作採用最佳工具。某些任務需要文件資料庫，而其他任務可能需要圖資料庫。由於使用單模型資料庫，它會導致多個操作挑戰。整合單模型資料庫本身就是一項困難的工作。但最大的挑戰是在不同的、不相關的資料庫系統之間構建具有資料一致性和容錯能力的大型內聚結構。這可能被證明幾乎是不可能的。
原生多模型資料庫可以處理多語言持久化，因為它允許輕鬆地擁有多語言資料，但同時在容錯系統上保持資料一致性。使用 ArangoDB，我們可以為複雜的工作使用正確的資料模型。
強大的資料一致性
如果使用多個單模型資料庫，資料一致性可能會成為一個問題。這些資料庫並非設計為相互通訊，因此需要實現某種形式的事務功能來保持不同模型之間的資料一致性。
ArangoDB 支援 ACID 事務，它使用單個後端管理不同的資料模型，在單個例項上提供強一致性，並在叢集模式下操作時提供原子操作。
容錯
使用許多不相關的元件構建容錯系統是一項挑戰。在使用叢集時，這個挑戰變得更加複雜。需要專業知識才能部署和維護此類系統，使用不同的技術和/或技術棧。此外，整合旨在獨立執行的多個子系統會造成巨大的工程和運營成本。
作為整合的技術棧，多模型資料庫提供了一個優雅的解決方案。ArangoDB 設計用於支援具有不同資料模型的現代模組化架構，也適用於叢集使用。
降低總擁有成本
每種資料庫技術都需要持續的維護、錯誤修復補丁和其他由供應商提供的程式碼更改。採用多模型資料庫只需消除應用程式設計中的資料庫技術數量，就可以顯著降低相關的維護成本。
事務
在多臺機器上提供事務保證是一項真正的挑戰，很少有 NoSQL 資料庫提供這些保證。ArangoDB 作為原生多模型資料庫，強制執行事務以保證資料一致性。
基本概念和術語
在本章中，我們將討論 ArangoDB 的基本概念和術語。瞭解我們正在處理的技術主題相關的基本術語非常重要。
ArangoDB 的術語如下：
- 文件
- 集合
- 集合識別符號
- 集合名稱
- 資料庫
- 資料庫名稱
- 資料庫組織
從資料模型的角度來看，ArangoDB 可以被認為是一個面向文件的資料庫，因為文件的概念是後者的數學概念。面向文件的資料庫是 NoSQL 資料庫的主要類別之一。
層次結構如下：文件分組到集合中，集合存在於資料庫中
識別符號和名稱是集合和資料庫的兩個屬性，這一點應該很明顯。
通常，儲存在文件集合中的兩個文件（頂點）透過儲存在邊集合中的文件（邊）連結。這是 ArangoDB 的圖資料模型。它遵循有向標記圖的數學概念，只是邊不僅有標籤，而且是完整的文件。
熟悉了該資料庫的核心術語後，我們開始理解 ArangoDB 的圖資料模型。在這個模型中，存在兩種型別的集合：文件集合和邊集合。邊集合儲存文件，還包括兩個特殊屬性：第一個是 **_from** 屬性，第二個是 **_to** 屬性。這些屬性用於建立圖資料庫中必不可少的文件之間的邊（關係）。在圖的上下文中，文件集合也稱為頂點集合（參見任何圖論書籍）。
現在讓我們看看資料庫有多重要。它們很重要，因為集合存在於資料庫中。在一個 ArangoDB 例項中，可以存在一個或多個數據庫。不同的資料庫通常用於多租戶設定，因為它們內部的不同資料集（集合、文件等）是彼此隔離的。預設資料庫 **_system** 是特殊的，因為它不能被刪除。使用者在這個資料庫中進行管理，他們的憑據對伺服器例項的所有資料庫都有效。
ArangoDB - 系統要求
在本章中，我們將討論 ArangoDB 的系統要求。
ArangoDB 的系統要求如下：
- 安裝了 Ubuntu 的 VPS 伺服器
- RAM：1 GB；CPU：2.2 GHz
對於本教程中的所有命令，我們使用了 RAM 為 1GB、一個 CPU 處理能力為 2.2 GHz 的 Ubuntu 16.04 (xenial) 例項。本教程中的所有 arangosh 命令都針對 ArangoDB 3.1.27 版本進行了測試。
如何安裝 ArangoDB？
在本節中，我們將瞭解如何安裝 ArangoDB。ArangoDB 預先構建了許多作業系統和發行版。有關更多詳細資訊，請參閱 ArangoDB 文件。如前所述，在本教程中，我們將使用 Ubuntu 16.04x64。
第一步是下載其儲存庫的公共金鑰：
# wget https://www.arangodb.com/repositories/arangodb31/ xUbuntu_16.04/Release.key
輸出
--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]
重要的是，您應該看到在輸出結束時儲存的 **Release.key**。
讓我們使用以下程式碼行安裝儲存的金鑰：
# sudo apt-key add Release.key
輸出
OK
執行以下命令以新增 apt 儲存庫並更新索引：
# sudo apt-add-repository 'deb https://www.arangodb.com/repositories/arangodb31/xUbuntu_16.04/ /' # sudo apt-get update
最後一步，我們可以安裝 ArangoDB：
# sudo apt-get install arangodb3
輸出
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.
按 **Enter** 鍵。現在 ArangoDB 的安裝過程將開始：
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.
當 ArangoDB 的安裝即將完成時，將出現以下螢幕：
在這裡，系統將要求您為 ArangoDB **root** 使用者提供密碼。請仔細記下它。
當出現以下對話方塊時，選擇 **yes** 選項：
當您像上面對話方塊中一樣單擊 **Yes** 時，將出現以下對話方塊。在此處單擊 **Yes**。
您也可以使用以下命令檢查 ArangoDB 的狀態：
# sudo systemctl status arangodb3
輸出
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 現在可以使用了。
要在終端中呼叫 arangosh 終端，請在終端中輸入以下命令：
# arangosh
輸出
Please specify a password:
輸入安裝時建立的root密碼：
_ __ _ _ __ __ _ _ __ __ _ ___ | | / | '__/ _ | ’ \ / ` |/ _ / | ’ | (| | | | (| | | | | (| | () _ \ | | | _,|| _,|| ||_, |_/|/| || |__/
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
要登出 ArangoDB，請輸入以下命令：
127.0.0.1:8529@_system> exit
輸出
Uf wiederluege! Na shledanou! Auf Wiedersehen! Bye Bye! Adiau! ¡Hasta luego! Εις το επανιδείν! להתראות ! Arrivederci! Tot ziens! Adjö! Au revoir! さようなら До свидания! Até Breve! !خداحافظ
ArangoDB - 命令列
本章將討論 Arangosh 如何作為 ArangoDB 的命令列工作。我們將首先學習如何新增資料庫使用者。
注意 - 請記住，數字鍵盤可能在 Arangosh 上不起作用。
讓我們假設使用者名稱為“harry”，密碼為“hpwdb”。
127.0.0.1:8529@_system> require("org/arangodb/users").save("harry", "hpwdb");
輸出
{
"user" : "harry",
"active" : true,
"extra" : {},
"changePassword" : false,
"code" : 201
}
ArangoDB - Web 介面
本章，我們將學習如何啟用/停用身份驗證，以及如何將 ArangoDB 繫結到公共網路介面。
# arangosh --server.endpoint tcp://127.0.0.1:8529 --server.database "_system"
它將提示您輸入之前儲存的密碼：
Please specify a password:
使用您在配置期間為 root 建立的密碼。
您也可以使用 curl 檢查您是否確實正在為需要身份驗證的請求獲取 HTTP 401（未授權）伺服器響應：
# curl --dump - http://127.0.0.1:8529/_api/version
輸出
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: 0
為了避免在學習過程中每次都輸入密碼，我們將停用身份驗證。為此，請開啟配置檔案：
# vim /etc/arangodb3/arangod.conf
如果程式碼顯示不清晰，您應該更改顏色方案。
:colorscheme desert
將身份驗證設定為 false，如下面的螢幕截圖所示。
重啟服務：
# service arangodb3 restart
將身份驗證設定為 false 後，您將能夠登入（使用 root 或在此情況下建立的使用者，例如Harry），無需在請指定密碼中輸入任何密碼。
讓我們在關閉身份驗證時檢查api版本：
# curl --dump - http://127.0.0.1:8529/_api/version
輸出
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"}
ArangoDB - 案例場景
本章將考慮兩種示例場景。這些示例更容易理解，並將幫助我們瞭解 ArangoDB 功能的工作方式。
為了演示 API，ArangoDB 預裝了一組易於理解的圖形。在您的 ArangoDB 中建立這些圖形例項有兩種方法：
- 在 Web 介面中的建立圖形視窗中新增示例選項卡，
- 或在 Arangosh 中載入模組@arangodb/graph-examples/example-graph。
首先，讓我們藉助 Web 介面載入一個圖形。為此，啟動 Web 介面並單擊圖形選項卡。
將出現建立圖形對話方塊。嚮導包含兩個選項卡 - 示例和圖形。預設情況下開啟圖形選項卡；假設我們要建立一個新圖形，它會詢問圖形的名稱和其他定義。
現在，我們將上傳已建立的圖形。為此，我們將選擇示例選項卡。
我們可以看到三個示例圖形。選擇Knows_Graph並單擊綠色按鈕“建立”。
建立後，您可以在 Web 介面中檢查它們 - 用於建立以下圖片的介面。
Knows_Graph
現在讓我們看看Knows_Graph是如何工作的。選擇 Knows_Graph，它將獲取圖形資料。
Knows_Graph 由一個頂點集合persons組成，透過一個邊集合knows連線。它將包含五個頂點：Alice、Bob、Charlie、Dave 和 Eve。我們將有以下有向關係
Alice knows Bob Bob knows Charlie Bob knows Dave Eve knows Alice Eve knows Bob
如果單擊一個節點（頂點），例如“bob”，它將顯示 ID（persons/bob）屬性名稱。
單擊任何邊時，它將顯示 ID（knows/4590）屬性。
這就是我們建立、檢查其頂點和邊的方法。
讓我們再新增一個圖形，這次使用 Arangosh。為此，我們需要在 ArangoDB 配置檔案中包含另一個端點。
如何新增多個端點
開啟配置檔案：
# vim /etc/arangodb3/arangod.conf
新增另一個端點，如下面的終端螢幕截圖所示。
重啟 ArangoDB：
# service arangodb3 restart
啟動 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>
Social_Graph
現在讓我們瞭解 Social_Graph 是什麼以及它是如何工作的。該圖顯示了一組人員及其關係：
此示例在兩個頂點集合（女性和男性）中具有女性和男性作為頂點。邊是它們在關係邊集合中的連線。我們已經描述瞭如何使用 Arangosh 建立此圖。讀者可以圍繞它進行操作並探索其屬性，就像我們對 Knows_Graph 所做的那樣。
ArangoDB - 資料模型和建模
本章將重點介紹以下主題：
- 資料庫互動
- 資料模型
- 資料檢索
ArangoDB 支援基於文件的資料模型以及基於圖形的資料模型。讓我們首先描述基於文件的資料模型。
ArangoDB 的文件非常類似於 JSON 格式。文件中包含零個或多個屬性，每個屬性都附加一個值。值可以是原子型別，例如數字、布林值或 null、文字字串，也可以是複合資料型別，例如嵌入式文件/物件或陣列。陣列或子物件可以由這些資料型別組成，這意味著單個文件可以表示非平凡的資料結構。
在層次結構中，文件被排列成集合，這些集合可能不包含任何文件（理論上）或包含多個文件。您可以將文件與行進行比較，將集合與表進行比較（這裡的表和行指的是關係資料庫管理系統 - RDBMS 的表和行）。
但是，在 RDBMS 中，定義列是將記錄儲存到表中的先決條件，這些定義稱為模式。然而，作為一個新穎的功能，ArangoDB 是無模式的——沒有先驗的理由來指定文件將具有哪些屬性。
與 RDBMS 不同的是，每個文件的結構都可以與其他文件完全不同。這些文件可以一起儲存在一個集合中。實際上，集合中的文件可能存在共同特徵，但是資料庫系統，即 ArangoDB 本身，不會將您繫結到特定的資料結構。
現在我們將嘗試理解 ArangoDB 的[圖形資料模型]，它需要兩種型別的集合——第一種是文件集合（在群論語言中稱為頂點集合），第二種是邊集合。這兩種型別之間存在細微的差別。邊集合也儲存文件，但它們的特徵是包含兩個唯一屬性_from和_to，用於建立文件之間的關係。實際上，一個文件（讀取邊）連結兩個文件（讀取頂點），兩者都儲存在其各自的集合中。這種架構源自標記有向圖的圖論概念，不包括那些不僅可以有標籤，而且本身可以是一個完整的 JSON 文件的邊。
為了計算新資料、刪除文件或操作它們，使用查詢來根據給定條件選擇或過濾文件。無論是像“示例查詢”那樣簡單，還是像“聯接”那樣複雜，查詢都使用 AQL（ArangoDB 查詢語言）編寫。
ArangoDB - 資料庫方法
本章將討論 ArangoDB 中的不同資料庫方法。
首先，讓我們獲取資料庫的屬性：
- 名稱
- ID
- 路徑
首先，我們呼叫 Arangosh。一旦呼叫 Arangosh，我們將列出我們迄今為止建立的資料庫：
我們將使用以下程式碼行來呼叫 Arangosh：
127.0.0.1:8529@_system> db._databases()
輸出
[ "_system", "song_collection" ]
我們看到兩個資料庫，一個是由預設建立的_system，第二個是我們建立的song_collection。
現在讓我們使用以下程式碼行切換到 song_collection 資料庫：
127.0.0.1:8529@_system> db._useDatabase("song_collection")
輸出
true 127.0.0.1:8529@song_collection>
我們將探索 song_collection 資料庫的屬性。
要查詢名稱
我們將使用以下程式碼行來查詢名稱。
127.0.0.1:8529@song_collection> db._name()
輸出
song_collection
要查詢 id：
我們將使用以下程式碼行來查詢 id。
127.0.0.1:8529@song_collection> db._id()
輸出
4838
要查詢路徑：
我們將使用以下程式碼行來查詢路徑。
127.0.0.1:8529@song_collection> db._path()
輸出
/var/lib/arangodb3/databases/database-4838
現在讓我們使用以下程式碼行檢查我們是否在系統資料庫中：
127.0.0.1:8529@song_collection&t; db._isSystem()
輸出
false
這意味著我們不在系統資料庫中（因為我們已經建立並切換到 song_collection）。以下螢幕截圖將幫助您理解這一點。
要獲取特定集合，例如 songs：
我們將使用以下程式碼行獲取特定集合。
127.0.0.1:8529@song_collection> db._collection("songs")
輸出
[ArangoCollection 4890, "songs" (type document, status loaded)]
該程式碼行返回單個集合。
讓我們在後續章節中討論資料庫操作的要點。
ArangoDB - CRUD 操作
本章將學習 Arangosh 的不同操作。
以下是 Arangosh 的可能操作：
- 建立文件集合
- 建立文件
- 讀取文件
- 更新文件
讓我們從建立一個新資料庫開始。我們將使用以下程式碼行建立一個新資料庫：
127.0.0.1:8529@_system> db._createDatabase("song_collection")
true
以下程式碼行將幫助您切換到新資料庫：
127.0.0.1:8529@_system> db._useDatabase("song_collection")
true
提示將切換到“@@song_collection”
127.0.0.1:8529@song_collection>
從這裡我們將學習 CRUD 操作。讓我們在新資料庫中建立一個集合：
127.0.0.1:8529@song_collection> db._createDocumentCollection('songs')
輸出
[ArangoCollection 4890, "songs" (type document, status loaded)] 127.0.0.1:8529@song_collection>
讓我們向我們的 'songs' 集合中新增一些文件（JSON 物件）。
我們按以下方式新增第一個文件：
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"})
輸出
{
"_id" : "songs/A_Man",
"_key" : "A_Man",
"_rev" : "_VjVClbW---"
}
讓我們向資料庫新增其他文件。這將幫助我們學習查詢資料的過程。您可以複製這些程式碼並將它們貼上到 Arangosh 中以模擬該過程：
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---"
}
如何讀取文件
_key 或文件控制代碼可用於檢索文件。如果不需要遍歷集合本身，請使用文件控制代碼。如果您有集合，則文件函式易於使用：
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
}
如何更新文件
有兩種選項可用於更新儲存的資料：替換和更新。
更新函式修補文件，將其與給定的屬性合併。另一方面，替換函式將用新文件替換之前的文件。即使提供了完全不同的屬性，替換仍然會發生。我們首先觀察非破壞性更新，更新歌曲中的屬性 Production：
127.0.0.1:8529@song_collection> db.songs.update("songs/A_Man",{production:
"Top Banana"});
輸出
{
"_id" : "songs/A_Man",
"_key" : "A_Man",
"_rev" : "_VjVOcqe---",
"_oldRev" : "_VjVClbW---"
}
現在讓我們讀取更新後的歌曲的屬性：
127.0.0.1:8529@song_collection> db.songs.document('A_Man');
輸出
{
"_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"
}
可以使用update函式輕鬆更新大型文件，尤其是在屬性很少的情況下。
相反，replace函式在與同一文件一起使用時會消除您的資料。
127.0.0.1:8529@song_collection> db.songs.replace("songs/A_Man",{production:
"Top Banana"});
現在讓我們使用以下程式碼行檢查我們剛剛更新的歌曲：
127.0.0.1:8529@song_collection> db.songs.document('A_Man');
輸出
{
"_key" : "A_Man",
"_id" : "songs/A_Man",
"_rev" : "_VjVRhOq---",
"production" : "Top Banana"
}
現在，您可以觀察到該文件不再具有原始資料。
如何刪除文件
刪除函式與文件控制代碼結合使用，用於從集合中刪除文件：
127.0.0.1:8529@song_collection> db.songs.remove('A_Man');
現在讓我們使用以下程式碼行檢查我們剛剛刪除的歌曲的屬性：
127.0.0.1:8529@song_collection> db.songs.document('A_Man');
我們將得到如下異常錯誤作為輸出：
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
使用 Web 介面的 CRUD 操作
在上一章中，我們學習瞭如何使用命令列工具 Arangosh 對文件執行各種操作。現在，我們將學習如何使用 Web 介面執行相同的操作。首先，將以下地址 - http://your_server_ip:8529/_db/song_collection/_admin/aardvark/index.html#login 複製到瀏覽器位址列。您將被定向到以下登入頁面。
現在，輸入使用者名稱和密碼。
如果成功，將顯示以下螢幕。我們需要選擇要操作的資料庫，預設資料庫為_system 資料庫。讓我們選擇song_collection 資料庫，然後點選綠色標籤 -
建立集合
在本節中，我們將學習如何建立集合。點選頂部導航欄中的“集合”選項卡。
我們使用命令列新增的 songs 集合可見。點選它將顯示條目。我們現在將使用 Web 介面新增一個artists 集合。我們使用 Arangosh 建立的songs 集合已經存在。在出現的“新建集合”對話方塊的“名稱”欄位中，輸入artists。可以安全地忽略高階選項，預設集合型別（即文件）就可以了。
點選“儲存”按鈕將最終建立集合，現在這兩個集合將在此頁面上可見。
使用文件填充新建立的集合
點選artists 集合後，您將看到一個空的集合 -
要新增文件，您需要點選右上角的“+”號。當系統提示您輸入_key 時，請輸入Affable_Balding 作為鍵。
現在，將出現一個表單來新增和編輯文件的屬性。新增屬性有兩種方式：圖形化和樹狀。圖形化方式直觀但速度慢，因此我們將切換到程式碼檢視，使用樹狀下拉選單進行選擇 -
為了簡化流程，我們建立了一個 JSON 格式的示例資料，您可以複製然後貼上到查詢編輯器區域 -
{"artist": "Johnny Mercer", "title":"Affable Balding Me", "composer": "Robert Emmett Dolan", "Year": 1950}
（注意：只能使用一對花括號；請參見下面的螢幕截圖）
您可以觀察到，我們在程式碼檢視模式下對鍵和值都加了引號。現在，點選“儲存”。成功完成操作後，頁面上會短暫出現綠色閃光。
如何讀取文件
要讀取文件，請返回“集合”頁面。
點選artist 集合後，將出現一個新條目。
如何更新文件
編輯文件中的條目很簡單；您只需點選文件概述中要編輯的行即可。在這裡，與建立新文件時一樣，也會顯示相同的查詢編輯器。
刪除文件
您可以透過按“-”圖示刪除文件。每個文件行在末尾都有此符號。它會提示您確認以避免不安全刪除。
此外，對於特定集合，“集合概述”頁面上還存在其他操作，例如過濾文件、管理索引和匯入資料。
在下一章中，我們將討論 Web 介面的一個重要功能，即 AQL 查詢編輯器。
使用 AQL 查詢資料
本章將討論如何使用 AQL 查詢資料。我們已經在之前的章節中討論過，ArangoDB 開發了自己的查詢語言，名為 AQL。
現在讓我們開始與 AQL 互動。如下圖所示，在 Web 介面中，點選導航欄頂部的AQL 編輯器選項卡。將出現一個空白的查詢編輯器。
需要時，您可以透過點選右上角的“查詢”或“結果”選項卡在編輯器和結果檢視之間切換，如下圖所示 -
除其他功能外，編輯器還具有語法高亮顯示、撤銷/重做功能和查詢儲存功能。有關詳細資訊，請參閱官方文件。我們將重點介紹 AQL 查詢編輯器的一些基本和常用功能。
AQL 基礎知識
在 AQL 中，查詢表示要實現的最終結果，而不是實現最終結果的過程。此功能通常被稱為該語言的宣告式屬性。此外，AQL 可以查詢和修改資料，因此可以透過組合這兩個過程來建立複雜的查詢。
請注意，AQL 完全符合 ACID 規範。讀取或修改查詢要麼完全完成，要麼完全不完成。即使讀取文件資料，也會以一致的資料單元結束。
我們向已經建立的 songs 集合新增兩首新歌曲。無需鍵入，您可以複製以下查詢，然後將其貼上到 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 songs
點選左下角的“執行”按鈕。
它將在songs 集合中寫入兩個新文件。
此查詢描述了 AQL 中 FOR 迴圈的工作方式；它迭代 JSON 編碼文件列表，對集合中的每個文件執行編碼操作。不同的操作可以是建立新結構、過濾、選擇文件、修改或將文件插入資料庫（參考即時示例）。本質上，AQL 可以高效地執行 CRUD 操作。
要查詢資料庫中的所有歌曲，讓我們再次執行以下查詢，相當於 SQL 型別資料庫的SELECT * FROM songs（因為編輯器會記住上次查詢，請按*新建*按鈕清除編輯器）-
FOR song IN songs RETURN song
結果集將顯示迄今為止儲存在songs 集合中的歌曲列表，如下圖所示。
可以將FILTER、SORT 和LIMIT 等操作新增到For 迴圈主體中，以縮小和排序結果。
FOR song IN songs FILTER song.Year > 1940 RETURN song
上面的查詢將在“結果”選項卡中顯示 1940 年以後創作的歌曲（請參見下面的圖片）。
本例中使用了文件鍵，但任何其他屬性也可以用作過濾的等效項。由於文件鍵保證是唯一的，因此最多隻有一個文件與該過濾器匹配。對於其他屬性，情況可能並非如此。要返回活動使用者（由名為 status 的屬性確定）的子集，按名稱升序排序，我們使用以下語法 -
FOR song IN songs FILTER song.Year > 1940 SORT song.composer RETURN song LIMIT 2
我們特意包含了這個例子。在這裡，我們觀察到 AQL 以紅色突出顯示的查詢語法錯誤訊息。此語法突出顯示錯誤，有助於除錯您的查詢，如下圖所示。
現在讓我們執行正確的查詢（注意更正）-
FOR song IN songs FILTER song.Year > 1940 SORT song.composer LIMIT 2 RETURN song
AQL 中的複雜查詢
AQL 為所有受支援的資料型別配備了多個函式。查詢中的變數賦值允許構建非常複雜的巢狀結構。這樣，資料密集型操作更靠近後端的資料，而不是客戶端（例如瀏覽器）。為了理解這一點，讓我們首先向歌曲新增任意持續時間（長度）。
讓我們從第一個函式開始，即 Update 函式 -
UPDATE { _key: "All_Mucked" }
WITH { length: 180 }
IN songs
我們可以看到已寫入一個文件，如上圖所示。
現在讓我們也更新其他文件（歌曲）。
UPDATE { _key: "Affable_Balding" }
WITH { length: 200 }
IN songs
現在我們可以檢查所有歌曲是否都有一個新的屬性length -
FOR song IN songs RETURN song
輸出
[
{
"_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
}
]
為了說明 AQL 的其他關鍵字（如 LET、FILTER、SORT 等）的使用，我們現在將歌曲的持續時間格式化為mm:ss 格式。
查詢
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)
}
這次我們將返回歌曲標題和持續時間。Return 函式允許您為每個輸入文件建立一個新的 JSON 物件以返回。
我們現在將討論 AQL 資料庫的“連線”功能。
讓我們首先建立一個集合composer_dob。此外，我們將透過在查詢框中執行以下查詢來建立四個文件，其中包含作曲家的假設出生日期 -
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
為了突出與 SQL 的相似性，我們在 AQL 中提供了一個巢狀的 FOR 迴圈查詢，從而進行 REPLACE 操作，首先在內部迴圈中迭代所有作曲家的出生日期，然後迭代所有相關的歌曲，建立一個包含屬性song_with_composer_key（而不是song 屬性）的新文件。
以下是查詢 -
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
現在讓我們再次執行查詢FOR song IN songs RETURN song 以檢視歌曲集合是如何變化的。
輸出
[
{
"_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"
}
]
上面的查詢完成了資料遷移過程，將composer_key 新增到每首歌曲中。
現在下一個查詢仍然是一個巢狀的 FOR 迴圈查詢，但這次是進行連線操作，將相關的作曲家姓名（使用 `composer_key` 選擇）新增到每首歌曲中 -
FOR s IN songs
FOR c IN composer_dob
FILTER c._key == s.composer_key
RETURN MERGE(s,
{ composer: c.composer }
)
輸出
[
{
"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"
}
]
ArangoDB - AQL 示例查詢
在本章中，我們將考慮一些關於演員和電影資料庫的 AQL 示例查詢。這些查詢基於圖。
問題
給定一個演員集合和一個電影集合，以及一個 actIn 邊集合（帶有一個 year 屬性）來連線頂點，如下所示 -
[演員] <- act in -> [電影]
我們如何獲得 -
- 所有在“電影1”或“電影2”中演出的演員？
- 所有同時在“電影1”和“電影2”中演出的演員？
- “演員1”和“演員2”之間所有共同出演的電影？
- 所有出演 3 部或更多電影的演員？
- 所有恰好有 6 位演員出演的電影？
- 按電影劃分的演員人數？
- 按演員劃分的電影數量？
- 2005 年到 2010 年間演員出演的電影數量？
解決方案
在解決並獲得上述查詢答案的過程中，我們將使用 Arangosh 建立資料集並在其上執行查詢。所有 AQL 查詢都是字串，可以簡單地複製到您喜歡的驅動程式（而不是 Arangosh）中。
讓我們從在 Arangosh 中建立測試資料集開始。首先，下載此檔案 -
# wget -O dataset.js https://drive.google.com/file/d/0B4WLtBDZu_QWMWZYZ3pYMEdqajA/view?usp=sharing
輸出
... 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]
您可以在上面的輸出中看到我們下載了一個 JavaScript 檔案dataset.js。此檔案包含在資料庫中建立資料集的 Arangosh 命令。我們不會逐個複製貼上命令，而是將使用 Arangosh 上的--javascript.execute 選項以非互動方式執行多個命令。認為它是救命命令！
現在在shell上執行以下命令：
$ arangosh --javascript.execute dataset.js
出現提示時輸入密碼，如上圖所示。現在我們已經儲存了資料，我們將構建AQL查詢來回答本章開頭提出的具體問題。
第一個問題
讓我們來看第一個問題：**所有在“movie1”或“movie2”中演出的演員**。假設，我們想找到所有在“The Matrix”或“The Devil's Advocate”中演出的演員的姓名：
我們將一次處理一部電影，以獲取演員的姓名：
127.0.0.1:8529@_system> db._query("FOR x IN ANY 'movies/TheMatrix' actsIn
OPTIONS {bfs: true, uniqueVertices: 'global'} RETURN x._id").toArray();
輸出
我們將收到以下輸出：
[ "actors/Hugo", "actors/Emil", "actors/Carrie", "actors/Keanu", "actors/Laurence" ]
現在我們繼續形成兩個NEIGHBORS查詢的UNION_DISTINCT，這將是解決方案：
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();
輸出
[ "actors/Charlize", "actors/Al", "actors/Laurence", "actors/Keanu", "actors/Carrie", "actors/Emil", "actors/Hugo" ]
第二個問題
現在讓我們考慮第二個問題：**所有同時在“movie1”和“movie2”中演出的演員**。這與上述問題幾乎相同。但這次我們不感興趣的是UNION，而是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();
輸出
我們將收到以下輸出：
[ "actors/Keanu" ]
第三個問題
現在讓我們考慮第三個問題：**“actor1”和“actor2”共同出演的所有電影**。這實際上與movie1和movie2中共同演員的問題相同。我們只需要更改起始頂點。例如，讓我們找到Hugo Weaving（“Hugo”）和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();
輸出
我們將收到以下輸出：
[ "movies/TheMatrixReloaded", "movies/TheMatrixRevolutions", "movies/TheMatrix" ]
第四個問題
現在讓我們考慮第四個問題。**出演3部或更多電影的所有演員**。這個問題不同；我們在這裡不能使用neighbors函式。相反，我們將使用AQL的edge-index和COLLECT語句進行分組。基本思想是按其**startVertex**（在此資料集中始終為演員）對所有邊進行分組。然後，我們從結果中刪除所有出演少於3部電影的演員，因為這裡我們包含了演員出演電影的數量：
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()
輸出
[
{
"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
}
]
對於其餘的問題，我們將討論查詢的構成，並且僅提供查詢。讀者應該自己在Arangosh終端上執行查詢。
第五個問題
現在讓我們考慮第五個問題：**恰好有6名演員出演的所有電影**。與之前的查詢相同，但使用相等過濾器。但是，現在我們需要電影而不是演員，所以我們返回**_to屬性**：
db._query("FOR x IN actsIn COLLECT movie = x._to WITH COUNT INTO counter FILTER
counter == 6 RETURN movie").toArray()
按電影劃分的演員人數？
我們記得在我們的資料集中，邊上的**_to**對應於電影，所以我們計算相同的**_to**出現的次數。這就是演員的數量。該查詢與之前的查詢幾乎相同，但**COLLECT之後沒有FILTER**：
db._query("FOR x IN actsIn COLLECT movie = x._to WITH COUNT INTO counter RETURN
{movie: movie, actors: counter}").toArray()
第六個問題
現在讓我們考慮第六個問題：**演員出演的電影數量。**
我們找到上述查詢解決方案的方法也將幫助您找到此查詢的解決方案。
db._query("FOR x IN actsIn COLLECT actor = x._from WITH COUNT INTO counter
RETURN {actor: actor, movies: counter}").toArray()
ArangoDB - 如何部署
在本章中，我們將描述部署ArangoDB的各種可能性。
部署：單例項
我們已經在之前的章節中學習瞭如何在Linux（Ubuntu）上部署單例項。現在讓我們看看如何使用Docker進行部署。
部署：Docker
對於使用docker進行部署，我們將在我們的機器上安裝Docker。有關Docker的更多資訊，請參考我們的教程Docker。
安裝Docker後，您可以使用以下命令：
docker run -e ARANGO_RANDOM_ROOT_PASSWORD = 1 -d --name agdb-foo -d arangodb/arangodb
它將建立一個ArangoDB的Docker例項，並將其作為Docker後臺程序啟動，標識名稱為**agdbfoo**。
終端也會列印程序識別符號。
預設情況下，埠8529保留用於ArangoDB監聽請求。此埠也自動可用於您可能已連結的所有Docker應用程式容器。