AqlPart2Tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![arangodb](img/ArangoDB_logo.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# AQL Tutorial Part 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://colab.research.google.com/github/joerg84/ArangoDBUniversity/blob/master/AqlPart2Tutorial.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the [first part of this tutorial](https://colab.research.google.com/github/joerg84/ArangoDBUniversity/blob/master/AqlCrudTutorial.ipynb) we have looked at basic CRUD queries. In this second part, we will look at some more advanced AQL features:\n",
    "\n",
    "* Filtering \n",
    "* Sorting\n",
    "* Limiting\n",
    "\n",
    "\n",
    "Recall, that in addition to the python interface, you can interact with ArangoDB using its web interface to manage collections and execute the queries."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setup "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before getting started with ArangoDB we need to prepare our environment and create a temporary database on ArangoDB's managed Service Oasis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "!git clone https://github.com/joerg84/ArangoDBUniversity.git\n",
    "!rsync -av ArangoDBUniversity/ ./ --exclude=.git\n",
    "!pip3 install pyarango\n",
    "!pip3 install \"python-arango>=5.0\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import requests\n",
    "import sys\n",
    "import oasis\n",
    "import time\n",
    "\n",
    "from pyArango.connection import *\n",
    "from arango import ArangoClient"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the temporary database:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Retrieve tmp credentials from ArangoDB Tutorial Service\n",
    "login = oasis.getTempCredentials(tutorialName=\"AqlPart2Tutorial\", credentialProvider='https://tutorials.arangodb.cloud:8529/_db/_system/tutorialDB/tutorialDB')\n",
    "\n",
    "# Connect to the temp database\n",
    "conn = oasis.connect(login)\n",
    "db = conn[login[\"dbName\"]] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"https://{}:{}\".format(login[\"hostname\"], login[\"port\"]))\n",
    "print(\"Username: \" + login[\"username\"])\n",
    "print(\"Password: \" + login[\"password\"])\n",
    "print(\"Database: \" + login[\"dbName\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Feel free to use to above URL to checkout the UI!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Import Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will work with the same dataset as in the [first part of this tutorial](https://colab.research.google.com/github/joerg84/ArangoDBUniversity/blob/master/AqlCrudTutorial.ipynb). So let us quickly import that into our temporary database. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the Characters Collection \n",
    "db.createCollection(name=\"Characters\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "insert_query = \"\"\"\n",
    "LET data = [\n",
    "    { \"name\": \"Ned\", \"surname\": \"Stark\", \"alive\": true, \"age\": 41, \"traits\": [\"A\",\"H\",\"C\",\"N\",\"P\"] },\n",
    "    { \"name\": \"Robert\", \"surname\": \"Baratheon\", \"alive\": false, \"traits\": [\"A\",\"H\",\"C\"] },\n",
    "    { \"name\": \"Jaime\", \"surname\": \"Lannister\", \"alive\": true, \"age\": 36, \"traits\": [\"A\",\"F\",\"B\"] },\n",
    "    { \"name\": \"Catelyn\", \"surname\": \"Stark\", \"alive\": false, \"age\": 40, \"traits\": [\"D\",\"H\",\"C\"] },\n",
    "    { \"name\": \"Cersei\", \"surname\": \"Lannister\", \"alive\": true, \"age\": 36, \"traits\": [\"H\",\"E\",\"F\"] },\n",
    "    { \"name\": \"Daenerys\", \"surname\": \"Targaryen\", \"alive\": true, \"age\": 16, \"traits\": [\"D\",\"H\",\"C\"] },\n",
    "    { \"name\": \"Jorah\", \"surname\": \"Mormont\", \"alive\": false, \"traits\": [\"A\",\"B\",\"C\",\"F\"] },\n",
    "    { \"name\": \"Petyr\", \"surname\": \"Baelish\", \"alive\": false, \"traits\": [\"E\",\"G\",\"F\"] },\n",
    "    { \"name\": \"Viserys\", \"surname\": \"Targaryen\", \"alive\": false, \"traits\": [\"O\",\"L\",\"N\"] },\n",
    "    { \"name\": \"Jon\", \"surname\": \"Snow\", \"alive\": true, \"age\": 16, \"traits\": [\"A\",\"B\",\"C\",\"F\"] },\n",
    "    { \"name\": \"Sansa\", \"surname\": \"Stark\", \"alive\": true, \"age\": 13, \"traits\": [\"D\",\"I\",\"J\"] },\n",
    "    { \"name\": \"Arya\", \"surname\": \"Stark\", \"alive\": true, \"age\": 11, \"traits\": [\"C\",\"K\",\"L\"] },\n",
    "    { \"name\": \"Robb\", \"surname\": \"Stark\", \"alive\": false, \"traits\": [\"A\",\"B\",\"C\",\"K\"] },\n",
    "    { \"name\": \"Theon\", \"surname\": \"Greyjoy\", \"alive\": true, \"age\": 16, \"traits\": [\"E\",\"R\",\"K\"] },\n",
    "    { \"name\": \"Bran\", \"surname\": \"Stark\", \"alive\": true, \"age\": 10, \"traits\": [\"L\",\"J\"] },\n",
    "    { \"name\": \"Joffrey\", \"surname\": \"Baratheon\", \"alive\": false, \"age\": 19, \"traits\": [\"I\",\"L\",\"O\"] },\n",
    "    { \"name\": \"Sandor\", \"surname\": \"Clegane\", \"alive\": true, \"traits\": [\"A\",\"P\",\"K\",\"F\"] },\n",
    "    { \"name\": \"Tyrion\", \"surname\": \"Lannister\", \"alive\": true, \"age\": 32, \"traits\": [\"F\",\"K\",\"M\",\"N\"] },\n",
    "    { \"name\": \"Khal\", \"surname\": \"Drogo\", \"alive\": false, \"traits\": [\"A\",\"C\",\"O\",\"P\"] },\n",
    "    { \"name\": \"Tywin\", \"surname\": \"Lannister\", \"alive\": false, \"traits\": [\"O\",\"M\",\"H\",\"F\"] },\n",
    "    { \"name\": \"Davos\", \"surname\": \"Seaworth\", \"alive\": true, \"age\": 49, \"traits\": [\"C\",\"K\",\"P\",\"F\"] },\n",
    "    { \"name\": \"Samwell\", \"surname\": \"Tarly\", \"alive\": true, \"age\": 17, \"traits\": [\"C\",\"L\",\"I\"] },\n",
    "    { \"name\": \"Stannis\", \"surname\": \"Baratheon\", \"alive\": false, \"traits\": [\"H\",\"O\",\"P\",\"M\"] },\n",
    "    { \"name\": \"Melisandre\", \"alive\": true, \"traits\": [\"G\",\"E\",\"H\"] },\n",
    "    { \"name\": \"Margaery\", \"surname\": \"Tyrell\", \"alive\": false, \"traits\": [\"M\",\"D\",\"B\"] },\n",
    "    { \"name\": \"Jeor\", \"surname\": \"Mormont\", \"alive\": false, \"traits\": [\"C\",\"H\",\"M\",\"P\"] },\n",
    "    { \"name\": \"Bronn\", \"alive\": true, \"traits\": [\"K\",\"E\",\"C\"] },\n",
    "    { \"name\": \"Varys\", \"alive\": true, \"traits\": [\"M\",\"F\",\"N\",\"E\"] },\n",
    "    { \"name\": \"Shae\", \"alive\": false, \"traits\": [\"M\",\"D\",\"G\"] },\n",
    "    { \"name\": \"Talisa\", \"surname\": \"Maegyr\", \"alive\": false, \"traits\": [\"D\",\"C\",\"B\"] },\n",
    "    { \"name\": \"Gendry\", \"alive\": false, \"traits\": [\"K\",\"C\",\"A\"] },\n",
    "    { \"name\": \"Ygritte\", \"alive\": false, \"traits\": [\"A\",\"P\",\"K\"] },\n",
    "    { \"name\": \"Tormund\", \"surname\": \"Giantsbane\", \"alive\": true, \"traits\": [\"C\",\"P\",\"A\",\"I\"] },\n",
    "    { \"name\": \"Gilly\", \"alive\": true, \"traits\": [\"L\",\"J\"] },\n",
    "    { \"name\": \"Brienne\", \"surname\": \"Tarth\", \"alive\": true, \"age\": 32, \"traits\": [\"P\",\"C\",\"A\",\"K\"] },\n",
    "    { \"name\": \"Ramsay\", \"surname\": \"Bolton\", \"alive\": true, \"traits\": [\"E\",\"O\",\"G\",\"A\"] },\n",
    "    { \"name\": \"Ellaria\", \"surname\": \"Sand\", \"alive\": true, \"traits\": [\"P\",\"O\",\"A\",\"E\"] },\n",
    "    { \"name\": \"Daario\", \"surname\": \"Naharis\", \"alive\": true, \"traits\": [\"K\",\"P\",\"A\"] },\n",
    "    { \"name\": \"Missandei\", \"alive\": true, \"traits\": [\"D\",\"L\",\"C\",\"M\"] },\n",
    "    { \"name\": \"Tommen\", \"surname\": \"Baratheon\", \"alive\": true, \"traits\": [\"I\",\"L\",\"B\"] },\n",
    "    { \"name\": \"Jaqen\", \"surname\": \"H'ghar\", \"alive\": true, \"traits\": [\"H\",\"F\",\"K\"] },\n",
    "    { \"name\": \"Roose\", \"surname\": \"Bolton\", \"alive\": true, \"traits\": [\"H\",\"E\",\"F\",\"A\"] },\n",
    "    { \"name\": \"The High Sparrow\", \"alive\": true, \"traits\": [\"H\",\"M\",\"F\",\"O\"] }\n",
    "]\n",
    "\n",
    "FOR d IN data\n",
    "    INSERT d INTO Characters\n",
    "\"\"\"\n",
    "\n",
    "db.AQLQuery(insert_query)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As before let us check the `Characters` collection:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_characters_names = \"\"\"\n",
    "FOR c IN Characters\n",
    "    RETURN c.name\n",
    "\"\"\"\n",
    "\n",
    "query_result = db.AQLQuery(all_characters_names, rawResults=True)\n",
    "for doc in  query_result:\n",
    "    print(doc)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Filter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To find documents that fulfill certain criteria more complex than key equality, there is the FILTER operation in AQL, which enables us to formulate arbitrary conditions for documents to match.\n",
    "We actually have used a filter condition before to find `Ned`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "find_ned_query = \"\"\"\n",
    "FOR c IN Characters\n",
    "    FILTER c.name == \"Ned\"\n",
    "    RETURN c\n",
    "\"\"\"\n",
    "query_result = db.AQLQuery(find_ned_query, rawResults=True)\n",
    "for doc in  query_result:\n",
    "    print(doc)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The filter condition reads like: “the attribute name of a character document must be equal to the string Ned”. If the condition applies, character document gets returned. This works with any attribute likewise:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "find_ned_query = \"\"\"\n",
    "FOR c IN Characters\n",
    "    FILTER c.surname == \"Stark\"\n",
    "    RETURN c\n",
    "\"\"\"\n",
    "query_result = db.AQLQuery(find_ned_query, rawResults=True)\n",
    "for doc in  query_result:\n",
    "    print(doc)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Range conditions\n",
    "Strict equality is one possible condition we can state. There are plenty of other conditions we can formulate however. For example, we could ask for all young characters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "find_adults_query = \"\"\"\n",
    "FOR c IN Characters\n",
    "    FILTER c.age >= 13\n",
    "    RETURN c.name\n",
    "\"\"\"\n",
    "query_result = db.AQLQuery(find_adults_query, rawResults=True)\n",
    "for doc in  query_result:\n",
    "    print(doc)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The operator >= stands for greater-or-equal, so every character of age 13 or older is returned (only their name in the example). We can return names and age of all characters younger than 13 by changing the operator to less-than and using the object syntax to define a subset of attributes to return:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "find_young_query = \"\"\"\n",
    "FOR c IN Characters\n",
    "    FILTER c.age < 13\n",
    "    RETURN { name: c.name, age: c.age }\n",
    "\"\"\"\n",
    "query_result = db.AQLQuery(find_young_query, rawResults=True)\n",
    "for doc in  query_result:\n",
    "    print(doc)\n",
    "    print()   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may notice that it returns name and age of 30 characters, most with an age of null. The reason for this is, that null is the fallback value if an attribute is requested by the query, but no such attribute exists in the document, and the null is compares to numbers as lower (see [Type and value order](https://www.arangodb.com/docs/stable/aql/fundamentals-type-value-order.html)). Hence, it accidentally fulfills the age criterion c.age < 13 (null < 13). To not let documents pass the filter without an age attribute, we can add a second criterion:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "find_young_query = \"\"\"\n",
    "FOR c IN Characters\n",
    "    FILTER c.age < 13\n",
    "    FILTER c.age != null\n",
    "    RETURN { name: c.name, age: c.age }\n",
    "\"\"\"\n",
    "query_result = db.AQLQuery(find_young_query, rawResults=True)\n",
    "for doc in  query_result:\n",
    "    print(doc)\n",
    "    print()   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This could equally be written with a boolean AND operator as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "find_young_query = \"\"\"\n",
    "FOR c IN Characters\n",
    "    FILTER c.age < 13 AND c.age != null\n",
    "    RETURN { name: c.name, age: c.age }\n",
    "\"\"\"\n",
    "query_result = db.AQLQuery(find_young_query, rawResults=True)\n",
    "for doc in  query_result:\n",
    "    print(doc)\n",
    "    print()  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want documents to fulfill one or another condition, possibly for different attributes as well, use OR:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "find_joffrey_query = \"\"\"\n",
    "FOR c IN Characters\n",
    "    FILTER c.name == \"Jon\" OR c.name == \"Joffrey\"\n",
    "    RETURN { name: c.name, surname: c.surname }\n",
    "\"\"\"\n",
    "query_result = db.AQLQuery(find_joffrey_query, rawResults=True)\n",
    "for doc in  query_result:\n",
    "    print(doc)\n",
    "    print()  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To learn more about Filter Operation check the [documentation](https://www.arangodb.com/docs/stable/aql/operations-filter.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sorting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_characters_names = \"\"\"\n",
    "FOR c IN Characters\n",
    "    RETURN c.name\n",
    "\"\"\"\n",
    "\n",
    "query_result = db.AQLQuery(all_characters_names, rawResults=True)\n",
    "for doc in  query_result:\n",
    "    print(doc)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we recall the above query, the order in which records were returned by the queries shown until is basically random. To return them in a defined order, we can add a SORT() operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_characters_names = \"\"\"\n",
    "FOR c IN Characters\n",
    "    SORT c.name\n",
    "    RETURN c.name\n",
    "\"\"\"\n",
    "\n",
    "query_result = db.AQLQuery(all_characters_names, rawResults=True)\n",
    "for doc in  query_result:\n",
    "    print(doc)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See how it sorted by name, then returned the ten alphabetically first coming names. We can reverse the sort order with DESC like descending:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_characters_names = \"\"\"\n",
    "FOR c IN Characters\n",
    "    SORT c.name DESC\n",
    "    RETURN c.name\n",
    "\"\"\"\n",
    "\n",
    "query_result = db.AQLQuery(all_characters_names, rawResults=True)\n",
    "for doc in  query_result:\n",
    "    print(doc)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first sort was ascending, which is the default order. Because it is the default, it is not required to explicitly ask for ASC order."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sort by multiple attributes\n",
    "Assume we want to sort by surname. Many of the characters share a surname. The result order among characters with the same surname is undefined. We can first sort by surname, then name to determine the order:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_characters_names = \"\"\"\n",
    "FOR c IN Characters\n",
    "    FILTER c.surname\n",
    "    SORT c.surname, c.name\n",
    "    LIMIT 10\n",
    "    RETURN {\n",
    "        surname: c.surname,\n",
    "        name: c.name\n",
    "    }\n",
    "\"\"\"\n",
    "\n",
    "query_result = db.AQLQuery(all_characters_names, rawResults=True)\n",
    "for doc in  query_result:\n",
    "    print(doc)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Overall, the documents are sorted by last name. If the surname is the same for two characters, the name values are compared and the result sorted.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Limiting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It may not always be necessary to return all documents, that a FOR loop would normally return. In those cases, we can limit the amount of documents with a LIMIT() operation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_chars_query = \"\"\"\n",
    "FOR c IN Characters\n",
    "    SORT c.name\n",
    "    LIMIT 5\n",
    "    RETURN c.name\n",
    "\"\"\"\n",
    "query_result = db.AQLQuery(sample_chars_query, rawResults=True)\n",
    "for doc in  query_result:\n",
    "    print(doc)\n",
    "    print()  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "LIMIT is followed by a number for the maximum document count. There is a second syntax however, which allows you to skip a certain amount of record and return the next n documents:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_chars_query = \"\"\"\n",
    "FOR c IN Characters\n",
    "    SORT c.name\n",
    "    LIMIT 2, 5\n",
    "    RETURN c.name\n",
    "\"\"\"\n",
    "query_result = db.AQLQuery(sample_chars_query, rawResults=True)\n",
    "for doc in  query_result:\n",
    "    print(doc)\n",
    "    print()  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sort and Limit Combined"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The order can also be determined by a numeric value, such as the age:\n",
    "A filter is applied to avoid documents without age attribute. The remaining documents are sorted by age in ascending order, and the name and age of the ten youngest characters are returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_chars_query = \"\"\"\n",
    "FOR c IN Characters\n",
    "    FILTER c.age\n",
    "    SORT c.age\n",
    "    LIMIT 10\n",
    "    RETURN {\n",
    "        name: c.name,\n",
    "        age: c.age\n",
    "    }\n",
    "\"\"\"\n",
    "query_result = db.AQLQuery(sample_chars_query, rawResults=True)\n",
    "for doc in  query_result:\n",
    "    print(doc)\n",
    "    print()  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please, refer to the documentation for [SORT operation](https://www.arangodb.com/docs/stable/aql/operations-sort.html) and [LIMIT operation](https://www.arangodb.com/docs/stable/aql/operations-limit.html)  for more details.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Next Steps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To continue playing and working with ArangoDB beyond the temporary database, you can:\n",
    "\n",
    "* [Get a 2 week free Trial with the ArangoDB Cloud](https://cloud.arangodb.com/home?utm_source=AQLPart2&utm_medium=Github&utm_campaign=ArangoDB%20University)\n",
    "* [Download ArangoDB](https://www.arangodb.com/download-major/)\n",
    "* Keep Learning at thttps://www.arangodb.com/arangodb-training-center/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Further Links"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* https://www.arangodb.com/docs/stable/aql/tutorial.html"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}