Variation5.QDSL.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Compiling /home/juanshac/Documents/tagless-final-tutorial/common.sc"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\u001b[32mimport \u001b[39m\u001b[36m$file.$     \n",
       "\u001b[39m\n",
       "\u001b[32mimport \u001b[39m\u001b[36mcommon._, dc._\n",
       "\u001b[39m\n",
       "\u001b[32mimport \u001b[39m\u001b[36mdoobie.implicits._\u001b[39m"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import $file.common\n",
    "import common._, dc._\n",
    "import doobie.implicits._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variation 5. Quoted DSLs: Quill"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is an all completely different approach to our problem, based on so-called Quoted DSLs. Unlike MTL, Quoted DSLs don't build upon custom syntax declared through APIs but upon the host language AST (Abstract Syntax Tree, i.e. the Scala syntax itself). And semantics is not given through API instances but through AST transformations, i.e. macros. The application of Quoted DSLs to Language-Integrated Query was one of the key features of the following [paper](http://homepages.inf.ed.ac.uk/slindley/papers/practical-theory-of-linq.pdf): "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](images/practicalLinq.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This paper explains how to solve the _avalanche_ query problem through a set of rewriting rules over the original query. The Scala library `quill` put this idea into practice. From the user point of view, a data model in `quill` is programmed through a flat model of case classes: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mclass\u001b[39m \u001b[36mCountry\u001b[39m\n",
       "defined \u001b[32mclass\u001b[39m \u001b[36mCity\u001b[39m"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "case class Country(\n",
    "    code: String, \n",
    "    name: String, \n",
    "    capital: Option[Int])\n",
    "\n",
    "case class City(\n",
    "    id: Int, \n",
    "    name: String, \n",
    "    countryCode: String, \n",
    "    population: Int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, queries are written using common Scala for-comprehensions. In our case:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[36mlargeCapitals\u001b[39m: \u001b[32mAnyRef\u001b[39m with \u001b[32mQuoted\u001b[39m[\u001b[32mQuery\u001b[39m[(\u001b[32mString\u001b[39m, \u001b[32mString\u001b[39m)]]{def quoted: io.getquill.ast.FlatMap;def ast: io.getquill.ast.FlatMap;def id586702505(): Unit;val liftings: Object} = querySchema(\"Country\").flatMap(country => querySchema(\"City\").filter(city => country.capital.exists((x1) => x1 == city.id)).filter(city => city.population > 8000000).map(city => (country.name, city.name)))"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "val largeCapitals = quote { \n",
    "    for {\n",
    "        country <- query[Country] \n",
    "        city <- query[City] \n",
    "        if country.capital.exists(_ == city.id) \n",
    "        if city.population > 8000000\n",
    "    } yield (country.name, city.name) \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the query is written exactly in the same way as we would write it using inmutable data structures and higher-order functions (disguised as for-comprehensions). But this query is embedded in a `quote` block, so what we are actually building is a generic query, which works for the different compilation targets of `quill`: currently, SQL and Cassandra QL. The SQL target actually supports doobie, so that we can execute the `quill` query using a _doobie context_ `dc` as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cmd3.sc:1: SELECT country.name, city.name FROM Country country, City city WHERE country.capital = city.id AND city.population > 8000000\n",
      "val res3 = dc.run(largeCapitals).transact(xa).unsafeRunSync\n",
      "                 ^"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\u001b[36mres3\u001b[39m: \u001b[32mList\u001b[39m[(\u001b[32mString\u001b[39m, \u001b[32mString\u001b[39m)] = \u001b[33mList\u001b[39m(\n",
       "  (\u001b[32m\"Indonesia\"\u001b[39m, \u001b[32m\"Jakarta\"\u001b[39m),\n",
       "  (\u001b[32m\"South Korea\"\u001b[39m, \u001b[32m\"Seoul\"\u001b[39m),\n",
       "  (\u001b[32m\"Mexico\"\u001b[39m, \u001b[32m\"Ciudad de M\\u00e9xico\"\u001b[39m),\n",
       "  (\u001b[32m\"Russian Federation\"\u001b[39m, \u001b[32m\"Moscow\"\u001b[39m)\n",
       ")"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dc.run(largeCapitals)\n",
    "    .transact(xa)\n",
    "    .unsafeRunSync"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The quill-to-doobie compiler shows us the generated SQL query, which, as you can see, is optimal! As we told you, this is thanks to the complex rewriting machinery of the Scala AST, which is performed through macros. Can we get rid of macros, somehow? With the [tagless-final approach](Variation6a.QUEΛ.ipynb), yes, we can!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Scala",
   "language": "scala",
   "name": "scala"
  },
  "language_info": {
   "codemirror_mode": "text/x-scala",
   "file_extension": ".scala",
   "mimetype": "text/x-scala",
   "name": "scala",
   "nbconvert_exporter": "script",
   "version": "2.13.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}