tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setup Dgraph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tutorial uses [dgraph via `docker-compose`](https://docs.dgraph.io/get-started/#docker-compose). It assumes you have already installed [docker](https://docs.docker.com/v17.09/engine/installation/) and [docker-compose](https://docs.docker.com/compose/install/) on the same machine as jupyter. What follows is a whirlwind demonstration that follows a subset tiny projection dgraph's [Tour of Dgraph: A Bigger Dataset](https://tour.dgraph.io/moredata/1/). I've set `--lru_mb=4096` instead of `2048` on the `alpha` server since the tour suggests it's often needed for a dataset of this size."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create the `docker-compose.yml`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The downloaded data and artifacts will go to `tutorial_artifacts` to keep your working directory legible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "!mkdir -p tutorial_artifacts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I've named the containers `dgraph_zero`, `dgraph_server`, and `dgraph_ratel` in the `docker-compose.yml` file. This makes data injestion more straight-forward."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing tutorial_artifacts/docker-compose.yml\n"
     ]
    }
   ],
   "source": [
    "%%writefile tutorial_artifacts/docker-compose.yml\n",
    "version: \"3.2\"\n",
    "services:\n",
    "  zero:\n",
    "    image: dgraph/dgraph:latest\n",
    "    container_name: \"dgraph_zero\"\n",
    "    volumes:\n",
    "      - type: volume\n",
    "        source: dgraph\n",
    "        target: /dgraph\n",
    "        volume:\n",
    "          nocopy: true\n",
    "    ports:\n",
    "      - 5080:5080\n",
    "      - 6080:6080\n",
    "    restart: on-failure\n",
    "    command: dgraph zero --my=zero:5080\n",
    "  server:\n",
    "    container_name: \"dgraph_server\"\n",
    "    image: dgraph/dgraph:latest\n",
    "    volumes:\n",
    "      - type: volume\n",
    "        source: dgraph\n",
    "        target: /dgraph\n",
    "        volume:\n",
    "          nocopy: true\n",
    "    ports:\n",
    "      - 8080:8080\n",
    "      - 9080:9080\n",
    "    restart: on-failure\n",
    "    command: dgraph alpha --my=server:7080 --lru_mb=4096 --zero=zero:5080\n",
    "  ratel:\n",
    "    container_name: \"dgraph_ratel\"\n",
    "    image: dgraph/dgraph:latest\n",
    "    volumes:\n",
    "      - type: volume\n",
    "        source: dgraph\n",
    "        target: /dgraph\n",
    "        volume:\n",
    "          nocopy: true\n",
    "    ports:\n",
    "      - 8000:8000\n",
    "    command: dgraph-ratel\n",
    "\n",
    "volumes:\n",
    "  dgraph:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Start Dgraph\n",
    "\n",
    "With the `docker-compose.yml` file written, it's now possible to start `dgraph`.\n",
    "\n",
    "(You'll probably have to verify successful start in your terminal with `docker ps`. Terminal output rewriting breaks in jupyter output cells.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating network \"tutorial_artifacts_default\" with the default driver\n",
      "Creating dgraph_ratel ... \n",
      "Creating dgraph_server ... \n",
      "Creating dgraph_zero   ... \n",
      "\u001b[2Bting dgraph_server ... \u001b[32mdone\u001b[0m\u001b[1A\u001b[2K\u001b[2A\u001b[2K"
     ]
    }
   ],
   "source": [
    "!docker-compose -f tutorial_artifacts/docker-compose.yml up -d "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Get the Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "!wget \"https://github.com/dgraph-io/tutorial/blob/master/resources/1million.rdf.gz?raw=true\" --no-clobber -O tutorial_artifacts/1million.rdf.gz -q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext idgraph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following command will delete existing data from dgraph. If this is your first run, you won't have any. And, if this isn't your first run, you may not want to delete your data. The `--skip` argument to the cell magic skips execution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Execution skipped. Remove `--skip` flag to execute."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%dgraph --alter --json --skip\n",
    "{\n",
    "    \"drop_all\": true\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following alters graph database."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "```json\n",
       "{\n",
       "    \"code\": \"Success\",\n",
       "    \"message\": \"Done\"\n",
       "}\n",
       "```\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%dgraph --alter\n",
    "\n",
    "# Define Directives and index\n",
    "director.film: [uid] @reverse .\n",
    "genre: [uid] @reverse .\n",
    "initial_release_date: dateTime @index(year) .\n",
    "name: string @index(exact, term) @lang ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For a variety of reasons, people have had trouble with loading the tour data. It's easy to end up with error messages like,\n",
    "\n",
    "> While trying to setup connection to Dgraph server.  \n",
    "> error: context deadline exceeded\n",
    "\n",
    "\n",
    "As [Pawan Rawal's suggestion](https://discuss.dgraph.io/t/cant-execute-tour-part-a-bigger-dataset/2267/9), using `docker cp` makes it easier. The following,\n",
    "\n",
    "1. Copies the data to the server container;\n",
    "2. Runs the injestor;\n",
    "3. Deletes the data on the server container."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Decoder]: Using assembly version of decoder\n",
      "I1020 20:42:40.707381      27 init.go:98] \n",
      "\n",
      "Dgraph version   : v1.1.0\n",
      "Dgraph SHA-256   : 7d4294a80f74692695467e2cf17f74648c18087ed7057d798f40e1d3a31d2095\n",
      "Commit SHA-1     : ef7cdb28\n",
      "Commit timestamp : 2019-09-04 00:12:51 -0700\n",
      "Branch           : HEAD\n",
      "Go version       : go1.12.7\n",
      "\n",
      "For Dgraph official documentation, visit https://docs.dgraph.io.\n",
      "For discussions about Dgraph     , visit https://discuss.dgraph.io.\n",
      "To say hi to the community       , visit https://dgraph.slack.com.\n",
      "\n",
      "Licensed variously under the Apache Public License 2.0 and Dgraph Community License.\n",
      "Copyright 2015-2018 Dgraph Labs, Inc.\n",
      "\n",
      "\n",
      "\n",
      "Running transaction with dgraph endpoint: dgraph_server:9080\n",
      "Found 1 data file(s) to process\n",
      "Processing data file \"1million.rdf.gz\"\n",
      "[20:42:45Z] Elapsed: 05s Txns: 34 N-Quads: 34000 N-Quads/s [last 5s]:  6800 Aborts: 0\n",
      "[20:42:50Z] Elapsed: 10s Txns: 70 N-Quads: 70000 N-Quads/s [last 5s]:  7200 Aborts: 0\n",
      "[20:42:55Z] Elapsed: 15s Txns: 173 N-Quads: 173000 N-Quads/s [last 5s]: 20600 Aborts: 0\n",
      "[20:43:00Z] Elapsed: 20s Txns: 283 N-Quads: 283000 N-Quads/s [last 5s]: 22000 Aborts: 0\n",
      "[20:43:05Z] Elapsed: 25s Txns: 395 N-Quads: 395000 N-Quads/s [last 5s]: 22400 Aborts: 0\n",
      "[20:43:10Z] Elapsed: 30s Txns: 498 N-Quads: 498000 N-Quads/s [last 5s]: 20600 Aborts: 0\n",
      "[20:43:15Z] Elapsed: 35s Txns: 610 N-Quads: 610000 N-Quads/s [last 5s]: 22400 Aborts: 0\n",
      "[20:43:20Z] Elapsed: 40s Txns: 718 N-Quads: 718000 N-Quads/s [last 5s]: 21600 Aborts: 0\n",
      "[20:43:25Z] Elapsed: 45s Txns: 830 N-Quads: 830000 N-Quads/s [last 5s]: 22400 Aborts: 0\n",
      "[20:43:30Z] Elapsed: 50s Txns: 914 N-Quads: 914000 N-Quads/s [last 5s]: 16800 Aborts: 0\n",
      "[20:43:35Z] Elapsed: 55s Txns: 985 N-Quads: 985000 N-Quads/s [last 5s]: 14200 Aborts: 0\n",
      "Number of TXs run            : 1042                                                                 \n",
      "Number of N-Quads processed  : 1041684\n",
      "Time spent                   : 59.563371303s\n",
      "N-Quads processed per second : 17655\n"
     ]
    }
   ],
   "source": [
    "!docker cp ./tutorial_artifacts/1million.rdf.gz dgraph_server:/dgraph\n",
    "!docker exec -it dgraph_server dgraph live -f 1million.rdf.gz --alpha dgraph_server:9080 --zero dgraph_zero:5080 -c 1\n",
    "!docker exec -it dgraph_server rm /dgraph/1million.rdf.gz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following adds types,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "```json\n",
       "{\n",
       "    \"code\": \"Success\",\n",
       "    \"message\": \"Done\"\n",
       "}\n",
       "```\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%dgraph --alter\n",
    "# Define Types\n",
    "\n",
    "type Person {\n",
    "    name: string\n",
    "    director.film: [Movie]\n",
    "}\n",
    "\n",
    "type Movie {\n",
    "    name: string\n",
    "    initial_release_date: string\n",
    "    genre: [Genre]\n",
    "    starring: [Performance]\n",
    "}\n",
    "\n",
    "type Genre {\n",
    "    name: string\n",
    "}\n",
    "\n",
    "type Performance {\n",
    "    performance.film: [Movie]\n",
    "    performance.character_note: string\n",
    "    performance.character: [Person]\n",
    "    performance.actor: [Person]\n",
    "    performance.special_performance_type: [Special_performance_type]\n",
    "    type: [Generic]\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, it's possible to execute queries!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "```json\n",
       "{\n",
       "    \"hanks\": [\n",
       "        {\n",
       "            \"uid\": \"0xcbcefccffb9eb400\",\n",
       "            \"name@.\": \"Tom Hanks\",\n",
       "            \"director.film\": [\n",
       "                {\n",
       "                    \"initial_release_date\": \"1996-09-14T00:00:00Z\",\n",
       "                    \"name@en\": \"That Thing You Do!\",\n",
       "                    \"name@it\": \"Music Graffiti\",\n",
       "                    \"name@de\": \"That Thing You Do!\"\n",
       "                },\n",
       "                {\n",
       "                    \"initial_release_date\": \"2011-06-27T00:00:00Z\",\n",
       "                    \"name@en\": \"Larry Crowne\",\n",
       "                    \"name@it\": \"L'amore all'improvviso - Larry Crowne\",\n",
       "                    \"name@de\": \"Larry Crowne\"\n",
       "                }\n",
       "            ]\n",
       "        }\n",
       "    ]\n",
       "}\n",
       "```\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%dgraph \n",
    "{\n",
    "    hanks(func: eq(name@., \"Tom Hanks\")) {\n",
    "        uid\n",
    "        name@.\n",
    "        director.film {\n",
    "            expand(_all_)\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output shows only the contents of the value associated with the `data` key by default. But, if you use the `--full-resp` flag, you'll get the full envelope."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "```json\n",
       "{\n",
       "    \"data\": {\n",
       "        \"hanks\": [\n",
       "            {\n",
       "                \"uid\": \"0xcbcefccffb9eb400\",\n",
       "                \"name@.\": \"Tom Hanks\",\n",
       "                \"director.film\": [\n",
       "                    {\n",
       "                        \"name@en\": \"That Thing You Do!\",\n",
       "                        \"name@it\": \"Music Graffiti\",\n",
       "                        \"name@de\": \"That Thing You Do!\",\n",
       "                        \"initial_release_date\": \"1996-09-14T00:00:00Z\"\n",
       "                    },\n",
       "                    {\n",
       "                        \"name@en\": \"Larry Crowne\",\n",
       "                        \"name@it\": \"L'amore all'improvviso - Larry Crowne\",\n",
       "                        \"name@de\": \"Larry Crowne\",\n",
       "                        \"initial_release_date\": \"2011-06-27T00:00:00Z\"\n",
       "                    }\n",
       "                ]\n",
       "            }\n",
       "        ]\n",
       "    },\n",
       "    \"extensions\": {\n",
       "        \"server_latency\": {\n",
       "            \"parsing_ns\": 37163,\n",
       "            \"processing_ns\": 4289874,\n",
       "            \"encoding_ns\": 157920,\n",
       "            \"assign_timestamp_ns\": 847628\n",
       "        },\n",
       "        \"txn\": {\n",
       "            \"start_ts\": 82088\n",
       "        }\n",
       "    }\n",
       "}\n",
       "```\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%dgraph --full-resp\n",
    "{\n",
    "    hanks(func: eq(name@., \"Tom Hanks\")) {\n",
    "        uid\n",
    "        name@.\n",
    "        director.film {\n",
    "            expand(_all_)\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I really enjoy [`jmespath`](http://jmespath.org/). You can use the `--jmespath` flag to extract a specific part of the response."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "```json\n",
       "\"0xcbcefccffb9eb400\"\n",
       "```\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%dgraph --jmespath=\"data.hanks[0].uid\"\n",
    "{\n",
    "    hanks(func: eq(name@., \"Tom Hanks\")) {\n",
    "        uid\n",
    "        name@.\n",
    "        director.film {\n",
    "            expand(_all_)\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For all queries, the extracted part is automatically bound to `_dgraph`, sorta following what you'd expect with `_` in IPython,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0xcbcefccffb9eb400'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_dgraph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And the full query is bound to `_dgraph_full`,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'data': {'hanks': [{'uid': '0xcbcefccffb9eb400',\n",
       "    'name@.': 'Tom Hanks',\n",
       "    'director.film': [{'name@en': 'That Thing You Do!',\n",
       "      'name@it': 'Music Graffiti',\n",
       "      'name@de': 'That Thing You Do!',\n",
       "      'initial_release_date': '1996-09-14T00:00:00Z'},\n",
       "     {'name@en': 'Larry Crowne',\n",
       "      'name@it': \"L'amore all'improvviso - Larry Crowne\",\n",
       "      'name@de': 'Larry Crowne',\n",
       "      'initial_release_date': '2011-06-27T00:00:00Z'}]}]},\n",
       " 'extensions': {'server_latency': {'parsing_ns': 21679,\n",
       "   'processing_ns': 3189200,\n",
       "   'encoding_ns': 119247,\n",
       "   'assign_timestamp_ns': 626255},\n",
       "  'txn': {'start_ts': 82089}}}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_dgraph_full"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can change the binding variable by specifying the `--into` flag."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "```json\n",
       "{\n",
       "    \"uid\": \"0xc96d2ccebd5f961a\",\n",
       "    \"name@en\": \"Jean-Pierre Jeunet\",\n",
       "    \"director.film\": [\n",
       "        {\n",
       "            \"names\": \"Delicatessen\"\n",
       "        },\n",
       "        {\n",
       "            \"names\": \"A Very Long Engagement\"\n",
       "        },\n",
       "        {\n",
       "            \"names\": \"Micmacs\"\n",
       "        },\n",
       "        {\n",
       "            \"names\": \"The Young and Prodigious Spivet\"\n",
       "        },\n",
       "        {\n",
       "            \"names\": \"Am\\u00e9lie\"\n",
       "        },\n",
       "        {\n",
       "            \"names\": \"The City of Lost Children\"\n",
       "        },\n",
       "        {\n",
       "            \"names\": \"Things I Like, Things I Don't Like\"\n",
       "        },\n",
       "        {\n",
       "            \"names\": \"Alien: Resurrection\"\n",
       "        }\n",
       "    ]\n",
       "}\n",
       "```\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%dgraph --into='jeunet' --jmespath=\"data.jeunet[0]\"\n",
    "{\n",
    "    jeunet(func: allofterms(name@en, \"Jean-Pierre Jeunet\")) {\n",
    "        uid\n",
    "        name@en\n",
    "        director.film {\n",
    "            names: name@en\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, it's in `jeunet`,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'uid': '0xc96d2ccebd5f961a',\n",
       " 'name@en': 'Jean-Pierre Jeunet',\n",
       " 'director.film': [{'names': 'Delicatessen'},\n",
       "  {'names': 'A Very Long Engagement'},\n",
       "  {'names': 'Micmacs'},\n",
       "  {'names': 'The Young and Prodigious Spivet'},\n",
       "  {'names': 'Amélie'},\n",
       "  {'names': 'The City of Lost Children'},\n",
       "  {'names': \"Things I Like, Things I Don't Like\"},\n",
       "  {'names': 'Alien: Resurrection'}]}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "jeunet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the full response in `jeunet_full`,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'data': {'jeunet': [{'uid': '0xc96d2ccebd5f961a',\n",
       "    'name@en': 'Jean-Pierre Jeunet',\n",
       "    'director.film': [{'names': 'Delicatessen'},\n",
       "     {'names': 'A Very Long Engagement'},\n",
       "     {'names': 'Micmacs'},\n",
       "     {'names': 'The Young and Prodigious Spivet'},\n",
       "     {'names': 'Amélie'},\n",
       "     {'names': 'The City of Lost Children'},\n",
       "     {'names': \"Things I Like, Things I Don't Like\"},\n",
       "     {'names': 'Alien: Resurrection'}]}]},\n",
       " 'extensions': {'server_latency': {'parsing_ns': 25980,\n",
       "   'processing_ns': 27678541,\n",
       "   'encoding_ns': 28621,\n",
       "   'assign_timestamp_ns': 568283},\n",
       "  'txn': {'start_ts': 82090}}}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "jeunet_full"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also interpret the command to execute as a [`jinja` templating](https://palletsprojects.com/p/jinja/) with the `--as-jinja` flag. Generally, *you don't want to do this too much*, since you should probably be crafting better graphql+- queries, but it's occasionally useful. Before sending, it's often helpful to use the `--print-jinja` flag to see what's going to get sent. Interpolation escaping works with ``<<variable>>`` bound to the user namespace (instead of ``{{variable}}``). Blocks work with `<% block %>`. (The jinja environment uses the cwd, so it's technically possible to load parent templates, but I *really* don't think you should.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "```text\n",
       "{\n",
       "    templated_query(func: uid(\"0xc96d2ccebd5f961a\")) {\n",
       "        name@en\n",
       "    }\n",
       "}\n",
       "```\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%dgraph --as-jinja --print-jinja\n",
    "{\n",
    "    templated_query(func: uid(\"<<jeunet.uid>>\")) {\n",
    "    <%- if True %>\n",
    "        name@en\n",
    "    <%- endif %>\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Having inspected the interpolated query, I feel secure sending it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "```json\n",
       "{\n",
       "    \"templated_query\": [\n",
       "        {\n",
       "            \"name@en\": \"Jean-Pierre Jeunet\"\n",
       "        }\n",
       "    ]\n",
       "}\n",
       "```\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%dgraph --as-jinja\n",
    "{\n",
    "    templated_query(func: uid(\"<<jeunet.uid>>\")) {\n",
    "        name@en\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that I'm done showing off, I'll take the server down."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping dgraph_zero   ... \n",
      "Stopping dgraph_server ... \n",
      "Stopping dgraph_ratel  ... \n",
      "\u001b[3Bping dgraph_zero   ... \u001b[32mdone\u001b[0m\u001b[2A\u001b[2KRemoving dgraph_zero   ... \n",
      "Removing dgraph_server ... \n",
      "Removing dgraph_ratel  ... \n",
      "\u001b[3BRemoving network tutorial_artifacts_default\n"
     ]
    }
   ],
   "source": [
    "!docker-compose -f tutorial_artifacts/docker-compose.yml down"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's it! Check out `dgraph`'s [online documentation](https://docs.dgraph.io/) for a lot more information. And, if this was useful, [please give me a star on github](https://github.com/jbn/idgraph) or [a shout out on twitter](https://twitter.com/generativist), or both :)"
   ]
  }
 ],
 "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}