Udacity_SQL_exercises.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d95dde93-aab2-4c02-9498-45028f2cd06a",
   "metadata": {},
   "source": [
    "Refer to Jupyter notes for more detail but to get the DB up and running start the db server:\n",
    "\n",
    "`pg_ctl -D ./SQLdb/db1 -l logfile start`\n",
    "\n",
    "May be necessary to change permissions on db1 to 0700 or 0750. See logs if problems starting server"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "41043f0e-9cba-429e-832d-e921d581df4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext sql"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3ef1717c-e660-4735-9984-394850189781",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Connected: @parchposey'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%sql postgresql://localhost/parchposey"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "85bab766-db32-4770-921f-960c65222c18",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(MySQLdb._exceptions.OperationalError) (1045, \"Access denied for user 'root'@'localhost' (using password: NO)\")\n",
      "(Background on this error at: https://sqlalche.me/e/14/e3q8)\n",
      "Connection info needed in SQLAlchemy format, example:\n",
      "               postgresql://username:password@hostname/dbname\n",
      "               or an existing connection: dict_keys(['postgresql://localhost/parchposey'])\n"
     ]
    }
   ],
   "source": [
    "%sql mysql://root:@localhost/bp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6dabeabd-7d60-4f0e-91e8-e180fa5ca472",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>version</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>PostgreSQL 12.2 on x86_64-pc-linux-gnu, compiled by x86_64-conda_cos6-linux-gnu-cc (crosstool-NG 1.23.0.449-a04d0) 7.3.0, 64-bit</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('PostgreSQL 12.2 on x86_64-pc-linux-gnu, compiled by x86_64-conda_cos6-linux-gnu-cc (crosstool-NG 1.23.0.449-a04d0) 7.3.0, 64-bit',)]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%sql select version()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a58ded76-ad9f-4ae8-ae9b-34429ae30e33",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SqlMagic(Magics, Configurable) options\n",
      "------------------------------------\n",
      "SqlMagic.autocommit=<Bool>\n",
      "    Set autocommit mode\n",
      "    Current: True\n",
      "SqlMagic.autolimit=<Int>\n",
      "    Automatically limit the size of the returned result sets\n",
      "    Current: 0\n",
      "SqlMagic.autopandas=<Bool>\n",
      "    Return Pandas DataFrames instead of regular result sets\n",
      "    Current: False\n",
      "SqlMagic.column_local_vars=<Bool>\n",
      "    Return data into local variables from column names\n",
      "    Current: False\n",
      "SqlMagic.displaylimit=<Int>\n",
      "    Automatically limit the number of rows displayed (full result set is still\n",
      "    stored)\n",
      "    Current: None\n",
      "SqlMagic.dsn_filename=<Unicode>\n",
      "    Path to DSN file. When the first argument is of the form [section], a\n",
      "    sqlalchemy connection string is formed from the matching section in the DSN\n",
      "    file.\n",
      "    Current: 'odbc.ini'\n",
      "SqlMagic.feedback=<Bool>\n",
      "    Print number of rows affected by DML\n",
      "    Current: True\n",
      "SqlMagic.short_errors=<Bool>\n",
      "    Don't display the full traceback on SQL Programming Error\n",
      "    Current: True\n",
      "SqlMagic.style=<Unicode>\n",
      "    Set the table printing style to any of prettytable's defined styles\n",
      "    (currently DEFAULT, MSWORD_FRIENDLY, PLAIN_COLUMNS, RANDOM)\n",
      "    Current: 'DEFAULT'\n"
     ]
    }
   ],
   "source": [
    "%config SqlMagic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "69a8f0de-a5c2-4094-a27c-b0045c7640e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "%config SqlMagic.autolimit=5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "373ad2bd-1c81-486d-8354-9bdab0c91a81",
   "metadata": {},
   "source": [
    "Provide a table for all web_events associated with account name of Walmart.There should be three columns. Be sure to include the primary_poc, time of the event, and the channel for each event. Additionally, you might choose to add a fourth column to assure only Walmart events were chosen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b8b82983-3dc9-42d5-abfd-2314f11b8639",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "39 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>primary_poc</th>\n",
       "            <th>occurred_at</th>\n",
       "            <th>channel</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Tamara Tuma</td>\n",
       "            <td>2015-10-06 17:13:58</td>\n",
       "            <td>direct</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Tamara Tuma</td>\n",
       "            <td>2015-11-05 03:08:26</td>\n",
       "            <td>direct</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Tamara Tuma</td>\n",
       "            <td>2015-12-04 03:57:24</td>\n",
       "            <td>direct</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Tamara Tuma</td>\n",
       "            <td>2016-01-02 00:55:03</td>\n",
       "            <td>direct</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Tamara Tuma</td>\n",
       "            <td>2016-02-01 19:02:33</td>\n",
       "            <td>direct</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Tamara Tuma', datetime.datetime(2015, 10, 6, 17, 13, 58), 'direct'),\n",
       " ('Tamara Tuma', datetime.datetime(2015, 11, 5, 3, 8, 26), 'direct'),\n",
       " ('Tamara Tuma', datetime.datetime(2015, 12, 4, 3, 57, 24), 'direct'),\n",
       " ('Tamara Tuma', datetime.datetime(2016, 1, 2, 0, 55, 3), 'direct'),\n",
       " ('Tamara Tuma', datetime.datetime(2016, 2, 1, 19, 2, 33), 'direct')]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT\n",
    "\ta.primary_poc,\n",
    "    w.occurred_at,\n",
    "    w.channel    \n",
    "FROM web_events w\n",
    "JOIN accounts a\n",
    "ON w.account_id = a.id\n",
    "WHERE a.name = 'Walmart'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cb995c2-d32d-4803-89d2-91d4e878c64b",
   "metadata": {},
   "source": [
    "Provide a table that provides the region for each sales_rep along with their associated accounts. Your final table should include three columns: the region name, the sales rep name, and the account name. Sort the accounts alphabetically (A-Z) according to account name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "5f183ce6-8b68-4fa1-bf47-afe413808915",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "351 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>region</th>\n",
       "            <th>rep</th>\n",
       "            <th>account</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>Sibyl Lauria</td>\n",
       "            <td>3M</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Midwest</td>\n",
       "            <td>Chau Rowles</td>\n",
       "            <td>Abbott Laboratories</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Midwest</td>\n",
       "            <td>Julie Starr</td>\n",
       "            <td>AbbVie</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Southeast</td>\n",
       "            <td>Earlie Schleusner</td>\n",
       "            <td>ADP</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>West</td>\n",
       "            <td>Marquetta Laycock</td>\n",
       "            <td>Advance Auto Parts</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Northeast', 'Sibyl Lauria', '3M'),\n",
       " ('Midwest', 'Chau Rowles', 'Abbott Laboratories'),\n",
       " ('Midwest', 'Julie Starr', 'AbbVie'),\n",
       " ('Southeast', 'Earlie Schleusner', 'ADP'),\n",
       " ('West', 'Marquetta Laycock', 'Advance Auto Parts')]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT r.name region, s.name rep, a.name account\n",
    "FROM sales_reps s\n",
    "JOIN region r\n",
    "ON s.region_id = r.id\n",
    "JOIN accounts a\n",
    "ON a.sales_rep_id = s.id\n",
    "ORDER BY a.name;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfe7221a-bafe-46ef-9b8a-ac8c19391718",
   "metadata": {},
   "source": [
    "Provide the name for each region for every order, as well as the account name and the unit price they paid (total_amt_usd/total) for the order. Your final table should have 3 columns: region name, account name, and unit price. A few accounts have 0 for total, so I divided by (total + 0.01) to assure not dividing by zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e8e809f6-0cef-4352-be73-88f9d5ba50eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "6912 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>region</th>\n",
       "            <th>account</th>\n",
       "            <th>unit_price</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>Walmart</td>\n",
       "            <td>5.7596000236672386</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>Walmart</td>\n",
       "            <td>5.9651748203187389</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>Walmart</td>\n",
       "            <td>5.8797060828725097</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>Walmart</td>\n",
       "            <td>5.4442361229475598</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>Walmart</td>\n",
       "            <td>5.9601842312587116</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Northeast', 'Walmart', Decimal('5.7596000236672386')),\n",
       " ('Northeast', 'Walmart', Decimal('5.9651748203187389')),\n",
       " ('Northeast', 'Walmart', Decimal('5.8797060828725097')),\n",
       " ('Northeast', 'Walmart', Decimal('5.4442361229475598')),\n",
       " ('Northeast', 'Walmart', Decimal('5.9601842312587116'))]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT r.name region, a.name account, (o.total_amt_usd/(o.total+0.01)) unit_price\n",
    "FROM orders o\n",
    "JOIN accounts a\n",
    "ON o.account_id = a.id\n",
    "JOIN sales_reps s\n",
    "ON a.sales_rep_id = s.id\n",
    "JOIN region r\n",
    "ON s.region_id = r.id"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2911dd7-effd-4cd4-b044-56bcbf155e0e",
   "metadata": {},
   "source": [
    "## Lesson 2: Quiz: Last Check\n",
    "\n",
    "1. Provide a table that provides the region for each sales_rep along with their associated accounts. This time only for the Midwest region. Your final table should include three columns: the region name, the sales rep name, and the account name. Sort the accounts alphabetically (A-Z) according to account name. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "907e9948-2260-481c-a82c-c017e96d1397",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "48 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>region</th>\n",
       "            <th>rep</th>\n",
       "            <th>account</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Midwest</td>\n",
       "            <td>Chau Rowles</td>\n",
       "            <td>Abbott Laboratories</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Midwest</td>\n",
       "            <td>Julie Starr</td>\n",
       "            <td>AbbVie</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Midwest</td>\n",
       "            <td>Cliff Meints</td>\n",
       "            <td>Aflac</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Midwest</td>\n",
       "            <td>Chau Rowles</td>\n",
       "            <td>Alcoa</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Midwest</td>\n",
       "            <td>Charles Bidwell</td>\n",
       "            <td>Altria Group</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Midwest', 'Chau Rowles', 'Abbott Laboratories'),\n",
       " ('Midwest', 'Julie Starr', 'AbbVie'),\n",
       " ('Midwest', 'Cliff Meints', 'Aflac'),\n",
       " ('Midwest', 'Chau Rowles', 'Alcoa'),\n",
       " ('Midwest', 'Charles Bidwell', 'Altria Group')]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT r.name region, s.name rep, a.name account\n",
    "FROM region r\n",
    "JOIN sales_reps s\n",
    "ON r.id = s.region_id\n",
    "JOIN accounts a\n",
    "ON s.id = a.sales_rep_id\n",
    "WHERE r.name = 'Midwest'\n",
    "ORDER BY a.name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e69483e7-f756-4692-9f46-0e65d14bb421",
   "metadata": {},
   "source": [
    "2. Provide a table that provides the region for each sales_rep along with their associated accounts. This time only for accounts where the sales rep has a first name starting with S and in the Midwest region. Your final table should include three columns: the region name, the sales rep name, and the account name. Sort the accounts alphabetically (A-Z) according to account name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "fa7bba02-d99f-45e2-b798-7a12fc6c49bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "5 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>region</th>\n",
       "            <th>rep</th>\n",
       "            <th>account</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Midwest</td>\n",
       "            <td>Sherlene Wetherington</td>\n",
       "            <td>Community Health Systems</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Midwest</td>\n",
       "            <td>Sherlene Wetherington</td>\n",
       "            <td>Progressive</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Midwest</td>\n",
       "            <td>Sherlene Wetherington</td>\n",
       "            <td>Rite Aid</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Midwest</td>\n",
       "            <td>Sherlene Wetherington</td>\n",
       "            <td>Time Warner Cable</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Midwest</td>\n",
       "            <td>Sherlene Wetherington</td>\n",
       "            <td>U.S. Bancorp</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Midwest', 'Sherlene Wetherington', 'Community Health Systems'),\n",
       " ('Midwest', 'Sherlene Wetherington', 'Progressive'),\n",
       " ('Midwest', 'Sherlene Wetherington', 'Rite Aid'),\n",
       " ('Midwest', 'Sherlene Wetherington', 'Time Warner Cable'),\n",
       " ('Midwest', 'Sherlene Wetherington', 'U.S. Bancorp')]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT r.name region, s.name rep, a.name account\n",
    "FROM region r\n",
    "JOIN sales_reps s\n",
    "ON r.id = s.region_id\n",
    "JOIN accounts a\n",
    "ON s.id = a.sales_rep_id\n",
    "WHERE (r.name = 'Midwest' AND s.name LIKE 'S%')\n",
    "ORDER BY a.name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4cf48b8-3dc0-4415-bd1f-efd0eca6de52",
   "metadata": {},
   "source": [
    "3. Provide a table that provides the region for each sales_rep along with their associated accounts. This time only for accounts where the sales rep has a last name starting with K and in the Midwest region. Your final table should include three columns: the region name, the sales rep name, and the account name. Sort the accounts alphabetically (A-Z) according to account name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "eb035adf-0bfb-439d-bc07-c5b37be4f95e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "13 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>region</th>\n",
       "            <th>rep</th>\n",
       "            <th>account</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Midwest</td>\n",
       "            <td>Delilah Krum</td>\n",
       "            <td>Amgen</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Midwest</td>\n",
       "            <td>Delilah Krum</td>\n",
       "            <td>AutoNation</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Midwest</td>\n",
       "            <td>Delilah Krum</td>\n",
       "            <td>Capital One Financial</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Midwest</td>\n",
       "            <td>Delilah Krum</td>\n",
       "            <td>Cummins</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Midwest</td>\n",
       "            <td>Carletta Kosinski</td>\n",
       "            <td>Danaher</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Midwest', 'Delilah Krum', 'Amgen'),\n",
       " ('Midwest', 'Delilah Krum', 'AutoNation'),\n",
       " ('Midwest', 'Delilah Krum', 'Capital One Financial'),\n",
       " ('Midwest', 'Delilah Krum', 'Cummins'),\n",
       " ('Midwest', 'Carletta Kosinski', 'Danaher')]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT r.name region, s.name rep, a.name account\n",
    "FROM region r\n",
    "JOIN sales_reps s\n",
    "ON r.id = s.region_id\n",
    "JOIN accounts a\n",
    "ON s.id = a.sales_rep_id\n",
    "WHERE (r.name = 'Midwest' AND s.name LIKE '% K%')\n",
    "ORDER BY a.name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6e6ab05-2e8f-4d27-9863-c41d46fcd210",
   "metadata": {},
   "source": [
    "4. Provide the name for each region for every order, as well as the account name and the unit price they paid (total_amt_usd/total) for the order. However, you should only provide the results if the standard order quantity exceeds 100. Your final table should have 3 columns: region name, account name, and unit price. In order to avoid a division by zero error, adding .01 to the denominator here is helpful total_amt_usd/(total+0.01)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "618d7b35-c90d-4a0c-be75-fa0c86280da1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "4509 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>region</th>\n",
       "            <th>account</th>\n",
       "            <th>unit_price</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>Walmart</td>\n",
       "            <td>5.7596000236672386</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>Walmart</td>\n",
       "            <td>5.9651748203187389</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>Walmart</td>\n",
       "            <td>5.4442361229475598</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>Walmart</td>\n",
       "            <td>5.9601842312587116</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>Walmart</td>\n",
       "            <td>6.1687185711808566</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Northeast', 'Walmart', Decimal('5.7596000236672386')),\n",
       " ('Northeast', 'Walmart', Decimal('5.9651748203187389')),\n",
       " ('Northeast', 'Walmart', Decimal('5.4442361229475598')),\n",
       " ('Northeast', 'Walmart', Decimal('5.9601842312587116')),\n",
       " ('Northeast', 'Walmart', Decimal('6.1687185711808566'))]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT r.name region, a.name account, o.total_amt_usd/(o.total+0.01) unit_price\n",
    "FROM orders o\n",
    "JOIN accounts a\n",
    "ON o.account_id = a.id\n",
    "JOIN sales_reps s\n",
    "ON a.sales_rep_id = s.id\n",
    "JOIN region r\n",
    "ON s.region_id = r.id\n",
    "WHERE standard_qty > 100"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3f4c058-9a5d-46bb-8a01-0dcd353dc09a",
   "metadata": {},
   "source": [
    "5. Provide the name for each region for every order, as well as the account name and the unit price they paid (total_amt_usd/total) for the order. However, you should only provide the results if the standard order quantity exceeds 100 and the poster order quantity exceeds 50. Your final table should have 3 columns: region name, account name, and unit price. Sort for the smallest unit price first. In order to avoid a division by zero error, adding .01 to the denominator here is helpful (total_amt_usd/(total+0.01)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "abd482f9-aad1-4528-b820-f311f3060a19",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "835 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>region</th>\n",
       "            <th>account</th>\n",
       "            <th>unit_price</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>State Farm Insurance Cos.</td>\n",
       "            <td>5.1192822502542913</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Southeast</td>\n",
       "            <td>DISH Network</td>\n",
       "            <td>5.2318158475403638</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>Travelers Cos.</td>\n",
       "            <td>5.2351813313106532</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>Best Buy</td>\n",
       "            <td>5.2604264379300265</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>West</td>\n",
       "            <td>Stanley Black &amp; Decker</td>\n",
       "            <td>5.2663955600739988</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Northeast', 'State Farm Insurance Cos.', Decimal('5.1192822502542913')),\n",
       " ('Southeast', 'DISH Network', Decimal('5.2318158475403638')),\n",
       " ('Northeast', 'Travelers Cos.', Decimal('5.2351813313106532')),\n",
       " ('Northeast', 'Best Buy', Decimal('5.2604264379300265')),\n",
       " ('West', 'Stanley Black & Decker', Decimal('5.2663955600739988'))]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT r.name region, a.name account, o.total_amt_usd/(o.total+0.01) unit_price\n",
    "FROM orders o\n",
    "JOIN accounts a\n",
    "ON o.account_id = a.id\n",
    "JOIN sales_reps s\n",
    "ON a.sales_rep_id = s.id\n",
    "JOIN region r\n",
    "ON s.region_id = r.id\n",
    "WHERE (o.standard_qty > 100 AND o.poster_qty > 50)\n",
    "ORDER BY unit_price"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3f127ea-e76a-4380-8e1d-f28a5770c99c",
   "metadata": {},
   "source": [
    "6. Provide the name for each region for every order, as well as the account name and the unit price they paid (total_amt_usd/total) for the order. However, you should only provide the results if the standard order quantity exceeds 100 and the poster order quantity exceeds 50. Your final table should have 3 columns: region name, account name, and unit price. Sort for the largest unit price first. In order to avoid a division by zero error, adding .01 to the denominator here is helpful (total_amt_usd/(total+0.01)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "323c3b57-00c2-402c-bff8-b9c94024f30a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "835 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>region</th>\n",
       "            <th>account</th>\n",
       "            <th>unit_price</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>IBM</td>\n",
       "            <td>8.0899060822781456</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>West</td>\n",
       "            <td>Mosaic</td>\n",
       "            <td>8.0663292103581285</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>West</td>\n",
       "            <td>Pacific Life</td>\n",
       "            <td>8.0630226525147913</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>CHS</td>\n",
       "            <td>8.0188493267801133</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>West</td>\n",
       "            <td>Fidelity National Financial</td>\n",
       "            <td>7.9928024668468328</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Northeast', 'IBM', Decimal('8.0899060822781456')),\n",
       " ('West', 'Mosaic', Decimal('8.0663292103581285')),\n",
       " ('West', 'Pacific Life', Decimal('8.0630226525147913')),\n",
       " ('Northeast', 'CHS', Decimal('8.0188493267801133')),\n",
       " ('West', 'Fidelity National Financial', Decimal('7.9928024668468328'))]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT r.name region, a.name account, o.total_amt_usd/(o.total+0.01) unit_price\n",
    "FROM orders o\n",
    "JOIN accounts a\n",
    "ON o.account_id = a.id\n",
    "JOIN sales_reps s\n",
    "ON a.sales_rep_id = s.id\n",
    "JOIN region r\n",
    "ON s.region_id = r.id\n",
    "WHERE (o.standard_qty > 100 AND o.poster_qty > 50)\n",
    "ORDER BY unit_price DESC"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84f1c5a6-2114-4205-9329-b041abb4b2ac",
   "metadata": {},
   "source": [
    "7. What are the different channels used by account id 1001? Your final table should have only 2 columns: account name and the different channels. You can try SELECT DISTINCT to narrow down the results to only the unique values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "196605f5-6279-4f79-93eb-ec0ca10c4449",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "6 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>name</th>\n",
       "            <th>channel</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Walmart</td>\n",
       "            <td>adwords</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Walmart</td>\n",
       "            <td>banner</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Walmart</td>\n",
       "            <td>direct</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Walmart</td>\n",
       "            <td>facebook</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Walmart</td>\n",
       "            <td>organic</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Walmart', 'adwords'),\n",
       " ('Walmart', 'banner'),\n",
       " ('Walmart', 'direct'),\n",
       " ('Walmart', 'facebook'),\n",
       " ('Walmart', 'organic')]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT DISTINCT a.name, w.channel\n",
    "FROM accounts a\n",
    "JOIN web_events w\n",
    "ON a.id = w.account_id\n",
    "WHERE a.id = 1001"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "378f10cd-745f-4d87-9853-96da1860a820",
   "metadata": {},
   "source": [
    "8. Find all the orders that occurred in 2015. Your final table should have 4 columns: occurred_at, account name, order total, and order total_amt_usd."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "6c1979bb-9ab5-4082-9097-a7fe8e8bf0c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1715 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>id</th>\n",
       "            <th>occurred_at</th>\n",
       "            <th>account</th>\n",
       "            <th>total</th>\n",
       "            <th>total_amt_usd</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>2922</td>\n",
       "            <td>2015-12-30 20:04:55</td>\n",
       "            <td>Occidental Petroleum</td>\n",
       "            <td>121</td>\n",
       "            <td>623.79</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1184</td>\n",
       "            <td>2015-12-30 19:01:13</td>\n",
       "            <td>CHS</td>\n",
       "            <td>340</td>\n",
       "            <td>1819.22</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>4803</td>\n",
       "            <td>2015-12-30 17:31:09</td>\n",
       "            <td>Pfizer</td>\n",
       "            <td>1314</td>\n",
       "            <td>8632.07</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2049</td>\n",
       "            <td>2015-12-30 17:30:33</td>\n",
       "            <td>Fluor</td>\n",
       "            <td>327</td>\n",
       "            <td>1762.44</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>5555</td>\n",
       "            <td>2015-12-30 17:17:03</td>\n",
       "            <td>Fluor</td>\n",
       "            <td>869</td>\n",
       "            <td>6311.35</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(2922, datetime.datetime(2015, 12, 30, 20, 4, 55), 'Occidental Petroleum', 121, Decimal('623.79')),\n",
       " (1184, datetime.datetime(2015, 12, 30, 19, 1, 13), 'CHS', 340, Decimal('1819.22')),\n",
       " (4803, datetime.datetime(2015, 12, 30, 17, 31, 9), 'Pfizer', 1314, Decimal('8632.07')),\n",
       " (2049, datetime.datetime(2015, 12, 30, 17, 30, 33), 'Fluor', 327, Decimal('1762.44')),\n",
       " (5555, datetime.datetime(2015, 12, 30, 17, 17, 3), 'Fluor', 869, Decimal('6311.35'))]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT o.id, o.occurred_at, a.name account, o.total, o.total_amt_usd\n",
    "FROM orders o\n",
    "JOIN accounts a\n",
    "ON o.account_id = a.id\n",
    "WHERE o.occurred_at BETWEEN '2015-01-01' AND '2015-12-31'\n",
    "ORDER BY o.occurred_at DESC;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51e9936d-a057-4542-9217-7de3c5825bc4",
   "metadata": {},
   "source": [
    "## Lesson 3: SQL Aggregations\n",
    "\n",
    "Concept 11. Quiz: MIN, MAX, & AVG"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3abff46f-6242-4972-96fa-3a7d4587ebff",
   "metadata": {},
   "source": [
    "3 When did the most recent (latest) web_event occur?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "5d673a22-ddad-4dd9-aad1-f4b5451ce6c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>max</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>2017-01-01 23:51:09</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(datetime.datetime(2017, 1, 1, 23, 51, 9),)]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT MAX(occurred_at) FROM web_events LIMIT 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b78e94f7-59e7-4271-b215-b436ff7f8003",
   "metadata": {},
   "source": [
    "4. Try to perform the result of the previous query without using an aggregation function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "76eb7b36-bc65-4de1-873b-67eb2f335055",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>occurred_at</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>2017-01-01 23:51:09</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(datetime.datetime(2017, 1, 1, 23, 51, 9),)]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT occurred_at FROM web_events ORDER BY occurred_at DESC LIMIT 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d24e5943-0c8f-47ed-8710-57c348397103",
   "metadata": {},
   "source": [
    "5. Find:\n",
    "    - the mean amount spent per order on each paper type eg AVG(standard_amt_usd)\n",
    "    - the mean amount of each paper type purchased per order AVG(standard_qty)\n",
    "    Your final answer should have 6 values - one for each paper type for the average number of sales, as well as the average amount."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "69bda5ed-bd18-4bcf-a040-ab84090ace41",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>avg_s_q</th>\n",
       "            <th>avg_p_q</th>\n",
       "            <th>avg_g_q</th>\n",
       "            <th>avg_s_a</th>\n",
       "            <th>avg_p_a</th>\n",
       "            <th>avg_g_a</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>280.4320023148148148</td>\n",
       "            <td>104.6941550925925926</td>\n",
       "            <td>146.6685474537037037</td>\n",
       "            <td>1399.3556915509259259</td>\n",
       "            <td>850.1165393518518519</td>\n",
       "            <td>1098.5474204282407407</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(Decimal('280.4320023148148148'), Decimal('104.6941550925925926'), Decimal('146.6685474537037037'), Decimal('1399.3556915509259259'), Decimal('850.1165393518518519'), Decimal('1098.5474204282407407'))]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT\n",
    "    AVG(standard_qty) avg_s_q,\n",
    "    AVG(poster_qty) avg_p_q,\n",
    "    AVG(gloss_qty) avg_g_q,\n",
    "    AVG(standard_amt_usd) avg_s_a,\n",
    "    AVG(poster_amt_usd) avg_p_a,\n",
    "    AVG(gloss_amt_usd) avg_g_a\n",
    "FROM orders"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35a90736-551b-4082-9531-1aafd12b2282",
   "metadata": {},
   "source": [
    "6. Via the video, you might be interested in how to calculate the MEDIAN. Though this is more advanced than what we have covered so far try finding - what is the MEDIAN total_usd spent on all orders?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "76622595-e99e-48c5-9718-9cf639dd3e7b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>total_amt_usd</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>1893.53</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(Decimal('1893.53'),)]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT total_amt_usd FROM orders WHERE id = 3456"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cde7c2a9-a654-4ab4-b3c0-761850652f24",
   "metadata": {},
   "source": [
    "My effort above is not very good... There's no sorting of the numbers, and no averaging of the two middle values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "b686c658-84b9-40a2-8c57-a85ee1bf24c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "2 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>total_amt_usd</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>2483.16</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2482.55</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(Decimal('2483.16'),), (Decimal('2482.55'),)]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT *\n",
    "FROM (SELECT total_amt_usd\n",
    "      FROM orders\n",
    "      ORDER BY total_amt_usd\n",
    "      LIMIT 3457) AS Table1\n",
    "ORDER BY total_amt_usd DESC\n",
    "LIMIT 2;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d5b0ad4-bb75-4afa-934f-51c8c79d11cc",
   "metadata": {},
   "source": [
    "The subquery above sorts the numbers first. It then returns the 2 middle values 3456 and 3457. It's then up to us to divide by two... or we could do this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "ec51f1cf-a26e-4650-af6a-3ca311d5a1b3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>avg</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>2482.8550000000000000</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(Decimal('2482.8550000000000000'),)]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT AVG(total_amt_usd) FROM\n",
    "\t(SELECT *\n",
    "\t\tFROM (SELECT total_amt_usd\n",
    "      \t\tFROM orders\n",
    "      \t\tORDER BY total_amt_usd\n",
    "      \t\tLIMIT 3457) AS Table1\n",
    "\tORDER BY total_amt_usd DESC\n",
    "\tLIMIT 2) AS Table2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee595318-85e5-4384-9b94-48d373ec309f",
   "metadata": {},
   "source": [
    "## Concept 14. Quiz: GROUP BY"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50f694b0-ab52-4ea6-9478-6e34bc38bf67",
   "metadata": {},
   "source": [
    "1. Which account (by name) placed the earliest order? Your solution should have the account name and the date of the order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "3b8ee7f0-d092-4c81-af6b-1e448023e25b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>name</th>\n",
       "            <th>occurred_at</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>DISH Network</td>\n",
       "            <td>2013-12-04 04:22:44</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('DISH Network', datetime.datetime(2013, 12, 4, 4, 22, 44))]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT a.name, o.occurred_at\n",
    "FROM accounts a\n",
    "JOIN orders o\n",
    "ON o.account_id = a.id\n",
    "ORDER BY o.occurred_at\n",
    "LIMIT 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4aef5153-908a-42b4-9687-6a61c0b9926c",
   "metadata": {},
   "source": [
    "2. Find the total sales in usd for each account. You should include two columns - the total sales for each company's orders in usd and the company name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "3ff84e16-e6e8-4084-99a7-155fcea18c24",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "350 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>name</th>\n",
       "            <th>sum</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>3M</td>\n",
       "            <td>127945.10</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Abbott Laboratories</td>\n",
       "            <td>96819.92</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>AbbVie</td>\n",
       "            <td>11243.63</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>ADP</td>\n",
       "            <td>163579.18</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Advance Auto Parts</td>\n",
       "            <td>6962.07</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('3M', Decimal('127945.10')),\n",
       " ('Abbott Laboratories', Decimal('96819.92')),\n",
       " ('AbbVie', Decimal('11243.63')),\n",
       " ('ADP', Decimal('163579.18')),\n",
       " ('Advance Auto Parts', Decimal('6962.07'))]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT a.name,\n",
    "    SUM(o.total_amt_usd)\n",
    "FROM accounts a\n",
    "JOIN orders o\n",
    "ON o.account_id = a.id\n",
    "GROUP BY a.name\n",
    "ORDER BY a.name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b48e726f-bf92-4e32-ac7f-ce73a8a65be7",
   "metadata": {},
   "source": [
    "3. Via what channel did the most recent (latest) web_event occur, which account was associated with this web_event? Your query should return only three values - the date, channel, and account name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "e90697fe-d76c-4183-b28e-570af417d3f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>occurred_at</th>\n",
       "            <th>channel</th>\n",
       "            <th>name</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>2017-01-01 23:51:09</td>\n",
       "            <td>organic</td>\n",
       "            <td>Molina Healthcare</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(datetime.datetime(2017, 1, 1, 23, 51, 9), 'organic', 'Molina Healthcare')]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT w.occurred_at, w.channel, a.name\n",
    "FROM web_events w\n",
    "JOIN accounts a\n",
    "ON a.id = w.account_id\n",
    "ORDER BY w.occurred_at DESC \n",
    "LIMIT 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2947f7d4-41cc-45a3-abc0-b13d756bf2a0",
   "metadata": {},
   "source": [
    "4. Find the total number of times each type of channel from the web_events was used. Your final table should have two columns - the channel and the number of times the channel was used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "6bc011d8-30ba-4301-a505-5b54b76a1ebd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "6 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>channel</th>\n",
       "            <th>count</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>twitter</td>\n",
       "            <td>474</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>adwords</td>\n",
       "            <td>906</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>organic</td>\n",
       "            <td>952</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>banner</td>\n",
       "            <td>476</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>facebook</td>\n",
       "            <td>967</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('twitter', 474),\n",
       " ('adwords', 906),\n",
       " ('organic', 952),\n",
       " ('banner', 476),\n",
       " ('facebook', 967)]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT w.channel, COUNT(*)\n",
    "FROM web_events w\n",
    "GROUP BY w.channel"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "318dfc6b-a483-421f-acee-0a79f9b20092",
   "metadata": {},
   "source": [
    "5. Who was the primary contact associated with the earliest web_event?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "d0f2aa9c-4871-42d9-bcc5-00ab33a34896",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>primary_poc</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Leana Hawker</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Leana Hawker',)]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT a.primary_poc\n",
    "FROM web_events w\n",
    "JOIN accounts a\n",
    "ON a.id = w.account_id\n",
    "ORDER BY w.occurred_at \n",
    "LIMIT 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bd3fec9-4851-47c7-bcad-a25a4babb1a0",
   "metadata": {},
   "source": [
    "6. What was the smallest order placed by each account in terms of total usd. Provide only two columns - the account name and the total usd. Order from smallest dollar amounts to largest."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "9cd26441-d699-4d9c-af4b-bd44b55afb96",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "(psycopg2.errors.DuplicateAlias) table name \"o\" specified more than once\n",
      "\n",
      "[SQL: SELECT a.name, MIN(o.total_amt_usd) smallest_order\n",
      "FROM orders o\n",
      "JOIN accounts o\n",
      "ON o.account_id = a.id\n",
      "GROUP BY a.name\n",
      "ORDER BY smallest_order]\n",
      "(Background on this error at: https://sqlalche.me/e/14/f405)\n"
     ]
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT a.name, MIN(o.total_amt_usd) smallest_order\n",
    "FROM orders o\n",
    "JOIN accounts o\n",
    "ON o.account_id = a.id\n",
    "GROUP BY a.name\n",
    "ORDER BY smallest_order"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "babea821-d0ae-44b8-9172-1790bc3c8369",
   "metadata": {},
   "source": [
    "7. Find the number of sales reps in each region. Your final table should have two columns - the region and the number of sales_reps. Order from fewest reps to most reps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "4f201b0d-3b61-42ea-a931-7777d0a23ee9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "4 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>region_name</th>\n",
       "            <th>number_of_reps</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Midwest</td>\n",
       "            <td>9</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Southeast</td>\n",
       "            <td>10</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>West</td>\n",
       "            <td>10</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>21</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Midwest', 9), ('Southeast', 10), ('West', 10), ('Northeast', 21)]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT r.name region_name, COUNT(*) number_of_reps\n",
    "FROM region r\n",
    "JOIN sales_reps s\n",
    "ON r.id = s.region_id\n",
    "GROUP BY region_name\n",
    "ORDER BY number_of_reps"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "220b4ae9-8191-460e-b28a-f97fd48825ae",
   "metadata": {},
   "source": [
    "## Concept 17. Quiz: GROUP BY Part II"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d756e37-15f5-4a45-b6ac-49d8d316059b",
   "metadata": {},
   "source": [
    "1. For each account, determine the average amount of each type of paper they purchased across their orders. Your result should have four columns - one for the account name and one for the average quantity purchased for each of the paper types for each account."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "d5f44818-3729-4a5d-9d2b-d0e7e14bf7bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "350 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>name</th>\n",
       "            <th>avg</th>\n",
       "            <th>avg_1</th>\n",
       "            <th>avg_2</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>3M</td>\n",
       "            <td>313.3928571428571429</td>\n",
       "            <td>112.1071428571428571</td>\n",
       "            <td>279.7500000000000000</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Abbott Laboratories</td>\n",
       "            <td>201.1000000000000000</td>\n",
       "            <td>92.4333333333333333</td>\n",
       "            <td>196.7000000000000000</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>AbbVie</td>\n",
       "            <td>238.3333333333333333</td>\n",
       "            <td>58.6666666666666667</td>\n",
       "            <td>278.0000000000000000</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>ADP</td>\n",
       "            <td>354.6333333333333333</td>\n",
       "            <td>61.9833333333333333</td>\n",
       "            <td>60.5333333333333333</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Advance Auto Parts</td>\n",
       "            <td>274.0000000000000000</td>\n",
       "            <td>27.7500000000000000</td>\n",
       "            <td>19.7500000000000000</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('3M', Decimal('313.3928571428571429'), Decimal('112.1071428571428571'), Decimal('279.7500000000000000')),\n",
       " ('Abbott Laboratories', Decimal('201.1000000000000000'), Decimal('92.4333333333333333'), Decimal('196.7000000000000000')),\n",
       " ('AbbVie', Decimal('238.3333333333333333'), Decimal('58.6666666666666667'), Decimal('278.0000000000000000')),\n",
       " ('ADP', Decimal('354.6333333333333333'), Decimal('61.9833333333333333'), Decimal('60.5333333333333333')),\n",
       " ('Advance Auto Parts', Decimal('274.0000000000000000'), Decimal('27.7500000000000000'), Decimal('19.7500000000000000'))]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT a.name, AVG(standard_qty), AVG(poster_qty), AVG(gloss_qty)\n",
    "FROM orders o\n",
    "JOIN accounts a\n",
    "ON o.account_id = a.id\n",
    "GROUP BY a.name\n",
    "ORDER BY a.name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85699a22-a720-424d-9181-66ffc3d2b7bd",
   "metadata": {},
   "source": [
    "2. For each account, determine the average amount spent per order on each paper type. Your result should have four columns - one for the account name and one for the average amount spent on each paper type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "05fc8c1f-b79f-41bf-84b2-15c3c8bad1af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "350 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>name</th>\n",
       "            <th>avg</th>\n",
       "            <th>avg_1</th>\n",
       "            <th>avg_2</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>3M</td>\n",
       "            <td>1563.8303571428571429</td>\n",
       "            <td>910.3100000000000000</td>\n",
       "            <td>2095.3275000000000000</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Abbott Laboratories</td>\n",
       "            <td>1003.4890000000000000</td>\n",
       "            <td>750.5586666666666667</td>\n",
       "            <td>1473.2830000000000000</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>AbbVie</td>\n",
       "            <td>1189.2833333333333333</td>\n",
       "            <td>476.3733333333333333</td>\n",
       "            <td>2082.2200000000000000</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>ADP</td>\n",
       "            <td>1769.6203333333333333</td>\n",
       "            <td>503.3046666666666667</td>\n",
       "            <td>453.3946666666666667</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Advance Auto Parts</td>\n",
       "            <td>1367.2600000000000000</td>\n",
       "            <td>225.3300000000000000</td>\n",
       "            <td>147.9275000000000000</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('3M', Decimal('1563.8303571428571429'), Decimal('910.3100000000000000'), Decimal('2095.3275000000000000')),\n",
       " ('Abbott Laboratories', Decimal('1003.4890000000000000'), Decimal('750.5586666666666667'), Decimal('1473.2830000000000000')),\n",
       " ('AbbVie', Decimal('1189.2833333333333333'), Decimal('476.3733333333333333'), Decimal('2082.2200000000000000')),\n",
       " ('ADP', Decimal('1769.6203333333333333'), Decimal('503.3046666666666667'), Decimal('453.3946666666666667')),\n",
       " ('Advance Auto Parts', Decimal('1367.2600000000000000'), Decimal('225.3300000000000000'), Decimal('147.9275000000000000'))]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT a.name, AVG(standard_amt_usd), AVG(poster_amt_usd), AVG(gloss_amt_usd)\n",
    "FROM orders o\n",
    "JOIN accounts a\n",
    "ON o.account_id = a.id\n",
    "GROUP BY a.name\n",
    "ORDER BY a.name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a880bba2-4da4-4e0c-bb8c-b11ec7789cd0",
   "metadata": {},
   "source": [
    "3. Determine the number of times a particular channel was used in the web_events table for each sales rep. Your final table should have three columns - the name of the sales rep, the channel, and the number of occurrences. Order your table with the highest number of occurrences first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "61893d0b-cca5-4f98-b516-ff530e507fc5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "295 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>name</th>\n",
       "            <th>channel</th>\n",
       "            <th>num</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Earlie Schleusner</td>\n",
       "            <td>direct</td>\n",
       "            <td>234</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Vernita Plump</td>\n",
       "            <td>direct</td>\n",
       "            <td>232</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Moon Torian</td>\n",
       "            <td>direct</td>\n",
       "            <td>194</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Georgianna Chisholm</td>\n",
       "            <td>direct</td>\n",
       "            <td>188</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Tia Amato</td>\n",
       "            <td>direct</td>\n",
       "            <td>185</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Earlie Schleusner', 'direct', 234),\n",
       " ('Vernita Plump', 'direct', 232),\n",
       " ('Moon Torian', 'direct', 194),\n",
       " ('Georgianna Chisholm', 'direct', 188),\n",
       " ('Tia Amato', 'direct', 185)]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT s.name, w.channel, COUNT(*) num\n",
    "FROM web_events w\n",
    "JOIN accounts a\n",
    "ON a.id = w.account_id\n",
    "JOIN sales_reps s\n",
    "ON a.sales_rep_id = s.id\n",
    "GROUP BY s.name, w.channel\n",
    "ORDER BY num DESC"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dae33b0c-ff65-4066-ae53-6114fd04eb76",
   "metadata": {},
   "source": [
    "4. Determine the number of times a particular channel was used in the web_events table for each region. Your final table should have three columns - the region name, the channel, and the number of occurrences. Order your table with the highest number of occurrences first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "fbcd252f-5aa1-4e28-b09d-5c898c723884",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "24 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>name</th>\n",
       "            <th>channel</th>\n",
       "            <th>num</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>direct</td>\n",
       "            <td>1800</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Southeast</td>\n",
       "            <td>direct</td>\n",
       "            <td>1548</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>West</td>\n",
       "            <td>direct</td>\n",
       "            <td>1254</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Midwest</td>\n",
       "            <td>direct</td>\n",
       "            <td>696</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>facebook</td>\n",
       "            <td>335</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Northeast', 'direct', 1800),\n",
       " ('Southeast', 'direct', 1548),\n",
       " ('West', 'direct', 1254),\n",
       " ('Midwest', 'direct', 696),\n",
       " ('Northeast', 'facebook', 335)]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT r.name, w.channel, COUNT(*) num\n",
    "FROM web_events w\n",
    "JOIN accounts a\n",
    "ON a.id = w.account_id\n",
    "JOIN sales_reps s\n",
    "ON a.sales_rep_id = s.id\n",
    "JOIN region r\n",
    "ON s.region_id = r.id\n",
    "GROUP BY r.name, w.channel\n",
    "ORDER BY num DESC"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "427857db-1633-4521-b5bf-898c7edb9f34",
   "metadata": {},
   "source": [
    "## Concept 20. Quiz: DISTINCT"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68819cc7-8d44-4ada-b590-004edaf845a7",
   "metadata": {},
   "source": [
    "1. Use DISTINCT to test if there are any accounts associated with more than one region."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "1d9fe5e2-46e2-4e3c-bdac-1c954fbd2fec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "351 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>name</th>\n",
       "            <th>region_id</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Johnson Controls</td>\n",
       "            <td>1</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>American Airlines Group</td>\n",
       "            <td>1</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Ingram Micro</td>\n",
       "            <td>1</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Freddie Mac</td>\n",
       "            <td>1</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Express Scripts Holding</td>\n",
       "            <td>1</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Johnson Controls', 1),\n",
       " ('American Airlines Group', 1),\n",
       " ('Ingram Micro', 1),\n",
       " ('Freddie Mac', 1),\n",
       " ('Express Scripts Holding', 1)]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT a.name, s.region_id FROM accounts a\n",
    "JOIN sales_reps s\n",
    "ON a.sales_rep_id = s.id\n",
    "JOIN region r\n",
    "ON r.id = s.region_id"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c282881-53eb-4274-bf0d-b027db9dd3fb",
   "metadata": {},
   "source": [
    "The above produces the same number of results as the following. This indicates that there are no accounts with multiple regions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "3bac9e5f-a0ff-41b3-975f-4598fdfa7f59",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "351 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>id</th>\n",
       "            <th>name</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>1591</td>\n",
       "            <td>Lockheed Martin</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2701</td>\n",
       "            <td>PNC Financial Services Group</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2451</td>\n",
       "            <td>Starbucks</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1681</td>\n",
       "            <td>Nationwide</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>4111</td>\n",
       "            <td>Republic Services</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(1591, 'Lockheed Martin'),\n",
       " (2701, 'PNC Financial Services Group'),\n",
       " (2451, 'Starbucks'),\n",
       " (1681, 'Nationwide'),\n",
       " (4111, 'Republic Services')]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT DISTINCT id, name\n",
    "FROM accounts;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92ced051-b952-4c02-b79b-1723ba58a36c",
   "metadata": {},
   "source": [
    "2. Have any sales reps worked on more than one account?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "ef220271-5f59-4e7f-9c2a-e80a2d589768",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "50 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>id</th>\n",
       "            <th>name</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>321870</td>\n",
       "            <td>Derrick Boggess</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>321500</td>\n",
       "            <td>Samuel Racine</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>321580</td>\n",
       "            <td>Sibyl Lauria</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>321550</td>\n",
       "            <td>Lavera Oles</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>321860</td>\n",
       "            <td>Saran Ram</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(321870, 'Derrick Boggess'),\n",
       " (321500, 'Samuel Racine'),\n",
       " (321580, 'Sibyl Lauria'),\n",
       " (321550, 'Lavera Oles'),\n",
       " (321860, 'Saran Ram')]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT DISTINCT id, name FROM sales_reps"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2612823-3879-4c9a-918f-1b93013f8b13",
   "metadata": {},
   "source": [
    "-- There are 50 sales reps. Using DISTINCT in this first query does seem pretty pointless, but it does point out that a sales rep isn't duplicated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "a822c239-7d11-47d9-8eb5-583b3aa9596d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "351 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>account_name</th>\n",
       "            <th>rep_name</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>FedEx</td>\n",
       "            <td>Akilah Drinkard</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Comcast</td>\n",
       "            <td>Akilah Drinkard</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Fannie Mae</td>\n",
       "            <td>Akilah Drinkard</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Assurant</td>\n",
       "            <td>Arica Stoltzfus</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>W.W. Grainger</td>\n",
       "            <td>Arica Stoltzfus</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('FedEx', 'Akilah Drinkard'),\n",
       " ('Comcast', 'Akilah Drinkard'),\n",
       " ('Fannie Mae', 'Akilah Drinkard'),\n",
       " ('Assurant', 'Arica Stoltzfus'),\n",
       " ('W.W. Grainger', 'Arica Stoltzfus')]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT a.name account_name, s.name rep_name FROM accounts a\n",
    "JOIN sales_reps s\n",
    "ON a.sales_rep_id = s.id\n",
    "ORDER BY rep_name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b70f5fb-cfd0-4efe-91ca-539662087b09",
   "metadata": {},
   "source": [
    "-- Here we listed all accounts and associated sales reps. We can easily see there are reps with more than one account"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "b62883ef-4998-468c-a091-af2f694f4687",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "50 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>id</th>\n",
       "            <th>name</th>\n",
       "            <th>num_accounts</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>321620</td>\n",
       "            <td>Retha Sears</td>\n",
       "            <td>3</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>321600</td>\n",
       "            <td>Ernestine Pickron</td>\n",
       "            <td>3</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>321650</td>\n",
       "            <td>Akilah Drinkard</td>\n",
       "            <td>3</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>321660</td>\n",
       "            <td>Silvana Virden</td>\n",
       "            <td>3</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>321610</td>\n",
       "            <td>Ayesha Monica</td>\n",
       "            <td>3</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(321620, 'Retha Sears', 3),\n",
       " (321600, 'Ernestine Pickron', 3),\n",
       " (321650, 'Akilah Drinkard', 3),\n",
       " (321660, 'Silvana Virden', 3),\n",
       " (321610, 'Ayesha Monica', 3)]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT s.id, s.name, COUNT(*) num_accounts\n",
    "FROM accounts a\n",
    "JOIN sales_reps s\n",
    "ON s.id = a.sales_rep_id\n",
    "GROUP BY s.id, s.name\n",
    "ORDER BY num_accounts;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52ba05a7-1b21-491b-a2f1-a996a82ff10f",
   "metadata": {},
   "source": [
    "Here we've counted the number of accounts for each customer. Which proves the point above a bit more cleanly. It doesn't really utilise the DISTINCT clause though... (which is a good thing as it is sloooowwww)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "824e8bed-08b1-4edc-b5f8-40ffbadecc7a",
   "metadata": {},
   "source": [
    "## Concept 23. HAVING"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb6ec85b-8659-4648-b303-df0992988130",
   "metadata": {},
   "source": [
    "1. How many of the sales reps have more than 5 accounts that they manage?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "da6bdb1b-05a0-455f-9a77-5dbc4b23dbbd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "34 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>id</th>\n",
       "            <th>name</th>\n",
       "            <th>num_accounts</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>321500</td>\n",
       "            <td>Samuel Racine</td>\n",
       "            <td>6</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>321510</td>\n",
       "            <td>Eugena Esser</td>\n",
       "            <td>6</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>321580</td>\n",
       "            <td>Sibyl Lauria</td>\n",
       "            <td>6</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>321590</td>\n",
       "            <td>Necole Victory</td>\n",
       "            <td>6</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>321560</td>\n",
       "            <td>Elba Felder</td>\n",
       "            <td>6</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(321500, 'Samuel Racine', 6),\n",
       " (321510, 'Eugena Esser', 6),\n",
       " (321580, 'Sibyl Lauria', 6),\n",
       " (321590, 'Necole Victory', 6),\n",
       " (321560, 'Elba Felder', 6)]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT s.id, s.name, COUNT(*) num_accounts\n",
    "FROM accounts a\n",
    "JOIN sales_reps s\n",
    "ON s.id = a.sales_rep_id\n",
    "GROUP BY s.id, s.name\n",
    "HAVING COUNT(*) > 5\n",
    "ORDER BY num_accounts"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f28f7d4-ba43-4498-a70b-a863992c61e7",
   "metadata": {},
   "source": [
    "2. How many accounts have more than 20 orders?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "881229a6-f9a7-4782-8f75-7efd67ea13d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "120 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>name</th>\n",
       "            <th>num_orders</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Thrivent Financial for Lutherans</td>\n",
       "            <td>21</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Performance Food Group</td>\n",
       "            <td>21</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Anthem</td>\n",
       "            <td>21</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Raytheon</td>\n",
       "            <td>22</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Jabil Circuit</td>\n",
       "            <td>22</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Thrivent Financial for Lutherans', 21),\n",
       " ('Performance Food Group', 21),\n",
       " ('Anthem', 21),\n",
       " ('Raytheon', 22),\n",
       " ('Jabil Circuit', 22)]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT a.name, COUNT(*) num_orders\n",
    "FROM accounts a\n",
    "JOIN orders o\n",
    "ON a.id = o.account_id\n",
    "GROUP BY a.name\n",
    "HAVING COUNT(*) > 20\n",
    "ORDER BY num_orders"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88e60828-1aa7-4eaa-9dee-d55653f680d2",
   "metadata": {},
   "source": [
    "3. Which account has the most orders?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "0bb79a86-a6e1-4143-82a8-882dd7b9d925",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>name</th>\n",
       "            <th>num_orders</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Leucadia National</td>\n",
       "            <td>71</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Leucadia National', 71)]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT a.name, COUNT(*) num_orders\n",
    "FROM accounts a\n",
    "JOIN orders o\n",
    "ON a.id = o.account_id\n",
    "GROUP BY a.name\n",
    "ORDER BY num_orders DESC\n",
    "LIMIT 1 "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d789e57-2198-468c-8d6d-e294a9274339",
   "metadata": {},
   "source": [
    "4. Which accounts spent more than 30,000 usd total across all orders?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "e6dfbc39-6149-4085-a335-4170ad349df4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "204 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>name</th>\n",
       "            <th>sum_orders</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Monsanto</td>\n",
       "            <td>130964.11</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>KKR</td>\n",
       "            <td>217473.85</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Performance Food Group</td>\n",
       "            <td>47645.86</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Paccar</td>\n",
       "            <td>161294.62</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>USAA</td>\n",
       "            <td>46822.63</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Monsanto', Decimal('130964.11')),\n",
       " ('KKR', Decimal('217473.85')),\n",
       " ('Performance Food Group', Decimal('47645.86')),\n",
       " ('Paccar', Decimal('161294.62')),\n",
       " ('USAA', Decimal('46822.63'))]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT a.name, SUM(total_amt_usd) sum_orders\n",
    "FROM accounts a\n",
    "JOIN orders o\n",
    "ON a.id = o.account_id\n",
    "GROUP BY a.name\n",
    "HAVING SUM(total_amt_usd) > 30000"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "534e5a8a-9f23-4d8b-92e7-59ce36924d93",
   "metadata": {},
   "source": [
    "5. Which accounts spent less than 1,000 usd total across all orders?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "98a909d5-b054-4e75-b96b-919c51c3ca05",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "56 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>name</th>\n",
       "            <th>sum_orders</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>AIG</td>\n",
       "            <td>9980.93</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>W.W. Grainger</td>\n",
       "            <td>8384.61</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Deere</td>\n",
       "            <td>1036.57</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>General Motors</td>\n",
       "            <td>9995.05</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Universal Health Services</td>\n",
       "            <td>5269.51</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('AIG', Decimal('9980.93')),\n",
       " ('W.W. Grainger', Decimal('8384.61')),\n",
       " ('Deere', Decimal('1036.57')),\n",
       " ('General Motors', Decimal('9995.05')),\n",
       " ('Universal Health Services', Decimal('5269.51'))]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT a.name, SUM(total_amt_usd) sum_orders\n",
    "FROM accounts a\n",
    "JOIN orders o\n",
    "ON a.id = o.account_id\n",
    "GROUP BY a.name\n",
    "HAVING SUM(total_amt_usd) < 10000"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ff35166-c53f-4340-be22-60a4c2f3f70f",
   "metadata": {},
   "source": [
    "6. Which account has spent the most with us?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "6b61a77d-fec8-478d-870d-4d5e1ed6b36d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>name</th>\n",
       "            <th>sum_orders</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>EOG Resources</td>\n",
       "            <td>382873.30</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('EOG Resources', Decimal('382873.30'))]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT a.name, SUM(total_amt_usd) sum_orders\n",
    "FROM accounts a\n",
    "JOIN orders o\n",
    "ON a.id = o.account_id\n",
    "GROUP BY a.name\n",
    "ORDER BY sum_orders DESC\n",
    "LIMIT 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f2dc1c9-3263-4778-8111-9bbfa819129b",
   "metadata": {},
   "source": [
    "7. Which account has spent the least with us?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "ca67e9c9-41b4-4b8b-9308-1d99c5d727af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>name</th>\n",
       "            <th>sum_orders</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Nike</td>\n",
       "            <td>390.25</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Nike', Decimal('390.25'))]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT a.name, SUM(total_amt_usd) sum_orders\n",
    "FROM accounts a\n",
    "JOIN orders o\n",
    "ON a.id = o.account_id\n",
    "GROUP BY a.name\n",
    "ORDER BY sum_orders\n",
    "LIMIT 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61f7c130-2f8d-48a0-9e27-5709c4c5568c",
   "metadata": {},
   "source": [
    "8. Which accounts used facebook as a channel to contact customers more than 6 times?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "7a815ac8-136e-4ceb-8c38-0211d3f15b11",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "46 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>name</th>\n",
       "            <th>channel</th>\n",
       "            <th>num</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>ADP</td>\n",
       "            <td>facebook</td>\n",
       "            <td>9</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Aetna</td>\n",
       "            <td>facebook</td>\n",
       "            <td>10</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Apple</td>\n",
       "            <td>facebook</td>\n",
       "            <td>9</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Arrow Electronics</td>\n",
       "            <td>facebook</td>\n",
       "            <td>9</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>AutoNation</td>\n",
       "            <td>facebook</td>\n",
       "            <td>14</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('ADP', 'facebook', 9),\n",
       " ('Aetna', 'facebook', 10),\n",
       " ('Apple', 'facebook', 9),\n",
       " ('Arrow Electronics', 'facebook', 9),\n",
       " ('AutoNation', 'facebook', 14)]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT a.name, w.channel, COUNT(*) num\n",
    "FROM web_events w\n",
    "JOIN accounts a\n",
    "ON a.id = w.account_id\n",
    "WHERE w.channel = 'facebook'\n",
    "GROUP BY a.name, w.channel\n",
    "HAVING COUNT(*) > 6\n",
    "ORDER BY a.name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f423ae9-a643-4581-92cc-9fb4e728fe7c",
   "metadata": {},
   "source": [
    "9. Which account used facebook most as a channel?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "daeb10ec-5ae8-4c79-b45d-c1f1ea3d4f6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>name</th>\n",
       "            <th>channel</th>\n",
       "            <th>num</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Gilead Sciences</td>\n",
       "            <td>facebook</td>\n",
       "            <td>16</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Gilead Sciences', 'facebook', 16)]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT a.name, w.channel, COUNT(*) num\n",
    "FROM web_events w\n",
    "JOIN accounts a\n",
    "ON a.id = w.account_id\n",
    "WHERE w.channel = 'facebook'\n",
    "GROUP BY a.name, w.channel\n",
    "ORDER BY num DESC\n",
    "LIMIT 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48d07060-81e8-47c5-857b-30a62302a73e",
   "metadata": {},
   "source": [
    "... but this wouldn't have worked well if more than one account had used a particular channel the same number of times. Best to use LIMIT 3 or so"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d360b2fb-e6a8-4324-bb3f-d7c4ab0fc0dd",
   "metadata": {},
   "source": [
    "10. Which channel was most frequently used by most accounts?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "024db342-8c70-49c9-824d-480156823a31",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "10 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>id</th>\n",
       "            <th>name</th>\n",
       "            <th>channel</th>\n",
       "            <th>use_of_channel</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>3411</td>\n",
       "            <td>Leucadia National</td>\n",
       "            <td>direct</td>\n",
       "            <td>52</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2731</td>\n",
       "            <td>Colgate-Palmolive</td>\n",
       "            <td>direct</td>\n",
       "            <td>51</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1601</td>\n",
       "            <td>New York Life Insurance</td>\n",
       "            <td>direct</td>\n",
       "            <td>51</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2051</td>\n",
       "            <td>Philip Morris International</td>\n",
       "            <td>direct</td>\n",
       "            <td>49</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>3911</td>\n",
       "            <td>Charter Communications</td>\n",
       "            <td>direct</td>\n",
       "            <td>48</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(3411, 'Leucadia National', 'direct', 52),\n",
       " (2731, 'Colgate-Palmolive', 'direct', 51),\n",
       " (1601, 'New York Life Insurance', 'direct', 51),\n",
       " (2051, 'Philip Morris International', 'direct', 49),\n",
       " (3911, 'Charter Communications', 'direct', 48)]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT a.id, a.name, w.channel, COUNT(*) use_of_channel\n",
    "FROM accounts a\n",
    "JOIN web_events w\n",
    "ON a.id = w.account_id\n",
    "GROUP BY a.id, a.name, w.channel\n",
    "ORDER BY use_of_channel DESC\n",
    "LIMIT 10;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2e10c47-b1ae-4759-9b31-e737026c94d3",
   "metadata": {},
   "source": [
    "I did not get this result. I went off on a complicated tangent including a subquery. I supposed that the question is more complex that it needs to be: if you simply view the web_events with the highest occurence (grouped by id>name>channel) you'll see the top ten at least are \"direct\" which answers the question ... or does it?!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b004c2e-48e9-4181-99e8-1998d1d4cd36",
   "metadata": {},
   "source": [
    "## Concept 27. Quiz: DATE Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8bf6a63-f4d1-4276-8285-fac5c219555a",
   "metadata": {},
   "source": [
    "Find the sales in terms of total dollars for all orders in each year, ordered from greatest to least. Do you notice any trends in the yearly sales totals?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "d8d3b13c-c1d2-48a0-810e-bfcc59699d65",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "5 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>year_total</th>\n",
       "            <th>sum_total_amt_usd</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>2016-01-01 00:00:00</td>\n",
       "            <td>12864917.92</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2015-01-01 00:00:00</td>\n",
       "            <td>5752004.94</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2014-01-01 00:00:00</td>\n",
       "            <td>4069106.54</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2013-01-01 00:00:00</td>\n",
       "            <td>377331.00</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2017-01-01 00:00:00</td>\n",
       "            <td>78151.43</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(datetime.datetime(2016, 1, 1, 0, 0), Decimal('12864917.92')),\n",
       " (datetime.datetime(2015, 1, 1, 0, 0), Decimal('5752004.94')),\n",
       " (datetime.datetime(2014, 1, 1, 0, 0), Decimal('4069106.54')),\n",
       " (datetime.datetime(2013, 1, 1, 0, 0), Decimal('377331.00')),\n",
       " (datetime.datetime(2017, 1, 1, 0, 0), Decimal('78151.43'))]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT\n",
    "    DATE_TRUNC('year',occurred_at) year_total,\n",
    "\tSUM(total_amt_usd) sum_total_amt_usd\n",
    "FROM orders\n",
    "GROUP BY 1\n",
    "ORDER BY 2 DESC"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6abd034-beb2-444f-8317-3f0a3bccb600",
   "metadata": {},
   "source": [
    "Which month did Parch & Posey have the greatest sales in terms of total dollars? Are all months evenly represented by the dataset?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "fd4e3146-e865-4b40-b9d7-da3efe7a1a03",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "38 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>year_total</th>\n",
       "            <th>sum_total_amt_usd</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>2016-12-01 00:00:00</td>\n",
       "            <td>1770282.62</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2016-11-01 00:00:00</td>\n",
       "            <td>1396045.62</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2016-10-01 00:00:00</td>\n",
       "            <td>1377981.57</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2016-07-01 00:00:00</td>\n",
       "            <td>1227707.47</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2016-09-01 00:00:00</td>\n",
       "            <td>1206399.93</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(datetime.datetime(2016, 12, 1, 0, 0), Decimal('1770282.62')),\n",
       " (datetime.datetime(2016, 11, 1, 0, 0), Decimal('1396045.62')),\n",
       " (datetime.datetime(2016, 10, 1, 0, 0), Decimal('1377981.57')),\n",
       " (datetime.datetime(2016, 7, 1, 0, 0), Decimal('1227707.47')),\n",
       " (datetime.datetime(2016, 9, 1, 0, 0), Decimal('1206399.93'))]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT\n",
    "    DATE_TRUNC('month',occurred_at) year_total,\n",
    "\tSUM(total_amt_usd) sum_total_amt_usd\n",
    "FROM orders\n",
    "GROUP BY 1\n",
    "ORDER BY 2 DESC"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dedf44dc-6273-4ac4-812b-06c654770ec5",
   "metadata": {},
   "source": [
    "Which year did Parch & Posey have the greatest sales in terms of total number of orders? Are all years evenly represented by the dataset?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "deb780cb-99e9-47ed-89c6-d13fad9997d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "5 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>year_total</th>\n",
       "            <th>num_orders</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>2016-01-01 00:00:00</td>\n",
       "            <td>3757</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2015-01-01 00:00:00</td>\n",
       "            <td>1725</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2014-01-01 00:00:00</td>\n",
       "            <td>1306</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2013-01-01 00:00:00</td>\n",
       "            <td>99</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2017-01-01 00:00:00</td>\n",
       "            <td>25</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(datetime.datetime(2016, 1, 1, 0, 0), 3757),\n",
       " (datetime.datetime(2015, 1, 1, 0, 0), 1725),\n",
       " (datetime.datetime(2014, 1, 1, 0, 0), 1306),\n",
       " (datetime.datetime(2013, 1, 1, 0, 0), 99),\n",
       " (datetime.datetime(2017, 1, 1, 0, 0), 25)]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT\n",
    "    DATE_TRUNC('year',occurred_at) year_total,\n",
    "\tCOUNT(*) num_orders\n",
    "FROM orders\n",
    "GROUP BY 1\n",
    "ORDER BY 2 DESC"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc8917c8-1102-407d-a32c-1c708a6e3d23",
   "metadata": {},
   "source": [
    "Which month did Parch & Posey have the greatest sales in terms of total number of orders? Are all months evenly represented by the dataset?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "197b0938-cbf2-4aa5-b6bf-e7569e89e0ef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "38 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>year_total</th>\n",
       "            <th>num_orders</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>2016-12-01 00:00:00</td>\n",
       "            <td>463</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2016-11-01 00:00:00</td>\n",
       "            <td>425</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2016-10-01 00:00:00</td>\n",
       "            <td>389</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2016-09-01 00:00:00</td>\n",
       "            <td>350</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2016-08-01 00:00:00</td>\n",
       "            <td>341</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(datetime.datetime(2016, 12, 1, 0, 0), 463),\n",
       " (datetime.datetime(2016, 11, 1, 0, 0), 425),\n",
       " (datetime.datetime(2016, 10, 1, 0, 0), 389),\n",
       " (datetime.datetime(2016, 9, 1, 0, 0), 350),\n",
       " (datetime.datetime(2016, 8, 1, 0, 0), 341)]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT\n",
    "    DATE_TRUNC('months',occurred_at) year_total,\n",
    "\tCOUNT(*) num_orders\n",
    "FROM orders\n",
    "GROUP BY 1\n",
    "ORDER BY 2 DESC"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ed6ab0a-3e0d-499a-be49-56264048d506",
   "metadata": {},
   "source": [
    "In which month of which year did Walmart spend the most on gloss paper in terms of dollars?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "7e931f00-f0c9-49da-be0c-8862ceffd495",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>ord_date</th>\n",
       "            <th>tot_spent</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>2016-05-01 00:00:00</td>\n",
       "            <td>9257.64</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(datetime.datetime(2016, 5, 1, 0, 0), Decimal('9257.64'))]"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT DATE_TRUNC('month', o.occurred_at) ord_date, SUM(o.gloss_amt_usd) tot_spent\n",
    "FROM orders o \n",
    "JOIN accounts a\n",
    "ON a.id = o.account_id\n",
    "WHERE a.name = 'Walmart'\n",
    "GROUP BY 1\n",
    "ORDER BY 2 DESC\n",
    "LIMIT 1;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1bee55a-20df-424f-a4b7-45990e9de7c5",
   "metadata": {},
   "source": [
    "Again, I made this much more complicated than it needed to be: all we needed to do was compute a list of all months detailing Walmart's spend on gloss paper. Sort descending. Limit 1. Done.\n",
    "\n",
    "Note: DATE_TRUNC does not truncate anything to the left of the specified time unit, so the year remains. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6a6eda7-cc3d-4abe-b2f2-6a72d2f8244b",
   "metadata": {},
   "source": [
    "## Concept 31. Quiz: CASE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d805dd5a-5e39-4790-8b0a-5512ad0a77e0",
   "metadata": {},
   "source": [
    "Write a query to display for each order, the account ID, total amount of the order, and the level of the order - ‘Large’ or ’Small’ - depending on if the order is $3000 or more, or smaller than $3000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "edf4a7e7-5390-4dd6-8ae1-b04f8d04a75b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "6912 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>account_id</th>\n",
       "            <th>total_amt_usd</th>\n",
       "            <th>order_level</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>1001</td>\n",
       "            <td>973.43</td>\n",
       "            <td>Small</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1001</td>\n",
       "            <td>1718.03</td>\n",
       "            <td>Small</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1001</td>\n",
       "            <td>776.18</td>\n",
       "            <td>Small</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1001</td>\n",
       "            <td>958.24</td>\n",
       "            <td>Small</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1001</td>\n",
       "            <td>983.49</td>\n",
       "            <td>Small</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(1001, Decimal('973.43'), 'Small'),\n",
       " (1001, Decimal('1718.03'), 'Small'),\n",
       " (1001, Decimal('776.18'), 'Small'),\n",
       " (1001, Decimal('958.24'), 'Small'),\n",
       " (1001, Decimal('983.49'), 'Small')]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT o.account_id, o.total_amt_usd,\n",
    "    CASE WHEN o.total_amt_usd >= 3000 THEN 'Large' ELSE 'Small' END AS order_level\n",
    "FROM orders o"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a378919f-fbe8-40dd-8163-d0d6007a5001",
   "metadata": {},
   "source": [
    "Write a query to display the number of orders in each of three categories, based on the total number of items in each order. The three categories are: 'At Least 2000', 'Between 1000 and 2000' and 'Less than 1000'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "6c4ba9be-4e36-4067-93cb-11275d4e1d8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "3 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>category</th>\n",
       "            <th>count</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Less than 1000</td>\n",
       "            <td>1270</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>At Least 2000</td>\n",
       "            <td>4072</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Between 1000 and 2000</td>\n",
       "            <td>1570</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Less than 1000', 1270),\n",
       " ('At Least 2000', 4072),\n",
       " ('Between 1000 and 2000', 1570)]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT \n",
    "    CASE\n",
    "        WHEN o.total_amt_usd >= 2000 THEN 'At Least 2000'\n",
    "        WHEN o.total_amt_usd < 2000 AND o.total_amt_usd >= 1000 THEN 'Between 1000 and 2000'\n",
    "        ELSE 'Less than 1000' END AS category,\n",
    "    COUNT(*)\n",
    "FROM orders o\n",
    "GROUP BY 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6231089-4d05-4727-bb00-3a5b55cd9931",
   "metadata": {},
   "source": [
    "We would like to understand 3 different levels of customers based on the amount associated with their purchases.\n",
    "\n",
    "The top level includes anyone with a Lifetime Value (total sales of all orders) greater than 200,000 usd.\n",
    "\n",
    "The second level is between 200,000 and 100,000 usd.\n",
    "\n",
    "The lowest level is anyone under 100,000 usd.\n",
    "\n",
    "Provide a table that includes the level associated with each account.\n",
    "\n",
    "You should provide the account name, the total sales of all orders for the customer, and the level. Order with the top spending customers listed first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "870f6b8f-2fff-4444-83f9-ab4a09a3b641",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "350 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>name</th>\n",
       "            <th>sum</th>\n",
       "            <th>level</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>EOG Resources</td>\n",
       "            <td>382873.30</td>\n",
       "            <td>Greater than 200,000 usd</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Mosaic</td>\n",
       "            <td>345618.59</td>\n",
       "            <td>Greater than 200,000 usd</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>IBM</td>\n",
       "            <td>326819.48</td>\n",
       "            <td>Greater than 200,000 usd</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>General Dynamics</td>\n",
       "            <td>300694.79</td>\n",
       "            <td>Greater than 200,000 usd</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Republic Services</td>\n",
       "            <td>293861.14</td>\n",
       "            <td>Greater than 200,000 usd</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('EOG Resources', Decimal('382873.30'), 'Greater than 200,000 usd'),\n",
       " ('Mosaic', Decimal('345618.59'), 'Greater than 200,000 usd'),\n",
       " ('IBM', Decimal('326819.48'), 'Greater than 200,000 usd'),\n",
       " ('General Dynamics', Decimal('300694.79'), 'Greater than 200,000 usd'),\n",
       " ('Republic Services', Decimal('293861.14'), 'Greater than 200,000 usd')]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT a.name, SUM(o.total_amt_usd),\n",
    "    CASE\n",
    "        WHEN SUM(o.total_amt_usd) > 200000 THEN 'Greater than 200,000 usd'\n",
    "        WHEN SUM(o.total_amt_usd) <= 200000 AND SUM(o.total_amt_usd) >= 100000 THEN 'Between 200,000 and 100,000 usd'\n",
    "        ELSE 'Under 100,000 usd'\n",
    "        END as level\n",
    "FROM orders o\n",
    "JOIN accounts a\n",
    "ON o.account_id = a.id\n",
    "GROUP BY 1\n",
    "ORDER BY 2 DESC"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e92797dc-efc0-44ae-b136-188f7ffd5ca5",
   "metadata": {},
   "source": [
    "We would now like to perform a similar calculation to the first, but we want to obtain the total amount spent by customers only in 2016 and 2017. Keep the same levels as in the previous question. Order with the top spending customers listed first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "f7bcadae-af4b-4a27-9e63-d4ac3d159bc8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "322 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>name</th>\n",
       "            <th>sum</th>\n",
       "            <th>level</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Pacific Life</td>\n",
       "            <td>255319.18</td>\n",
       "            <td>Greater than 200,000 usd</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Mosaic</td>\n",
       "            <td>172180.04</td>\n",
       "            <td>Between 200,000 and 100,000 usd</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>CHS</td>\n",
       "            <td>163471.78</td>\n",
       "            <td>Between 200,000 and 100,000 usd</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Core-Mark Holding</td>\n",
       "            <td>148105.93</td>\n",
       "            <td>Between 200,000 and 100,000 usd</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Disney</td>\n",
       "            <td>129157.38</td>\n",
       "            <td>Between 200,000 and 100,000 usd</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Pacific Life', Decimal('255319.18'), 'Greater than 200,000 usd'),\n",
       " ('Mosaic', Decimal('172180.04'), 'Between 200,000 and 100,000 usd'),\n",
       " ('CHS', Decimal('163471.78'), 'Between 200,000 and 100,000 usd'),\n",
       " ('Core-Mark Holding', Decimal('148105.93'), 'Between 200,000 and 100,000 usd'),\n",
       " ('Disney', Decimal('129157.38'), 'Between 200,000 and 100,000 usd')]"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT a.name, SUM(o.total_amt_usd),\n",
    "    CASE\n",
    "        WHEN SUM(o.total_amt_usd) > 200000 THEN 'Greater than 200,000 usd'\n",
    "        WHEN SUM(o.total_amt_usd) <= 200000 AND SUM(o.total_amt_usd) >= 100000 THEN 'Between 200,000 and 100,000 usd'\n",
    "        ELSE 'Under 100,000 usd'\n",
    "        END AS level\n",
    "FROM orders o\n",
    "JOIN accounts a\n",
    "ON o.account_id = a.id\n",
    "WHERE o.occurred_at BETWEEN '2016-01-01' AND '2018-01-01'\n",
    "GROUP BY 1\n",
    "ORDER BY 2 DESC"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1733caa2-8007-409a-8d9d-d19e94edb6e7",
   "metadata": {},
   "source": [
    "We would like to identify top performing sales reps, which are sales reps associated with more than 200 orders. Create a table with the sales rep name, the total number of orders, and a column with top or not depending on if they have more than 200 orders. Place the top sales people first in your final table.\n",
    "\n",
    "- Columns required: rep_name, num_orders, top\n",
    "- Group by: rep_name\n",
    "- Order by order_count (descending)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "a72143f8-4c58-4389-bb04-1c0fb3a94157",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "50 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>rep_name</th>\n",
       "            <th>num_orders</th>\n",
       "            <th>top_not</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Earlie Schleusner</td>\n",
       "            <td>335</td>\n",
       "            <td>top</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Vernita Plump</td>\n",
       "            <td>299</td>\n",
       "            <td>top</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Tia Amato</td>\n",
       "            <td>267</td>\n",
       "            <td>top</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Georgianna Chisholm</td>\n",
       "            <td>256</td>\n",
       "            <td>top</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Moon Torian</td>\n",
       "            <td>250</td>\n",
       "            <td>top</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Earlie Schleusner', 335, 'top'),\n",
       " ('Vernita Plump', 299, 'top'),\n",
       " ('Tia Amato', 267, 'top'),\n",
       " ('Georgianna Chisholm', 256, 'top'),\n",
       " ('Moon Torian', 250, 'top')]"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT s.name rep_name, COUNT(o.*) num_orders,\n",
    "    CASE\n",
    "        WHEN COUNT(o.*) > 200 THEN 'top'\n",
    "        ELSE 'not'\n",
    "        END AS top_not\n",
    "FROM orders o\n",
    "JOIN accounts a\n",
    "ON o.account_id = a.id\n",
    "JOIN sales_reps s\n",
    "ON a.sales_rep_id = s.id\n",
    "GROUP BY 1\n",
    "ORDER BY 2 DESC"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11781502-c276-4c86-9209-b203da791411",
   "metadata": {},
   "source": [
    "The previous didn't account for the middle, nor the dollar amount associated with the sales. Management decides they want to see these characteristics represented as well.\n",
    "\n",
    "We would like to identify top performing sales reps, which are sales reps associated with more than 200 orders or more than 750000 in total sales.\n",
    "\n",
    "The middle group has any rep with more than 150 orders or 500000 in sales.\n",
    "\n",
    "Create a table with:\n",
    "- the sales rep name\n",
    "- the total number of orders\n",
    "- total sales across all orders\n",
    "- a column with top, middle, or low depending on this criteria.\n",
    "\n",
    "Place the top sales people based on dollar amount of sales first in your final table.\n",
    "\n",
    "You might see a few upset sales people by this criteria!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "535ef4ec-a0f9-424c-bc58-82db5c77ede8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "50 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>rep_name</th>\n",
       "            <th>num_orders</th>\n",
       "            <th>total_sales</th>\n",
       "            <th>top_not</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Earlie Schleusner</td>\n",
       "            <td>335</td>\n",
       "            <td>1098137.72</td>\n",
       "            <td>top</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Tia Amato</td>\n",
       "            <td>267</td>\n",
       "            <td>1010690.60</td>\n",
       "            <td>top</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Vernita Plump</td>\n",
       "            <td>299</td>\n",
       "            <td>934212.93</td>\n",
       "            <td>top</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Georgianna Chisholm</td>\n",
       "            <td>256</td>\n",
       "            <td>886244.12</td>\n",
       "            <td>top</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Arica Stoltzfus</td>\n",
       "            <td>186</td>\n",
       "            <td>810353.34</td>\n",
       "            <td>top</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Earlie Schleusner', 335, Decimal('1098137.72'), 'top'),\n",
       " ('Tia Amato', 267, Decimal('1010690.60'), 'top'),\n",
       " ('Vernita Plump', 299, Decimal('934212.93'), 'top'),\n",
       " ('Georgianna Chisholm', 256, Decimal('886244.12'), 'top'),\n",
       " ('Arica Stoltzfus', 186, Decimal('810353.34'), 'top')]"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT s.name rep_name, COUNT(o.*) num_orders, SUM(o.total_amt_usd) total_sales,\n",
    "    CASE\n",
    "        WHEN COUNT(o.*) > 200 OR SUM(o.total_amt_usd) > 750000 THEN 'top'\n",
    "        WHEN\n",
    "            (COUNT(o.*) <= 200 AND COUNT(o.*) > 150)\n",
    "            OR\n",
    "            (SUM(o.total_amt_usd) <= 750000 AND SUM(o.total_amt_usd) > 500000) THEN 'middle'\n",
    "        ELSE 'not'\n",
    "        END AS top_not\n",
    "FROM orders o\n",
    "JOIN accounts a\n",
    "ON o.account_id = a.id\n",
    "JOIN sales_reps s\n",
    "ON a.sales_rep_id = s.id\n",
    "GROUP BY 1\n",
    "ORDER BY 3 DESC"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91a0513f-da4a-4ccf-8fe3-3d5054369a06",
   "metadata": {},
   "source": [
    "We want to find the average number of events for each day for each channel. The first table will provide us the number of events for each day and channel, and then we will need to average these values together using a second query.\n",
    "\n",
    "An attempt to abstract the wordy description into a framework which simplifies the production of an SQL statement:\n",
    "\n",
    "* Time period: day\n",
    "* Output: number of events during time period\n",
    "* Group by: channel, day"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "057365b5-d219-42d1-91df-7b208bc6c75f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "6 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>channel</th>\n",
       "            <th>avg_channel_count</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>adwords</td>\n",
       "            <td>1.5701906412478336</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>banner</td>\n",
       "            <td>1.2899728997289973</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>direct</td>\n",
       "            <td>4.8964879852125693</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>facebook</td>\n",
       "            <td>1.5983471074380165</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>organic</td>\n",
       "            <td>1.6672504378283713</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('adwords', Decimal('1.5701906412478336')),\n",
       " ('banner', Decimal('1.2899728997289973')),\n",
       " ('direct', Decimal('4.8964879852125693')),\n",
       " ('facebook', Decimal('1.5983471074380165')),\n",
       " ('organic', Decimal('1.6672504378283713'))]"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT channel,\n",
    "    AVG(channel_count) avg_channel_count\n",
    "FROM\n",
    "(SELECT DATE_TRUNC('day', w.occurred_at),\n",
    "    w.channel,\n",
    "    COUNT(*) channel_count\n",
    "FROM web_events w\n",
    "GROUP BY 1,2\n",
    "ORDER BY 1) sub\n",
    "GROUP BY 1\n",
    "ORDER BY 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75885b6d-cc10-4157-bd25-3434a5a34461",
   "metadata": {},
   "source": [
    "First month an order was placed?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "c32ed96f-d86e-4c7e-874b-dd9ae5918491",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>date_trunc</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>2013-12-01 00:00:00</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(datetime.datetime(2013, 12, 1, 0, 0),)]"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT DATE_TRUNC('month', MIN(occurred_at)) FROM orders"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae0e75bc-d314-4be8-b822-289d4cfbf413",
   "metadata": {},
   "source": [
    "The average amount of standard paper sold on the first month that any order was placed in the orders table (in terms of quantity).\n",
    "\n",
    "The average amount of gloss paper sold on the first month that any order was placed in the orders table (in terms of quantity).\n",
    "\n",
    "The average amount of poster paper sold on the first month that any order was placed in the orders table (in terms of quantity).\n",
    "\n",
    "The total amount spent on all orders on the first month that any order was placed in the orders table (in terms of usd)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "6ab8768a-f7c1-42e8-9ffb-c90a84d54494",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "(psycopg2.errors.SyntaxError) syntax error at or near \"SUM\"\n",
      "LINE 5:     SUM(total_amt_usd) total_usd\n",
      "            ^\n",
      "\n",
      "[SQL: SELECT\n",
      "    AVG(standard_qty) avg_standard,\n",
      "    AVG(gloss_qty) avg_gloss,\n",
      "    AVG(poster_qty) avg_poster\n",
      "    SUM(total_amt_usd) total_usd\n",
      "FROM orders\n",
      "WHERE DATE_TRUNC('month', occurred_at) = \n",
      "(SELECT DATE_TRUNC('month', MIN(occurred_at)) AS min_month FROM orders)]\n",
      "(Background on this error at: https://sqlalche.me/e/14/f405)\n"
     ]
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT\n",
    "    AVG(standard_qty) avg_standard,\n",
    "    AVG(gloss_qty) avg_gloss,\n",
    "    AVG(poster_qty) avg_poster\n",
    "    SUM(total_amt_usd) total_usd\n",
    "FROM orders\n",
    "WHERE DATE_TRUNC('month', occurred_at) = \n",
    "(SELECT DATE_TRUNC('month', MIN(occurred_at)) AS min_month FROM orders)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fcced7c-58c1-4165-a3c2-1687b0519c07",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Lesson 4. Concept 9. Quiz: Subquery Mania\n",
    "\n",
    "> __I PUT A LOT OF TIME INTO THESE NOTES!!!!!!!!__\n",
    "\n",
    "Provide the name of the sales_rep in each region with the largest amount of total_amt_usd sales.\n",
    "\n",
    " - Group by: Region\n",
    " - Return: Sales rep\n",
    " - Filter by: MAX(total_amt_usd) <<==== THIS IS A CLUE: \"FILTER\" MIGHT SUGGEST USING JOIN\n",
    "\n",
    " - SUM(total_amt_usd) by sales rep by region\n",
    "\n",
    "Or\n",
    "\n",
    "- Calculate the SUM(total_amt_usd) for each sales rep.\n",
    "- Find the maximum for each region\n",
    "- List that max and the sales rep for each region <<==== THIS IS A CLUE: COMBINING MIGHT SUGGEST USING JOIN\n",
    "\n",
    "Problem 1: what if two sales reps have sold the same max amount in any region?\n",
    "\n",
    "Problem 2: Care must be taken to ensure that sales reps with same value sales in different regions aren't bulked together\n",
    "\n",
    "My effort:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "2b0cc5bb-f0e0-4e53-b4aa-902bf5163dca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "50 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>sales_rep</th>\n",
       "            <th>region_name</th>\n",
       "            <th>total_sales</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Earlie Schleusner</td>\n",
       "            <td>Southeast</td>\n",
       "            <td>1098137.72</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Tia Amato</td>\n",
       "            <td>Northeast</td>\n",
       "            <td>1010690.60</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Vernita Plump</td>\n",
       "            <td>Southeast</td>\n",
       "            <td>934212.93</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Georgianna Chisholm</td>\n",
       "            <td>West</td>\n",
       "            <td>886244.12</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Arica Stoltzfus</td>\n",
       "            <td>West</td>\n",
       "            <td>810353.34</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Earlie Schleusner', 'Southeast', Decimal('1098137.72')),\n",
       " ('Tia Amato', 'Northeast', Decimal('1010690.60')),\n",
       " ('Vernita Plump', 'Southeast', Decimal('934212.93')),\n",
       " ('Georgianna Chisholm', 'West', Decimal('886244.12')),\n",
       " ('Arica Stoltzfus', 'West', Decimal('810353.34'))]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT s.name sales_rep, r.name region_name, SUM(total_amt_usd) total_sales\n",
    "FROM orders o\n",
    "JOIN accounts a\n",
    "ON o.account_id = a.id\n",
    "JOIN sales_reps s\n",
    "ON a.sales_rep_id = s.id\n",
    "JOIN region r\n",
    "ON s.region_id = r.id\n",
    "GROUP BY 1, 2\n",
    "ORDER BY 3 DESC"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70838e98-2d40-49db-a444-dd2e7054fda4",
   "metadata": {},
   "source": [
    "Developed slightly with a clue from the solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "378b2634-fda9-409c-8ccc-85e4140ceb82",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "4 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>region_name</th>\n",
       "            <th>max</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Midwest</td>\n",
       "            <td>675637.19</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Southeast</td>\n",
       "            <td>1098137.72</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>West</td>\n",
       "            <td>886244.12</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>1010690.60</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Midwest', Decimal('675637.19')),\n",
       " ('Southeast', Decimal('1098137.72')),\n",
       " ('West', Decimal('886244.12')),\n",
       " ('Northeast', Decimal('1010690.60'))]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT region_name, MAX(total_sales)\n",
    "FROM (\n",
    "    SELECT s.name sales_rep, r.name region_name, SUM(total_amt_usd) total_sales\n",
    "    FROM orders o\n",
    "    JOIN accounts a\n",
    "    ON o.account_id = a.id\n",
    "    JOIN sales_reps s\n",
    "    ON a.sales_rep_id = s.id\n",
    "    JOIN region r\n",
    "    ON s.region_id = r.id\n",
    "    GROUP BY 1, 2\n",
    "    ORDER BY 3 DESC\n",
    ") AS Table1\n",
    "GROUP BY 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b356148d-9e18-41fd-ba7b-b84632320c80",
   "metadata": {
    "tags": []
   },
   "source": [
    "But I didn't get far enough. The solution is shown below.\n",
    "\n",
    "I kept thinking about how to create a query that would return a table with just the maximum value from each region (I had in mind the use of TRIM) but actually this method is much more straightforward: join the two tables above together.\n",
    "\n",
    "It occured to me that there's loads of repetition going on (in terms of joins etc) but this evidently don't matter.\n",
    "\n",
    "Breakdown:\n",
    "1. Calculate the sum of each agents sales within each region. This can be done by grouping by region, agent, with aggregate sum(total_amt_usd). Call this table t1\n",
    "\n",
    "2. Identify the max agent's sum(total_amt_usd) from t1. Call this table t2.\n",
    "\n",
    "3. Join tables t2 and t1 together. Without using a WITH clause, you need to create a third table to do this. Join these tables on t2.region_name = t3.region_name AND t2.max_region_sum_total_amt_usd = t3.rep_sum_total_amt_usd. This bit is the magic: by matching the t3.total_amt (all agent's totals)= t2.total_amt (which is the max), we create a table which only lists those agents with the max sales per region."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "d6866f95-a055-4624-ac0f-a3b0b9b07752",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "4 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>region_name</th>\n",
       "            <th>sales_rep_name</th>\n",
       "            <th>sum_total_amt_usd</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Midwest</td>\n",
       "            <td>Charles Bidwell</td>\n",
       "            <td>675637.19</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>Tia Amato</td>\n",
       "            <td>1010690.60</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Southeast</td>\n",
       "            <td>Earlie Schleusner</td>\n",
       "            <td>1098137.72</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>West</td>\n",
       "            <td>Georgianna Chisholm</td>\n",
       "            <td>886244.12</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Midwest', 'Charles Bidwell', Decimal('675637.19')),\n",
       " ('Northeast', 'Tia Amato', Decimal('1010690.60')),\n",
       " ('Southeast', 'Earlie Schleusner', Decimal('1098137.72')),\n",
       " ('West', 'Georgianna Chisholm', Decimal('886244.12'))]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT t2.region_name, t3.sales_rep_name, t3.sum_total_amt_usd\n",
    "FROM (\n",
    "    SELECT region_name, MAX(sum_total_amt_usd) max_region_sum_total_amt_usd\n",
    "    FROM (\n",
    "        -- Calculates total sales for each agent in each region\n",
    "        SELECT r.name region_name, s.name sales_rep_name, SUM(total_amt_usd) sum_total_amt_usd\n",
    "        FROM orders o\n",
    "        JOIN accounts a\n",
    "        ON o.account_id = a.id\n",
    "        JOIN sales_reps s\n",
    "        ON a.sales_rep_id = s.id\n",
    "        JOIN region r\n",
    "        ON s.region_id = r.id\n",
    "        GROUP BY 1, 2\n",
    "        ORDER BY 1\n",
    "        ) AS t1\n",
    "    GROUP BY 1\n",
    "    ORDER BY 1) as t2\n",
    "JOIN (\n",
    "    -- Calculates total sales for each agent in each region. Identical to t1!\n",
    "    SELECT r.name region_name, s.name sales_rep_name, SUM(total_amt_usd) sum_total_amt_usd\n",
    "    FROM orders o\n",
    "    JOIN accounts a\n",
    "    ON o.account_id = a.id\n",
    "    JOIN sales_reps s\n",
    "    ON a.sales_rep_id = s.id\n",
    "    JOIN region r\n",
    "    ON s.region_id = r.id\n",
    "    GROUP BY 2, 1\n",
    "    ORDER BY 1\n",
    ") AS t3\n",
    "ON t2.region_name = t3.region_name AND t2.max_region_sum_total_amt_usd = t3.sum_total_amt_usd\n",
    "ORDER BY 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2455848-bfd6-4192-8ed9-080c8a80800d",
   "metadata": {},
   "source": [
    "And the above can be further simplified using the WITH statement. Instead of identical subqueries which produce t1 and t3, we simply create/prepopulate a table t1 which contains the data we're interested in. This demonstrates how the creation of both t1 and t3 results in inefficiency as the tables are identical"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "60a3c0a4-c97e-4984-919c-961474962f18",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "4 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>region_name</th>\n",
       "            <th>sales_rep_name</th>\n",
       "            <th>sum_total_amt_usd</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Midwest</td>\n",
       "            <td>Charles Bidwell</td>\n",
       "            <td>675637.19</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>Tia Amato</td>\n",
       "            <td>1010690.60</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Southeast</td>\n",
       "            <td>Earlie Schleusner</td>\n",
       "            <td>1098137.72</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>West</td>\n",
       "            <td>Georgianna Chisholm</td>\n",
       "            <td>886244.12</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Midwest', 'Charles Bidwell', Decimal('675637.19')),\n",
       " ('Northeast', 'Tia Amato', Decimal('1010690.60')),\n",
       " ('Southeast', 'Earlie Schleusner', Decimal('1098137.72')),\n",
       " ('West', 'Georgianna Chisholm', Decimal('886244.12'))]"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "WITH t1 AS\n",
    "    (\n",
    "        -- Calculates total sales for each agent in each region\n",
    "        SELECT r.name region_name, s.name sales_rep_name, SUM(total_amt_usd) sum_total_amt_usd\n",
    "        FROM orders o\n",
    "        JOIN accounts a\n",
    "        ON o.account_id = a.id\n",
    "        JOIN sales_reps s\n",
    "        ON a.sales_rep_id = s.id\n",
    "        JOIN region r\n",
    "        ON s.region_id = r.id\n",
    "        GROUP BY 1, 2\n",
    "        ORDER BY 1\n",
    "    )\n",
    "\n",
    "SELECT t2.region_name, t1.sales_rep_name, t1.sum_total_amt_usd\n",
    "FROM (\n",
    "    SELECT region_name, MAX(sum_total_amt_usd) max_region_sum_total_amt_usd\n",
    "    FROM t1\n",
    "    GROUP BY 1\n",
    "    ORDER BY 1) as t2\n",
    "JOIN t1\n",
    "ON t2.region_name = t1.region_name AND t2.max_region_sum_total_amt_usd = t1.sum_total_amt_usd\n",
    "ORDER BY 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f31852a-35b0-45af-b350-0f946628d749",
   "metadata": {
    "tags": []
   },
   "source": [
    "And we can take it further (although this is simply easier to read, no less efficient because the omitted subquery was only run once anyway ):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "3ac8b26c-b3ea-46a7-a277-6170cf135470",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "4 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>region_name</th>\n",
       "            <th>sales_rep_name</th>\n",
       "            <th>sum_total_amt_usd</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Midwest</td>\n",
       "            <td>Charles Bidwell</td>\n",
       "            <td>675637.19</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>Tia Amato</td>\n",
       "            <td>1010690.60</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Southeast</td>\n",
       "            <td>Earlie Schleusner</td>\n",
       "            <td>1098137.72</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>West</td>\n",
       "            <td>Georgianna Chisholm</td>\n",
       "            <td>886244.12</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Midwest', 'Charles Bidwell', Decimal('675637.19')),\n",
       " ('Northeast', 'Tia Amato', Decimal('1010690.60')),\n",
       " ('Southeast', 'Earlie Schleusner', Decimal('1098137.72')),\n",
       " ('West', 'Georgianna Chisholm', Decimal('886244.12'))]"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "WITH t1 AS\n",
    "    (\n",
    "        -- Calculates total sales for each agent in each region\n",
    "        SELECT r.name region_name, s.name sales_rep_name, SUM(total_amt_usd) sum_total_amt_usd\n",
    "        FROM orders o\n",
    "        JOIN accounts a\n",
    "        ON o.account_id = a.id\n",
    "        JOIN sales_reps s\n",
    "        ON a.sales_rep_id = s.id\n",
    "        JOIN region r\n",
    "        ON s.region_id = r.id\n",
    "        GROUP BY 1, 2\n",
    "        ORDER BY 1\n",
    "    ),\n",
    "    \n",
    "    t2 AS\n",
    "    (\n",
    "        -- Identify the max sales any single agent made in each region\n",
    "        SELECT region_name, MAX(sum_total_amt_usd) max_region_sum_total_amt_usd\n",
    "        FROM t1\n",
    "        GROUP BY 1\n",
    "        ORDER BY 1\n",
    "    )\n",
    "\n",
    "SELECT t2.region_name, t1.sales_rep_name, t1.sum_total_amt_usd\n",
    "FROM t2\n",
    "JOIN t1\n",
    "ON t2.region_name = t1.region_name AND t2.max_region_sum_total_amt_usd = t1.sum_total_amt_usd\n",
    "ORDER BY 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e1cda50-b414-4451-b270-1dff22cd65e2",
   "metadata": {},
   "source": [
    "For the region with the largest (sum) of sales total_amt_usd, how many total (count) orders were placed?\n",
    "\n",
    "Breakdown:\n",
    "1. Which region has the largest SUM(total_amt_usd)?\n",
    "2. What is the COUNT(*) of orders for that region? We could join tables together here...\n",
    "\n",
    "Approach:\n",
    "1. Create a table (t1) listing region_name and SUM(total_amt_usd) region_total_sales\n",
    "2. Create a table (t2) listing region_name and MAX(region_total_sales) from t1\n",
    "3. Create a table (t3) listing all orders and COUNT() number_orders for region_name from t2. This might be t2 joined with another table (t4) listing all orders.\n",
    "\n",
    "OR (having peeked at the solution):\n",
    "\n",
    "2. Create a table (t2) listing solely a single value MAX(region_total_sales) from t1 (this is called a SCALAR SUBQUERY apparently)\n",
    "3. Create a table listing regions and a count of all orders for each.\n",
    "4. Add a HAVING statement to list only the entry which has the same value as returned by step 2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "ffcc6bff-ae49-4aa4-933f-665864f8dd42",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>region_name</th>\n",
       "            <th>sales_count</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>2357</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Northeast', 2357)]"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT r.name region_name, COUNT(*) sales_count\n",
    "FROM orders o\n",
    "JOIN accounts a\n",
    "ON o.account_id = a.id\n",
    "JOIN sales_reps s\n",
    "ON a.sales_rep_id = s.id\n",
    "JOIN region r\n",
    "ON s.region_id = r.id\n",
    "GROUP BY 1\n",
    "HAVING SUM(o.total_amt_usd) = (\n",
    "    SELECT MAX(total_sales)\n",
    "    FROM (\n",
    "        SELECT r.name region_name, SUM(o.total_amt_usd) total_sales\n",
    "        FROM orders o\n",
    "        JOIN accounts a\n",
    "        ON o.account_id = a.id\n",
    "        JOIN sales_reps s\n",
    "        ON a.sales_rep_id = s.id\n",
    "        JOIN region r\n",
    "        ON s.region_id = r.id\n",
    "        GROUP BY 1) t1\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9a2ae4e-b332-44fa-93f6-2fb3d11c47bf",
   "metadata": {
    "tags": []
   },
   "source": [
    "How many accounts had more total purchases than the account name which has bought the most standard_qty paper throughout their lifetime as a customer?\n",
    "\n",
    "Breakdown\n",
    "1. What is the most standard_qty paper purchased by any one account?\n",
    "2. List total purchases by account: a.name, standard_qty + poster_qty + gloss_qty\n",
    "3. Add HAVING clause SUM()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "9298aea1-826a-4559-8d31-f2f3bb9da748",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "6 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>account_name</th>\n",
       "            <th>sum</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>EOG Resources</td>\n",
       "            <td>56410</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Mosaic</td>\n",
       "            <td>49246</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>IBM</td>\n",
       "            <td>47506</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Core-Mark Holding</td>\n",
       "            <td>44750</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>General Dynamics</td>\n",
       "            <td>43730</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('EOG Resources', 56410),\n",
       " ('Mosaic', 49246),\n",
       " ('IBM', 47506),\n",
       " ('Core-Mark Holding', 44750),\n",
       " ('General Dynamics', 43730)]"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT a.name account_name, SUM(o.total) \n",
    "FROM orders o\n",
    "JOIN accounts a\n",
    "ON o.account_id = a.id\n",
    "GROUP BY 1\n",
    "HAVING SUM(o.total) > (\n",
    "    SELECT MAX(sum_standard_qty)\n",
    "    FROM (\n",
    "        SELECT a.name account_max_standard_qty, SUM(standard_qty) sum_standard_qty\n",
    "        FROM orders o\n",
    "        JOIN accounts a\n",
    "        ON o.account_id = a.id\n",
    "        GROUP BY 1\n",
    "        ORDER BY 2 DESC\n",
    "    ) t1\n",
    ")\n",
    "ORDER BY 2 DESC"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "283d0379-191d-4a8c-aa89-8b5eaf673fd8",
   "metadata": {},
   "source": [
    "Not a bad attempt (above) but I made a couple of mistakes:\n",
    "- In the HAVING clause, I selected the max value of sum_standard_qty. I should have selected the max value of sum_total (which would have needed to be added to t1's select clause). The way I have done it, any total quantities over the sum_standard_qty value would have been returned (which is not what the question asked for). Returning the total quantity for the account with the max standard qty is easy: just add SUM(o.total) to t1's select clause.\n",
    "\n",
    "- Using MAX(total) (having included changes as per last point) results in the maximum value in the total column being returned, not the corresponding total value for the account with the max sum_standard_qty column. The solution here is to use LIMIT to restrict the returned rows. However, this doesn't feel like \"best practice\"...\n",
    "\n",
    "- My approach simply returns the list of relevant account names (ie those with value of orders above a certain value). But the question asked for the number of accounts: so I should have added a COUNT clause over the whole query.\n",
    "\n",
    "- Also, I didn't note that there's already a o.total value which suffices for standard_qty + gloss_qty etc\n",
    "\n",
    "Corrected:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "ca169958-4bd5-427f-b75f-d1c8d0dd720d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>count</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>3</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(3,)]"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT COUNT(*) FROM (\n",
    "    SELECT a.name account_name, SUM(o.total) \n",
    "    FROM orders o\n",
    "    JOIN accounts a\n",
    "    ON o.account_id = a.id\n",
    "    GROUP BY 1\n",
    "    HAVING SUM(o.total) > (\n",
    "        SELECT total\n",
    "        FROM (\n",
    "            SELECT a.name account_max_standard_qty, SUM(standard_qty) sum_standard_qty, SUM(o.total) total\n",
    "            FROM orders o\n",
    "            JOIN accounts a\n",
    "            ON o.account_id = a.id\n",
    "            GROUP BY 1\n",
    "            ORDER BY 2 DESC\n",
    "            LIMIT 1\n",
    "            ) t1\n",
    "    )\n",
    "    ORDER BY 2 DESC\n",
    ") as t2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "764041cd-56d4-49b8-9520-c3f4a44e96dc",
   "metadata": {
    "tags": []
   },
   "source": [
    "Provided solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "537628c1-73e6-4576-858e-6ac14a74e685",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>count</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>3</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(3,)]"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT COUNT(*)\n",
    "FROM (SELECT a.name\n",
    "       FROM orders o\n",
    "       JOIN accounts a\n",
    "       ON a.id = o.account_id\n",
    "       GROUP BY 1\n",
    "       HAVING SUM(o.total) > (SELECT total \n",
    "                   FROM (SELECT a.name act_name, SUM(o.standard_qty) tot_std, SUM(o.total) total\n",
    "                         FROM accounts a\n",
    "                         JOIN orders o\n",
    "                         ON o.account_id = a.id\n",
    "                         GROUP BY 1\n",
    "                         ORDER BY 2 DESC\n",
    "                         LIMIT 1) inner_tab)\n",
    "             ) counter_tab;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afb42cf8-0c58-4cbe-8f59-b0dd8acc944b",
   "metadata": {},
   "source": [
    "For the customer that spent the most (in total over their lifetime as a customer) total_amt_usd, how many web_events did they have for each channel?\n",
    "\n",
    "Breakdown\n",
    "1. Which customer spent the most? accounts, orders, web_events\n",
    "2. How many web_events did they have? Group by channel\n",
    "\n",
    "Desired derived table:\n",
    "\n",
    "account_name    |   channel |   num_web_events\n",
    "\n",
    "Specification:\n",
    "WHERE account_name = *account_name which had spent the most*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "91b0e5df-555a-4b4a-9eba-55cb2343035e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "6 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>channel</th>\n",
       "            <th>count</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>adwords</td>\n",
       "            <td>744</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>twitter</td>\n",
       "            <td>310</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>organic</td>\n",
       "            <td>806</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>banner</td>\n",
       "            <td>248</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>facebook</td>\n",
       "            <td>682</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('adwords', 744),\n",
       " ('twitter', 310),\n",
       " ('organic', 806),\n",
       " ('banner', 248),\n",
       " ('facebook', 682)]"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT w.channel, COUNT(*)\n",
    "FROM orders o\n",
    "JOIN accounts a\n",
    "ON a.id = o.account_id\n",
    "JOIN web_events w\n",
    "ON a.id = w.account_id\n",
    "WHERE a.name = (\n",
    "    SELECT account_name\n",
    "    FROM (\n",
    "        SELECT a.name account_name, SUM(o.total_amt_usd) total\n",
    "        FROM orders o\n",
    "        JOIN accounts a\n",
    "        ON a.id = o.account_id\n",
    "        JOIN web_events w\n",
    "        ON a.id = w.account_id\n",
    "        GROUP BY 1\n",
    "        ORDER BY 2 DESC\n",
    "        LIMIT 1\n",
    "    ) AS t1\n",
    ")\n",
    "GROUP BY 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32071b7e-e4bf-4af5-bab1-83f3d0847f7b",
   "metadata": {
    "tags": []
   },
   "source": [
    "Again, another decent effort. However, I joined too many tables together, and this produced much larger numbers of rows, which in turn increased the count massively.\n",
    "\n",
    "TAKE CARE ONLY TO JOIN ONLY NECESSARY TABLES\n",
    "\n",
    "With some corrections:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "776e8507-9d3c-474e-8da9-13d199c675f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "6 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>channel</th>\n",
       "            <th>count</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>adwords</td>\n",
       "            <td>12</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>banner</td>\n",
       "            <td>4</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>direct</td>\n",
       "            <td>44</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>facebook</td>\n",
       "            <td>11</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>organic</td>\n",
       "            <td>13</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('adwords', 12),\n",
       " ('banner', 4),\n",
       " ('direct', 44),\n",
       " ('facebook', 11),\n",
       " ('organic', 13)]"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT w.channel, COUNT(*)\n",
    "FROM accounts a\n",
    "JOIN web_events w\n",
    "ON a.id = w.account_id\n",
    "WHERE a.name = ( -- I could have, instead, replaced WHERE with AND (which would have joined web_events and accounts on a.id = w.account_id AND a.name = *account name with greatest total_amt_usd)\n",
    "    SELECT account_name\n",
    "    FROM (\n",
    "        SELECT a.name account_name, SUM(o.total_amt_usd) total\n",
    "        FROM orders o\n",
    "        JOIN accounts a\n",
    "        ON a.id = o.account_id\n",
    "        GROUP BY 1\n",
    "        ORDER BY 2 DESC\n",
    "        LIMIT 1\n",
    "    ) AS t1\n",
    ")\n",
    "GROUP BY 1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6586f0f6-3120-4d9f-bdbc-e38afda22d2f",
   "metadata": {},
   "source": [
    "Provided solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "3d1c1118-c3e5-489f-9af2-3ca61352c230",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "6 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>name</th>\n",
       "            <th>channel</th>\n",
       "            <th>count</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>EOG Resources</td>\n",
       "            <td>direct</td>\n",
       "            <td>44</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>EOG Resources</td>\n",
       "            <td>organic</td>\n",
       "            <td>13</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>EOG Resources</td>\n",
       "            <td>adwords</td>\n",
       "            <td>12</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>EOG Resources</td>\n",
       "            <td>facebook</td>\n",
       "            <td>11</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>EOG Resources</td>\n",
       "            <td>twitter</td>\n",
       "            <td>5</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('EOG Resources', 'direct', 44),\n",
       " ('EOG Resources', 'organic', 13),\n",
       " ('EOG Resources', 'adwords', 12),\n",
       " ('EOG Resources', 'facebook', 11),\n",
       " ('EOG Resources', 'twitter', 5)]"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT a.name, w.channel, COUNT(*)\n",
    "FROM accounts a\n",
    "JOIN web_events w\n",
    "ON a.id = w.account_id AND a.id =  (SELECT id\n",
    "                     FROM (SELECT a.id, a.name, SUM(o.total_amt_usd) tot_spent\n",
    "                           FROM orders o\n",
    "                           JOIN accounts a\n",
    "                           ON a.id = o.account_id\n",
    "                           GROUP BY a.id, a.name\n",
    "                           ORDER BY 3 DESC\n",
    "                           LIMIT 1) inner_table)\n",
    "GROUP BY 1, 2\n",
    "ORDER BY 3 DESC"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d5ad858-a16e-4f5f-a9ee-79ac7914678b",
   "metadata": {
    "tags": []
   },
   "source": [
    "The last line isn't really necessary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8798b5e8-29a1-49dd-8bd4-e5ed7a861190",
   "metadata": {},
   "source": [
    "What is the lifetime average amount spent in terms of total_amt_usd for the top 10 total spending accounts?\n",
    "\n",
    "Breakdown\n",
    "1. What are top 10 total spending accounts?\n",
    "2. What is the average of total_amt_usd of all orders for each of the above?\n",
    "\n",
    "Desired derived table:\n",
    "Join on o.account_id = a.id AND a.name = account_name (top 10 total spending accounts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "ee9a4695-becd-47e4-8d97-33cab5efcbb2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "10 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>account_id</th>\n",
       "            <th>avg</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>4211</td>\n",
       "            <td>6175.3758064516129032</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>4111</td>\n",
       "            <td>5877.2228000000000000</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1301</td>\n",
       "            <td>5446.9913333333333333</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>4151</td>\n",
       "            <td>5236.6453030303030303</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1871</td>\n",
       "            <td>4555.9816666666666667</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(4211, Decimal('6175.3758064516129032')),\n",
       " (4111, Decimal('5877.2228000000000000')),\n",
       " (1301, Decimal('5446.9913333333333333')),\n",
       " (4151, Decimal('5236.6453030303030303')),\n",
       " (1871, Decimal('4555.9816666666666667'))]"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT account_id, AVG(total_amt_usd)\n",
    "FROM orders o\n",
    "JOIN (\n",
    "    SELECT account_id account_id2, SUM(total_amt_usd)\n",
    "    FROM orders o\n",
    "    GROUP BY account_id\n",
    "    ORDER BY 2 DESC\n",
    "    LIMIT 10\n",
    ") AS t1\n",
    "ON t1.account_id2 = o.account_id\n",
    "GROUP BY 1\n",
    "ORDER BY 2 DESC"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96c3ac4c-1eba-4b2f-a1d7-057292e45a80",
   "metadata": {},
   "source": [
    "Turns out I misinterpreted the question, or the question was badly worded...\n",
    "\n",
    "To test my answer:\n",
    "\n",
    "1. What's the ID of the account with the greatest spend?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "dc9e8e8c-bc5d-40e5-8e95-fba43728a1ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>account_id2</th>\n",
       "            <th>sum</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>4211</td>\n",
       "            <td>382873.30</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(4211, Decimal('382873.30'))]"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT account_id account_id2, SUM(total_amt_usd)\n",
    "FROM orders o\n",
    "GROUP BY account_id\n",
    "ORDER BY 2 DESC\n",
    "LIMIT 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01ef6f77-28bf-459c-9556-c8f73dd2428d",
   "metadata": {
    "tags": []
   },
   "source": [
    "Result: 4211\n",
    "\n",
    "2. What's the average of total_amt_usd for this account_id?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "946ee985-a2f3-4765-87b6-d12144d63c0d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>avg</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>6175.3758064516129032</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(Decimal('6175.3758064516129032'),)]"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT AVG(total_amt_usd)\n",
    "FROM orders o\n",
    "WHERE o.account_id = 4211"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5104daa2-3206-4682-868d-fb31c61f835c",
   "metadata": {},
   "source": [
    "Result: 6175.3758064516129032 which matches the result so by my interpreation of the question my answer is correct"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78b2e019-2ef0-4337-8092-d2a0c4ec68af",
   "metadata": {},
   "source": [
    "What is the lifetime average amount spent (in terms of total_amt_usd), including only the companies that spent more per order, on average, than the average of all orders.\n",
    "\n",
    "Reword:\n",
    "1. What is the average amount spent of only the companies whose average order was above the overall average?\n",
    "\n",
    "Breakdown:\n",
    "1. Calculate the overall average total_amt_usd of each order\n",
    "2. Calculate the average total_amt_usd of each company\n",
    "3. Produce a table which lists only the companies whose average total_amt_usd is greater than the overall average\n",
    "4. Join this last table with a table which lists all orders, INNER JOIN on id, and take the average"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "8dccd8cd-976d-4831-8c60-efc3eda4bd77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>avg</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>4434.2127982456140351</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(Decimal('4434.2127982456140351'),)]"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT AVG(total_amt_usd)\n",
    "FROM orders o\n",
    "JOIN (\n",
    "    SELECT account_id account_id2, AVG(total_amt_usd)\n",
    "    FROM orders o\n",
    "    GROUP BY 1\n",
    "    HAVING AVG(total_amt_usd) > (\n",
    "        SELECT AVG(total_amt_usd)\n",
    "        FROM orders o\n",
    "    )\n",
    "    ORDER BY 1\n",
    ") AS t1\n",
    "ON t1.account_id2 = o.account_id\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81e3b893-e15a-4b78-a345-96f6aa82e354",
   "metadata": {
    "tags": []
   },
   "source": [
    "The provided solution came at this a little differently..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "31f5f81f-c8f5-44b7-b64e-0b72c8e2adc7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>avg</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>4721.1397439971747168</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(Decimal('4721.1397439971747168'),)]"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT AVG(avg_amt)\n",
    "FROM (SELECT o.account_id, AVG(o.total_amt_usd) avg_amt\n",
    "    FROM orders o\n",
    "    GROUP BY 1\n",
    "    HAVING AVG(o.total_amt_usd) > (SELECT AVG(o.total_amt_usd) avg_all\n",
    "                                   FROM orders o)) temp_table;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51aa0306-d990-4b17-a9d3-4907f7a94b6e",
   "metadata": {},
   "source": [
    "Here it can be seen that it took the average of only the transactions above the overall average value. I interpreted the question differently: I identified companies whose average transaction was below overall average, and then calculated the average transaction for those identified companies."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfcd6c3c-1097-49df-ab7d-45cd15815e23",
   "metadata": {},
   "source": [
    "## Concept 13. Quiz: WITH"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b7d9b6e-16b2-4a5d-a1c5-8e813ec79e9e",
   "metadata": {},
   "source": [
    "Provide the name of the sales_rep in each region with the largest amount of total_amt_usd sales.\n",
    "\n",
    "Use WITH"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "56cd2c89-8eb3-4840-9c68-c7b252e0d2b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "4 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>rep_name</th>\n",
       "            <th>region_name</th>\n",
       "            <th>total_amt</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Charles Bidwell</td>\n",
       "            <td>Midwest</td>\n",
       "            <td>675637.19</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Earlie Schleusner</td>\n",
       "            <td>Southeast</td>\n",
       "            <td>1098137.72</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Georgianna Chisholm</td>\n",
       "            <td>West</td>\n",
       "            <td>886244.12</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Tia Amato</td>\n",
       "            <td>Northeast</td>\n",
       "            <td>1010690.60</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Charles Bidwell', 'Midwest', Decimal('675637.19')),\n",
       " ('Earlie Schleusner', 'Southeast', Decimal('1098137.72')),\n",
       " ('Georgianna Chisholm', 'West', Decimal('886244.12')),\n",
       " ('Tia Amato', 'Northeast', Decimal('1010690.60'))]"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "WITH t3 AS\n",
    "    (SELECT s.name rep_name, r.name region_name, SUM(o.total_amt_usd) total_amt\n",
    "    FROM sales_reps s\n",
    "    JOIN accounts a\n",
    "    ON a.sales_rep_id = s.id\n",
    "    JOIN orders o\n",
    "    ON o.account_id = a.id\n",
    "    JOIN region r\n",
    "    ON r.id = s.region_id\n",
    "    GROUP BY 1,2),\n",
    "\n",
    "    t2 AS\n",
    "    (SELECT region_name, MAX(total_amt) total_amt\n",
    "    FROM t3\n",
    "    GROUP BY 1)\n",
    "\n",
    "SELECT t3.rep_name, t3.region_name, t3.total_amt\n",
    "FROM t2\n",
    "JOIN t3\n",
    "ON t3.region_name = t2.region_name AND t3.total_amt = t2.total_amt;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9ecc08e-5a8c-4ced-834b-eebb000a2e3c",
   "metadata": {
    "tags": []
   },
   "source": [
    "For the region with the largest sales total_amt_usd, how many total orders were placed?\n",
    "\n",
    "Use WITH\n",
    "\n",
    "Breakdown\n",
    "1. Identify region with largest sales total_amt_usd\n",
    "2. List all orders for that region\n",
    "3. Count those orders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "3e2da6bf-68c6-4d8f-86ea-e9396750c4c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>region_name</th>\n",
       "            <th>count</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Northeast</td>\n",
       "            <td>2357</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Northeast', 2357)]"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "WITH t1 AS\n",
    "    (\n",
    "        SELECT r.name region_name, SUM(total_amt_usd)\n",
    "        FROM orders o\n",
    "        JOIN accounts a\n",
    "        ON o.account_id = a.id\n",
    "        JOIN sales_reps s\n",
    "        ON a.sales_rep_id = s.id\n",
    "        JOIN region r\n",
    "        ON s.region_id = r.id\n",
    "        GROUP BY 1\n",
    "        ORDER BY 2 DESC\n",
    "        LIMIT 1\n",
    "    ),\n",
    "\n",
    "    t2 AS\n",
    "    (\n",
    "        SELECT o.id order_id, r.name region_name\n",
    "        FROM orders o\n",
    "        JOIN accounts a\n",
    "        ON o.account_id = a.id\n",
    "        JOIN sales_reps s\n",
    "        ON a.sales_rep_id = s.id\n",
    "        JOIN region r\n",
    "        ON s.region_id = r.id\n",
    "    )\n",
    "\n",
    "SELECT t2.region_name, COUNT(*)\n",
    "FROM t2\n",
    "JOIN t1\n",
    "ON t1.region_name = t2.region_name\n",
    "GROUP BY 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c93b15e-11b0-465c-a704-a8a226418e8a",
   "metadata": {},
   "source": [
    "How many accounts had more total purchases than the account name which has bought the most standard_qty paper throughout their lifetime as a customer?\n",
    "\n",
    "Breakdown:\n",
    "1. What account has bought the most standard_qty paper\n",
    "2. How many accounts had more total purchases than this account?\n",
    "\n",
    "Formalise:\n",
    "1. Return: account_name, SUM(standard_qty), SUM(total)\n",
    "\n",
    "Use WITH"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "3f711e62-a6af-4984-ac74-46e80e75faa9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>count</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>3</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(3,)]"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "WITH\n",
    "    t1 AS (\n",
    "        SELECT a.name account_name, SUM(standard_qty) sum_standard_qty, SUM(total) sum_total\n",
    "        FROM orders o\n",
    "        JOIN accounts a\n",
    "        ON o.account_id = a.id\n",
    "        GROUP BY 1\n",
    "        ORDER BY 2 DESC\n",
    "        LIMIT 1\n",
    "    ),\n",
    "\n",
    "    t2 AS (\n",
    "        SELECT a.name account_name, SUM(standard_qty) sum_standard_qty, SUM(total) sum_total\n",
    "        FROM orders o\n",
    "        JOIN accounts a\n",
    "        ON o.account_id = a.id\n",
    "        GROUP BY 1\n",
    "        HAVING SUM(total) > (\n",
    "            SELECT sum_total\n",
    "            FROM t1\n",
    "        )\n",
    "    )\n",
    "\n",
    "SELECT COUNT(*)\n",
    "FROM t2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec12bae4-1d81-4a5b-ae61-89aef3648793",
   "metadata": {
    "tags": []
   },
   "source": [
    "For the customer that spent the most (in total over their lifetime as a customer) total_amt_usd, how many web_events did they have for each channel? \n",
    "\n",
    "Breakdown:\n",
    "1. Which customer spent the most total_amt_usd?\n",
    "2. How many web_events did they have for each channel?\n",
    "\n",
    "Approaches:\n",
    "1. Inner join between (which account_name spent the most total_amt_usd) and (all customer web_events grouped by channel) on (account_name)\n",
    "2. Query (which account_name spent the most total_amt_usd) and specify in WHERE of (all customer web_events grouped by channel)\n",
    "\n",
    "Approach 1, technique 1:\n",
    "Here we join tables in a sequence\n",
    "\n",
    "Perform inner join on tables t2 and t3. Common denominator will be the account name.\n",
    "Feels very inefficient as we're creating a table of all web_events across all accounts.\n",
    "\n",
    "Better to count web_events for each channel for only the account in question?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "8e586b45-fac5-4dd8-a149-cd952f997caa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "6 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>id</th>\n",
       "            <th>channel</th>\n",
       "            <th>count</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>4211</td>\n",
       "            <td>adwords</td>\n",
       "            <td>12</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>4211</td>\n",
       "            <td>banner</td>\n",
       "            <td>4</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>4211</td>\n",
       "            <td>direct</td>\n",
       "            <td>44</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>4211</td>\n",
       "            <td>facebook</td>\n",
       "            <td>11</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>4211</td>\n",
       "            <td>organic</td>\n",
       "            <td>13</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(4211, 'adwords', 12),\n",
       " (4211, 'banner', 4),\n",
       " (4211, 'direct', 44),\n",
       " (4211, 'facebook', 11),\n",
       " (4211, 'organic', 13)]"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "WITH\n",
    "    t1 AS (\n",
    "        -- Identify the account with the greatest SUM(total_amt_usd)\n",
    "        SELECT a.id, SUM(total_amt_usd) sum_total_amt_usd\n",
    "        FROM orders o\n",
    "        JOIN accounts a\n",
    "        ON a.id = o.account_id\n",
    "        GROUP BY 1\n",
    "        ORDER BY 2 DESC\n",
    "        LIMIT 1\n",
    "    ),\n",
    "\n",
    "    t2 AS (\n",
    "        -- Pull the account name only\n",
    "        SELECT id\n",
    "        FROM t1\n",
    "    ),\n",
    "\n",
    "    t3 AS (\n",
    "        -- Count number of rows in web_events grouped by account_name and channel\n",
    "        SELECT a.id, w.channel, COUNT(*)\n",
    "        FROM web_events w\n",
    "        JOIN accounts a\n",
    "        ON a.id = w.account_id\n",
    "        GROUP BY 1, 2\n",
    "    )\n",
    "\n",
    "SELECT t3.id, t3.channel, t3.count\n",
    "FROM t2\n",
    "JOIN t3\n",
    "ON t2.id = t3.id\n",
    "ORDER BY 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18ee588c-7724-47e0-861a-22b6782e10a2",
   "metadata": {},
   "source": [
    "Approach 1, technique 2 \n",
    "Here we join two tables simultaneously.\n",
    "Is this at all any more efficient than the previous operation?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "9b4e0d48-4d7c-4dc4-932e-5c872126133b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "6 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>account_name</th>\n",
       "            <th>channel</th>\n",
       "            <th>count</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>EOG Resources</td>\n",
       "            <td>adwords</td>\n",
       "            <td>12</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>EOG Resources</td>\n",
       "            <td>banner</td>\n",
       "            <td>4</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>EOG Resources</td>\n",
       "            <td>direct</td>\n",
       "            <td>44</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>EOG Resources</td>\n",
       "            <td>facebook</td>\n",
       "            <td>11</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>EOG Resources</td>\n",
       "            <td>organic</td>\n",
       "            <td>13</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('EOG Resources', 'adwords', 12),\n",
       " ('EOG Resources', 'banner', 4),\n",
       " ('EOG Resources', 'direct', 44),\n",
       " ('EOG Resources', 'facebook', 11),\n",
       " ('EOG Resources', 'organic', 13)]"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "WITH\n",
    "    t1 AS (\n",
    "        -- Identify the account with the greatest SUM(total_amt_usd)\n",
    "        SELECT a.id, SUM(total_amt_usd) sum_total_amt_usd\n",
    "        FROM orders o\n",
    "        JOIN accounts a\n",
    "        ON a.id = o.account_id\n",
    "        GROUP BY 1\n",
    "        ORDER BY 2 DESC\n",
    "        LIMIT 1\n",
    "    )\n",
    "\n",
    "SELECT a.name account_name, w.channel, COUNT(*)\n",
    "FROM web_events w\n",
    "JOIN accounts a\n",
    "ON a.id = w.account_id AND a.id = (SELECT id FROM t1)\n",
    "GROUP BY 1, 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ac3efbb-8b12-4814-b89c-776e65f7466b",
   "metadata": {
    "tags": []
   },
   "source": [
    "Approach 2:\n",
    "Syntactically these are almost identical... WHERE is kind of like ON??? Only in so far as INNER JOINS are concerned..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "bdfcf03a-617f-4664-a38a-a41df9109c9e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "6 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>name</th>\n",
       "            <th>channel</th>\n",
       "            <th>count</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>EOG Resources</td>\n",
       "            <td>adwords</td>\n",
       "            <td>12</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>EOG Resources</td>\n",
       "            <td>banner</td>\n",
       "            <td>4</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>EOG Resources</td>\n",
       "            <td>direct</td>\n",
       "            <td>44</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>EOG Resources</td>\n",
       "            <td>facebook</td>\n",
       "            <td>11</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>EOG Resources</td>\n",
       "            <td>organic</td>\n",
       "            <td>13</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('EOG Resources', 'adwords', 12),\n",
       " ('EOG Resources', 'banner', 4),\n",
       " ('EOG Resources', 'direct', 44),\n",
       " ('EOG Resources', 'facebook', 11),\n",
       " ('EOG Resources', 'organic', 13)]"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "WITH\n",
    "t1 AS (\n",
    "    -- Identify the account with the greatest SUM(total_amt_usd)\n",
    "    SELECT a.id, SUM(total_amt_usd) sum_total_amt_usd\n",
    "    FROM orders o\n",
    "    JOIN accounts a\n",
    "    ON a.id = o.account_id\n",
    "    JOIN web_events w\n",
    "    ON a.id = w.account_id\n",
    "    GROUP BY 1\n",
    "    ORDER BY 2 DESC\n",
    "    LIMIT 1\n",
    ")\n",
    "\n",
    "SELECT a.name, w.channel, COUNT(*)\n",
    "FROM web_events w\n",
    "JOIN accounts a\n",
    "ON a.id = w.account_id\n",
    "WHERE a.id = (SELECT id FROM t1)\n",
    "GROUP BY 1, 2\n",
    "ORDER BY 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "baaa9d62-0c1f-4a8a-94e4-7b4bacc21f89",
   "metadata": {},
   "source": [
    "What is the lifetime average amount spent in terms of total_amt_usd for the top 10 total spending accounts?\n",
    "\n",
    "Use WITH\n",
    "\n",
    "Breakdown:\n",
    "1. What are the top 10 total spending accounts?\n",
    "2. What is the average amount spent in terms of total_amt_usd across all of these accounts?\n",
    "\n",
    "Approaches:\n",
    "1. JOIN (top 10 accounts) with (list of all transactions) ON (account_id or name)\n",
    "2. Calculate average of the above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "1a8cd9b0-8422-4ac1-b654-d59786558033",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>avg</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>304846.969000000000</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(Decimal('304846.969000000000'),)]"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "WITH\n",
    "    top_10_accounts AS (\n",
    "        SELECT a.id account_id, SUM(o.total_amt_usd) sum_total_amt_usd\n",
    "        FROM accounts a\n",
    "        JOIN orders o\n",
    "        ON a.id = o.account_id\n",
    "        GROUP BY 1\n",
    "        ORDER BY 2 DESC\n",
    "        LIMIT 10\n",
    "    )\n",
    "\n",
    "SELECT AVG(top_10_accounts.sum_total_amt_usd)\n",
    "FROM top_10_accounts"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e325172-4980-47b6-a162-23454849579b",
   "metadata": {
    "tags": []
   },
   "source": [
    "What is the lifetime average amount spent in terms of total_amt_usd, including only the companies that spent more per order, on average, than the average of all orders.\n",
    "\n",
    "Use WITH\n",
    "\n",
    "Reword:\n",
    "What's the overall average sum(total_amt_usd) of only companies with an avg(total_amt_usd) > overall avg(total_amt_usd)?\n",
    "\n",
    "Approach\n",
    "1. Calculate overall_avg_total_amt_usd\n",
    "2. List companies with an avg(total_amt_usd) > overall_avg_total_amt_usd (companies_above_avg_total_amt_usd)\n",
    "3. Calculate the average of these averages!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "5fef5a7e-7851-4acf-8a5d-d03b89753a0b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>avg</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>4721.1397439971747168</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(Decimal('4721.1397439971747168'),)]"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "WITH\n",
    "    overall_avg_total_amt_usd AS\n",
    "    (\n",
    "        SELECT AVG(total_amt_usd)\n",
    "        FROM orders\n",
    "    ),\n",
    "\n",
    "    companies_above_avg_total_amt_usd AS\n",
    "    (\n",
    "        SELECT a.id, AVG(o.total_amt_usd)\n",
    "        FROM accounts a\n",
    "        JOIN orders o\n",
    "        ON a.id = o.account_id\n",
    "        GROUP BY 1\n",
    "        HAVING AVG(o.total_amt_usd) > (SELECT * FROM overall_avg_total_amt_usd)\n",
    "    )\n",
    "\n",
    "SELECT AVG(avg) FROM companies_above_avg_total_amt_usd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da23e259-1bf4-4a7b-88e8-c6a530272588",
   "metadata": {
    "tags": []
   },
   "source": [
    "Note on this line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "0f1678f9-adb5-4f67-8076-d3b66217c49d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "(psycopg2.errors.SyntaxError) syntax error at or near \"HAVING\"\n",
      "LINE 1: HAVING AVG(o.total_amt_usd) > (SELECT * FROM overall_avg_tot...\n",
      "        ^\n",
      "\n",
      "[SQL: HAVING AVG(o.total_amt_usd) > (SELECT * FROM overall_avg_total_amt_usd)]\n",
      "(Background on this error at: https://sqlalche.me/e/14/f405)\n"
     ]
    }
   ],
   "source": [
    "%%sql\n",
    "HAVING AVG(o.total_amt_usd) > (SELECT * FROM overall_avg_total_amt_usd)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f772399-99ff-479e-9efe-3adc4976e3e6",
   "metadata": {
    "tags": []
   },
   "source": [
    "... it's not possible to reference directly the table overall_avg_total_amt_usd, even though it is a SCALAR QUERY."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8952edc-16f4-49ce-b10e-e3e012605ec2",
   "metadata": {},
   "source": [
    "## Lesson 5. Concept 3. Quiz: LEFT & RIGHT\n",
    "\n",
    "Use the accounts table and a CASE statement to create two groups: one group of company names that start with a number and a second group of those company names that start with a letter. What proportion of company names start with a letter?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "71d1faa9-e8a2-46a8-9434-5f9b7b6143d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "2 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>first_digit</th>\n",
       "            <th>count</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Not Numerical</td>\n",
       "            <td>350</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Numerical</td>\n",
       "            <td>1</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Not Numerical', 350), ('Numerical', 1)]"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT \n",
    "\tCASE\n",
    "    \tWHEN LEFT(name, 1) BETWEEN '0' AND '9' THEN 'Numerical'\n",
    "        ELSE 'Not Numerical' END AS first_digit,\n",
    "    COUNT(*)\n",
    "FROM accounts\n",
    "GROUP BY 1\n",
    "ORDER BY 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9a606b4-294f-41ec-b15f-2cfd20e7d154",
   "metadata": {
    "tags": []
   },
   "source": [
    "But how do we show the proportion of our results?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "acbef4f7-a161-41c0-adde-a756a1de7adc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "2 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>first_digit</th>\n",
       "            <th>proportion</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Not Numerical</td>\n",
       "            <td>0.997</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Numerical</td>\n",
       "            <td>0.003</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Not Numerical', Decimal('0.997')), ('Numerical', Decimal('0.003'))]"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "WITH summary AS\n",
    "    (\n",
    "        SELECT \n",
    "            CASE\n",
    "                WHEN LEFT(name, 1) BETWEEN '0' AND '9' THEN 'Numerical'\n",
    "                ELSE 'Not Numerical' END AS first_digit,\n",
    "            COUNT(*)\n",
    "        FROM accounts\n",
    "        GROUP BY 1\n",
    "        ORDER BY 1\n",
    "    )\n",
    "\n",
    "SELECT first_digit, ROUND(count/(SELECT SUM(summary.count) FROM summary), 3) proportion\n",
    "FROM summary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6dff84a-4dcf-4276-81f1-6b1206ad3a9f",
   "metadata": {
    "tags": []
   },
   "source": [
    "Consider vowels as a, e, i, o, and u. What proportion of company names start with a vowel, and what percent start with anything else?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "0f0f12f0-3b15-4fc6-aad9-bb8addfe5781",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "6 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>first_digit</th>\n",
       "            <th>proportion</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>0 - other</td>\n",
       "            <td>0.772</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>a</td>\n",
       "            <td>0.105</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>e</td>\n",
       "            <td>0.046</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>i</td>\n",
       "            <td>0.020</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>o</td>\n",
       "            <td>0.020</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('0 - other', Decimal('0.772')),\n",
       " ('a', Decimal('0.105')),\n",
       " ('e', Decimal('0.046')),\n",
       " ('i', Decimal('0.020')),\n",
       " ('o', Decimal('0.020'))]"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "WITH summary AS\n",
    "    (\n",
    "        SELECT \n",
    "            CASE\n",
    "                WHEN LEFT(name, 1) = 'A' OR LEFT(name, 1) = 'a' THEN 'a'\n",
    "                WHEN LEFT(name, 1) = 'E' OR LEFT(name, 1) = 'e' THEN 'e'\n",
    "                WHEN LEFT(name, 1) = 'I' OR LEFT(name, 1) = 'i' THEN 'i'\n",
    "                WHEN LEFT(name, 1) = 'O' OR LEFT(name, 1) = 'o' THEN 'o'\n",
    "                WHEN LEFT(name, 1) = 'U' OR LEFT(name, 1) = 'u' THEN 'u'\n",
    "                ELSE '0 - other'\n",
    "                END AS first_digit,\n",
    "            COUNT(*)\n",
    "        FROM accounts\n",
    "        GROUP BY 1\n",
    "        ORDER BY 1\n",
    "    )\n",
    "\n",
    "SELECT first_digit, ROUND(count/(SELECT SUM(summary.count) FROM summary), 3) proportion\n",
    "FROM summary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e86eb840-4ebb-462f-afbd-da9114a1e805",
   "metadata": {
    "tags": []
   },
   "source": [
    "Could use LIKE instead"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "8c18698b-5496-49d8-8f69-b114e725a069",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "6 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>first_digit</th>\n",
       "            <th>proportion</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>0 - other</td>\n",
       "            <td>0.772</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>a</td>\n",
       "            <td>0.105</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>e</td>\n",
       "            <td>0.046</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>i</td>\n",
       "            <td>0.020</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>o</td>\n",
       "            <td>0.020</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('0 - other', Decimal('0.772')),\n",
       " ('a', Decimal('0.105')),\n",
       " ('e', Decimal('0.046')),\n",
       " ('i', Decimal('0.020')),\n",
       " ('o', Decimal('0.020'))]"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "WITH summary AS\n",
    "    (\n",
    "        SELECT \n",
    "            CASE\n",
    "                WHEN name LIKE 'A%' OR name LIKE 'a%' THEN 'a'\n",
    "                WHEN name LIKE 'E%' OR name LIKE 'e%' THEN 'e'\n",
    "                WHEN name LIKE 'I%' OR name LIKE 'i%' THEN 'i'\n",
    "                WHEN name LIKE 'O%' OR name LIKE 'o%' THEN 'o'\n",
    "                WHEN name LIKE 'U%' OR name LIKE 'u%' THEN 'u'\n",
    "                ELSE '0 - other'\n",
    "                END AS first_digit,\n",
    "            COUNT(*)\n",
    "        FROM accounts\n",
    "        GROUP BY 1\n",
    "        ORDER BY 1\n",
    "    )\n",
    "\n",
    "SELECT first_digit, ROUND(count/(SELECT SUM(summary.count) FROM summary), 3) proportion\n",
    "FROM summary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f58f05f-0f9e-4116-9f67-52a13ad0fd1f",
   "metadata": {
    "tags": []
   },
   "source": [
    "Tidied up. When comparing strings, use UPPER()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "96adf1fe-cfe7-4b9e-8470-6bcda735b990",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "6 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>first_digit</th>\n",
       "            <th>proportion</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>0 - other</td>\n",
       "            <td>0.772</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>a</td>\n",
       "            <td>0.105</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>e</td>\n",
       "            <td>0.046</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>i</td>\n",
       "            <td>0.020</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>o</td>\n",
       "            <td>0.020</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('0 - other', Decimal('0.772')),\n",
       " ('a', Decimal('0.105')),\n",
       " ('e', Decimal('0.046')),\n",
       " ('i', Decimal('0.020')),\n",
       " ('o', Decimal('0.020'))]"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "WITH summary AS\n",
    "    (\n",
    "        SELECT \n",
    "            CASE\n",
    "                WHEN LEFT(UPPER(name), 1) = 'A' THEN 'a'\n",
    "                WHEN LEFT(UPPER(name), 1) = 'E' THEN 'e'\n",
    "                WHEN LEFT(UPPER(name), 1) = 'I' THEN 'i'\n",
    "                WHEN LEFT(UPPER(name), 1) = 'O' THEN 'o'\n",
    "                WHEN LEFT(UPPER(name), 1) = 'U' THEN 'u'\n",
    "                ELSE '0 - other'\n",
    "                END AS first_digit,\n",
    "            COUNT(*)\n",
    "        FROM accounts\n",
    "        GROUP BY 1\n",
    "        ORDER BY 1\n",
    "    )\n",
    "\n",
    "SELECT first_digit, ROUND(count/(SELECT SUM(summary.count) FROM summary), 3) proportion\n",
    "FROM summary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e1e9691-d046-466d-92f7-42a745b5739a",
   "metadata": {
    "tags": []
   },
   "source": [
    "Being a bit more observant of the actual requested information, all we need is a delineation of vowels vs others:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "bb1aa9fa-d57b-4ccd-830b-324dced1e6ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "2 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>first_digit</th>\n",
       "            <th>proportion</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>other</td>\n",
       "            <td>0.772</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>vowel</td>\n",
       "            <td>0.228</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('other', Decimal('0.772')), ('vowel', Decimal('0.228'))]"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "WITH summary AS\n",
    "    (\n",
    "        SELECT \n",
    "            CASE\n",
    "                WHEN LEFT(UPPER(name), 1) IN ('A','E','I','O','U') THEN 'vowel'\n",
    "                ELSE 'other'\n",
    "                END AS first_digit,\n",
    "            COUNT(*)\n",
    "        FROM accounts\n",
    "        GROUP BY 1\n",
    "        ORDER BY 1\n",
    "    )\n",
    "\n",
    "SELECT first_digit, ROUND(count/(SELECT SUM(summary.count) FROM summary), 3) proportion\n",
    "FROM summary\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "838d6901-93b5-420f-b62e-8f24be8f9c35",
   "metadata": {
    "tags": []
   },
   "source": [
    "Another approach. This doesn't calculate the actual proportion though..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "3da233d8-554a-4110-bf51-fd5fae9f0f7a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>vowels</th>\n",
       "            <th>other</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>80</td>\n",
       "            <td>271</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(80, 271)]"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "WITH summary AS\n",
    "    (\n",
    "        SELECT name,\n",
    "            CASE\n",
    "                WHEN LEFT(UPPER(name), 1) IN ('A','E','I','O','U') THEN 1\n",
    "                ELSE 0 END AS vowels, \n",
    "            CASE\n",
    "                WHEN LEFT(UPPER(name), 1) IN ('A','E','I','O','U') THEN 0\n",
    "                ELSE 1 END AS other\n",
    "        FROM accounts\n",
    "    )\n",
    "\n",
    "SELECT SUM(vowels) vowels, SUM(other) other\n",
    "FROM summary\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "389cf57c-7141-43ec-b3a9-2bcc42b13d87",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Quizzes POSITION & STRPOS\n",
    "\n",
    "Use the accounts table to create first and last name columns that hold the first and last names for the primary_poc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "43544149-b237-4aed-a2a7-de976bd1c321",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "351 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>first</th>\n",
       "            <th>last</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Tamara </td>\n",
       "            <td>Tuma</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Sung </td>\n",
       "            <td>Shields</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Jodee </td>\n",
       "            <td>Lupo</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Serafina </td>\n",
       "            <td>Banda</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Angeles </td>\n",
       "            <td>Crusoe</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Tamara ', 'Tuma'),\n",
       " ('Sung ', 'Shields'),\n",
       " ('Jodee ', 'Lupo'),\n",
       " ('Serafina ', 'Banda'),\n",
       " ('Angeles ', 'Crusoe')]"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT\n",
    "\tLEFT(primary_poc, POSITION(' ' IN UPPER(primary_poc))) AS first,\n",
    "\tRIGHT(primary_poc, LENGTH(primary_poc) - POSITION(' ' IN UPPER(primary_poc))) AS last\n",
    "FROM accounts"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f82482a8-7d86-41f1-bffc-006f2ff403d6",
   "metadata": {
    "tags": []
   },
   "source": [
    "Now see if you can do the same thing for every rep name in the sales_reps table. Again provide first and last name columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "0c97cbfc-da9d-42b9-a468-9b35c7aae7ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "50 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>first</th>\n",
       "            <th>last</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>Samuel </td>\n",
       "            <td>Racine</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Eugena </td>\n",
       "            <td>Esser</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Michel </td>\n",
       "            <td>Averette</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Renetta </td>\n",
       "            <td>Carew</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>Cara </td>\n",
       "            <td>Clarke</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[('Samuel ', 'Racine'),\n",
       " ('Eugena ', 'Esser'),\n",
       " ('Michel ', 'Averette'),\n",
       " ('Renetta ', 'Carew'),\n",
       " ('Cara ', 'Clarke')]"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT\n",
    "\tLEFT(name, POSITION(' ' IN UPPER(name))) AS first,\n",
    "\tRIGHT(name, LENGTH(name) - POSITION(' ' IN UPPER(name))) AS last\n",
    "FROM sales_reps"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d374f13c-1ad2-4539-a946-6265c3df3006",
   "metadata": {
    "tags": []
   },
   "source": [
    "Correct given date \"01/31/2014 08:00:00 AM +0000\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "da4e6b0c-96a2-4b2d-91d0-490c4155a27d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "(psycopg2.errors.UndefinedTable) relation \"sf_crime_data\" does not exist\n",
      "LINE 4: FROM sf_crime_data\n",
      "             ^\n",
      "\n",
      "[SQL: SELECT\n",
      "    date orig_date,\n",
      "    (SUBSTR(date, 7, 4) || '-' || LEFT(date, 2) || '-' || SUBSTR(date, 4, 2))::DATE new_date\n",
      "FROM sf_crime_data\n",
      "LIMIT 10;]\n",
      "(Background on this error at: https://sqlalche.me/e/14/f405)\n"
     ]
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT\n",
    "    date orig_date,\n",
    "    (SUBSTR(date, 7, 4) || '-' || LEFT(date, 2) || '-' || SUBSTR(date, 4, 2))::DATE new_date\n",
    "FROM sf_crime_data\n",
    "LIMIT 10;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bfd80aa-b0a0-4e1c-b542-f70a3d474967",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Coalesce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "7569732e-8b9c-4436-84c0-38195dc7089c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "1 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>filled_id</th>\n",
       "            <th>name</th>\n",
       "            <th>website</th>\n",
       "            <th>lat</th>\n",
       "            <th>long</th>\n",
       "            <th>primary_poc</th>\n",
       "            <th>sales_rep_id</th>\n",
       "            <th>account_id</th>\n",
       "            <th>occurred_at</th>\n",
       "            <th>standard_qty</th>\n",
       "            <th>gloss_qty</th>\n",
       "            <th>poster_qty</th>\n",
       "            <th>total</th>\n",
       "            <th>standard_amt_usd</th>\n",
       "            <th>gloss_amt_usd</th>\n",
       "            <th>poster_amt_usd</th>\n",
       "            <th>total_amt_usd</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>1731</td>\n",
       "            <td>Goldman Sachs Group</td>\n",
       "            <td>www.gs.com</td>\n",
       "            <td>40.75744399</td>\n",
       "            <td>-73.96730918</td>\n",
       "            <td>Loris Manfredi</td>\n",
       "            <td>321690</td>\n",
       "            <td>1731</td>\n",
       "            <td>None</td>\n",
       "            <td>0</td>\n",
       "            <td>0</td>\n",
       "            <td>0</td>\n",
       "            <td>0</td>\n",
       "            <td>0</td>\n",
       "            <td>0</td>\n",
       "            <td>0</td>\n",
       "            <td>0</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(1731, 'Goldman Sachs Group', 'www.gs.com', Decimal('40.75744399'), Decimal('-73.96730918'), 'Loris Manfredi', 321690, 1731, None, 0, 0, 0, 0, Decimal('0'), Decimal('0'), Decimal('0'), Decimal('0'))]"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT\n",
    "\tCOALESCE(o.id, a.id) filled_id,\n",
    "    a.name,\n",
    "    a.website,\n",
    "    a.lat,\n",
    "    a.long,\n",
    "    a.primary_poc,\n",
    "    a.sales_rep_id,\n",
    "    COALESCE(o.account_id, a.id) account_id,\n",
    "    o.occurred_at,\n",
    "    COALESCE(o.standard_qty, 0) standard_qty,\n",
    "    COALESCE(o.gloss_qty,0) gloss_qty,\n",
    "    COALESCE(o.poster_qty,0) poster_qty,\n",
    "    COALESCE(o.total,0) total,\n",
    "    COALESCE(o.standard_amt_usd,0) standard_amt_usd,\n",
    "    COALESCE(o.gloss_amt_usd,0) gloss_amt_usd,\n",
    "    COALESCE(o.poster_amt_usd,0) poster_amt_usd,\n",
    "    COALESCE(o.total_amt_usd,0) total_amt_usd\n",
    "FROM accounts a\n",
    "LEFT JOIN orders o\n",
    "ON a.id = o.account_id\n",
    "WHERE o.* IS NULL;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25fdeb0d-3ccf-4a46-ab84-647775f038f2",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Window functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "c6c49c5d-10c5-4ad2-af34-1629d67638b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "6912 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>standard_amt_usd</th>\n",
       "            <th>date_year</th>\n",
       "            <th>sum</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>0.00</td>\n",
       "            <td>2013-01-01 00:00:00</td>\n",
       "            <td>0.00</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2445.10</td>\n",
       "            <td>2013-01-01 00:00:00</td>\n",
       "            <td>2445.10</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2634.72</td>\n",
       "            <td>2013-01-01 00:00:00</td>\n",
       "            <td>5079.82</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>0.00</td>\n",
       "            <td>2013-01-01 00:00:00</td>\n",
       "            <td>5079.82</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2455.08</td>\n",
       "            <td>2013-01-01 00:00:00</td>\n",
       "            <td>7534.90</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(Decimal('0.00'), datetime.datetime(2013, 1, 1, 0, 0), Decimal('0.00')),\n",
       " (Decimal('2445.10'), datetime.datetime(2013, 1, 1, 0, 0), Decimal('2445.10')),\n",
       " (Decimal('2634.72'), datetime.datetime(2013, 1, 1, 0, 0), Decimal('5079.82')),\n",
       " (Decimal('0.00'), datetime.datetime(2013, 1, 1, 0, 0), Decimal('5079.82')),\n",
       " (Decimal('2455.08'), datetime.datetime(2013, 1, 1, 0, 0), Decimal('7534.90'))]"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT\n",
    "\tstandard_amt_usd\n",
    "    ,DATE_TRUNC('year', occurred_at) AS date_year -- <== QUITE NEAT PUTTING THE COMMA ON A NEW LINE. EDIT ONLY ONE LINE TO REMOVE A PARAMETER.\n",
    "    ,SUM(standard_amt_usd) OVER (/* PARTITION BY DATE_TRUNC('year', occurred_at) */ ORDER BY occurred_at)\n",
    "FROM orders"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e023676-f517-466d-8e6d-c1925e478cc3",
   "metadata": {
    "tags": []
   },
   "source": [
    "Select the id, account_id, and total variable from the orders table, then create a column called total_rank that ranks this total amount of paper ordered (from highest to lowest) for each account using a partition. Your final table should have these four columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "a1a212b0-17dd-4a3a-bd76-33b0cb554a9d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "(psycopg2.errors.SyntaxError) syntax error at or near \",\"\n",
      "LINE 3:     ,account_id\n",
      "            ^\n",
      "\n",
      "[SQL: SELECT\n",
      "\tid,\n",
      "    ,account_id\n",
      "    ,total\n",
      "    ,DENSE_RANK() OVER (PARTITION BY account_id ORDER BY total) total_rank -- <== Provided solution suggests using RANK(), but I think DENSE_RANK() works better here\n",
      "FROM orders]\n",
      "(Background on this error at: https://sqlalche.me/e/14/f405)\n"
     ]
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT\n",
    "\tid,\n",
    "    ,account_id\n",
    "    ,total\n",
    "    ,DENSE_RANK() OVER (PARTITION BY account_id ORDER BY total) total_rank -- <== Provided solution suggests using RANK(), but I think DENSE_RANK() works better here\n",
    "FROM orders"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0953793-dd90-4cbc-9145-3d948670fef7",
   "metadata": {
    "tags": []
   },
   "source": [
    "Now, create and use an alias to shorten the following query (which is different than the one in Derek's previous video) that has multiple window functions. Name the alias account_year_window, which is more descriptive than main_window in the example above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "995a0b6d-863a-49a0-98ee-76e2519f56a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "6912 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>id</th>\n",
       "            <th>account_id</th>\n",
       "            <th>year</th>\n",
       "            <th>dense_rank</th>\n",
       "            <th>total_amt_usd</th>\n",
       "            <th>sum_total_amt_usd</th>\n",
       "            <th>count_total_amt_usd</th>\n",
       "            <th>avg_total_amt_usd</th>\n",
       "            <th>min_total_amt_usd</th>\n",
       "            <th>max_total_amt_usd</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>4307</td>\n",
       "            <td>1001</td>\n",
       "            <td>2015-01-01 00:00:00</td>\n",
       "            <td>1</td>\n",
       "            <td>8757.18</td>\n",
       "            <td>21651.53</td>\n",
       "            <td>5</td>\n",
       "            <td>4330.3060000000000000</td>\n",
       "            <td>776.18</td>\n",
       "            <td>9426.71</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>3</td>\n",
       "            <td>1001</td>\n",
       "            <td>2015-01-01 00:00:00</td>\n",
       "            <td>1</td>\n",
       "            <td>776.18</td>\n",
       "            <td>21651.53</td>\n",
       "            <td>5</td>\n",
       "            <td>4330.3060000000000000</td>\n",
       "            <td>776.18</td>\n",
       "            <td>9426.71</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2</td>\n",
       "            <td>1001</td>\n",
       "            <td>2015-01-01 00:00:00</td>\n",
       "            <td>1</td>\n",
       "            <td>1718.03</td>\n",
       "            <td>21651.53</td>\n",
       "            <td>5</td>\n",
       "            <td>4330.3060000000000000</td>\n",
       "            <td>776.18</td>\n",
       "            <td>9426.71</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1</td>\n",
       "            <td>1001</td>\n",
       "            <td>2015-01-01 00:00:00</td>\n",
       "            <td>1</td>\n",
       "            <td>973.43</td>\n",
       "            <td>21651.53</td>\n",
       "            <td>5</td>\n",
       "            <td>4330.3060000000000000</td>\n",
       "            <td>776.18</td>\n",
       "            <td>9426.71</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>4308</td>\n",
       "            <td>1001</td>\n",
       "            <td>2015-01-01 00:00:00</td>\n",
       "            <td>1</td>\n",
       "            <td>9426.71</td>\n",
       "            <td>21651.53</td>\n",
       "            <td>5</td>\n",
       "            <td>4330.3060000000000000</td>\n",
       "            <td>776.18</td>\n",
       "            <td>9426.71</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(4307, 1001, datetime.datetime(2015, 1, 1, 0, 0), 1, Decimal('8757.18'), Decimal('21651.53'), 5, Decimal('4330.3060000000000000'), Decimal('776.18'), Decimal('9426.71')),\n",
       " (3, 1001, datetime.datetime(2015, 1, 1, 0, 0), 1, Decimal('776.18'), Decimal('21651.53'), 5, Decimal('4330.3060000000000000'), Decimal('776.18'), Decimal('9426.71')),\n",
       " (2, 1001, datetime.datetime(2015, 1, 1, 0, 0), 1, Decimal('1718.03'), Decimal('21651.53'), 5, Decimal('4330.3060000000000000'), Decimal('776.18'), Decimal('9426.71')),\n",
       " (1, 1001, datetime.datetime(2015, 1, 1, 0, 0), 1, Decimal('973.43'), Decimal('21651.53'), 5, Decimal('4330.3060000000000000'), Decimal('776.18'), Decimal('9426.71')),\n",
       " (4308, 1001, datetime.datetime(2015, 1, 1, 0, 0), 1, Decimal('9426.71'), Decimal('21651.53'), 5, Decimal('4330.3060000000000000'), Decimal('776.18'), Decimal('9426.71'))]"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT id,\n",
    "       account_id,\n",
    "       DATE_TRUNC('year',occurred_at) AS year,\n",
    "       DENSE_RANK() OVER (PARTITION BY account_id ORDER BY DATE_TRUNC('year',occurred_at)) AS dense_rank,\n",
    "       total_amt_usd,\n",
    "       SUM(total_amt_usd) OVER (PARTITION BY account_id ORDER BY DATE_TRUNC('year',occurred_at)) AS sum_total_amt_usd,\n",
    "       COUNT(total_amt_usd) OVER (PARTITION BY account_id ORDER BY DATE_TRUNC('year',occurred_at)) AS count_total_amt_usd,\n",
    "       AVG(total_amt_usd) OVER (PARTITION BY account_id ORDER BY DATE_TRUNC('year',occurred_at)) AS avg_total_amt_usd,\n",
    "       MIN(total_amt_usd) OVER (PARTITION BY account_id ORDER BY DATE_TRUNC('year',occurred_at)) AS min_total_amt_usd,\n",
    "       MAX(total_amt_usd) OVER (PARTITION BY account_id ORDER BY DATE_TRUNC('year',occurred_at)) AS max_total_amt_usd\n",
    "FROM orders"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "763997a5-c765-4b6e-9f34-ed4770b2470b",
   "metadata": {
    "tags": []
   },
   "source": [
    "My effort:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "b9ec6cd5-02b3-45f2-88d8-2c512cf6b6a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "6912 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>id</th>\n",
       "            <th>account_id</th>\n",
       "            <th>year</th>\n",
       "            <th>dense_rank</th>\n",
       "            <th>total_amt_usd</th>\n",
       "            <th>sum_total_amt_usd</th>\n",
       "            <th>count_total_amt_usd</th>\n",
       "            <th>avg_total_amt_usd</th>\n",
       "            <th>min_total_amt_usd</th>\n",
       "            <th>max_total_amt_usd</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>4307</td>\n",
       "            <td>1001</td>\n",
       "            <td>2015-01-01 00:00:00</td>\n",
       "            <td>1</td>\n",
       "            <td>8757.18</td>\n",
       "            <td>21651.53</td>\n",
       "            <td>5</td>\n",
       "            <td>4330.3060000000000000</td>\n",
       "            <td>776.18</td>\n",
       "            <td>9426.71</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>3</td>\n",
       "            <td>1001</td>\n",
       "            <td>2015-01-01 00:00:00</td>\n",
       "            <td>1</td>\n",
       "            <td>776.18</td>\n",
       "            <td>21651.53</td>\n",
       "            <td>5</td>\n",
       "            <td>4330.3060000000000000</td>\n",
       "            <td>776.18</td>\n",
       "            <td>9426.71</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2</td>\n",
       "            <td>1001</td>\n",
       "            <td>2015-01-01 00:00:00</td>\n",
       "            <td>1</td>\n",
       "            <td>1718.03</td>\n",
       "            <td>21651.53</td>\n",
       "            <td>5</td>\n",
       "            <td>4330.3060000000000000</td>\n",
       "            <td>776.18</td>\n",
       "            <td>9426.71</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1</td>\n",
       "            <td>1001</td>\n",
       "            <td>2015-01-01 00:00:00</td>\n",
       "            <td>1</td>\n",
       "            <td>973.43</td>\n",
       "            <td>21651.53</td>\n",
       "            <td>5</td>\n",
       "            <td>4330.3060000000000000</td>\n",
       "            <td>776.18</td>\n",
       "            <td>9426.71</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>4308</td>\n",
       "            <td>1001</td>\n",
       "            <td>2015-01-01 00:00:00</td>\n",
       "            <td>1</td>\n",
       "            <td>9426.71</td>\n",
       "            <td>21651.53</td>\n",
       "            <td>5</td>\n",
       "            <td>4330.3060000000000000</td>\n",
       "            <td>776.18</td>\n",
       "            <td>9426.71</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(4307, 1001, datetime.datetime(2015, 1, 1, 0, 0), 1, Decimal('8757.18'), Decimal('21651.53'), 5, Decimal('4330.3060000000000000'), Decimal('776.18'), Decimal('9426.71')),\n",
       " (3, 1001, datetime.datetime(2015, 1, 1, 0, 0), 1, Decimal('776.18'), Decimal('21651.53'), 5, Decimal('4330.3060000000000000'), Decimal('776.18'), Decimal('9426.71')),\n",
       " (2, 1001, datetime.datetime(2015, 1, 1, 0, 0), 1, Decimal('1718.03'), Decimal('21651.53'), 5, Decimal('4330.3060000000000000'), Decimal('776.18'), Decimal('9426.71')),\n",
       " (1, 1001, datetime.datetime(2015, 1, 1, 0, 0), 1, Decimal('973.43'), Decimal('21651.53'), 5, Decimal('4330.3060000000000000'), Decimal('776.18'), Decimal('9426.71')),\n",
       " (4308, 1001, datetime.datetime(2015, 1, 1, 0, 0), 1, Decimal('9426.71'), Decimal('21651.53'), 5, Decimal('4330.3060000000000000'), Decimal('776.18'), Decimal('9426.71'))]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT \n",
    "    id\n",
    "    ,account_id\n",
    "    ,DATE_TRUNC('year',occurred_at) AS year\n",
    "    ,DENSE_RANK() OVER account_year_window AS dense_rank\n",
    "    ,total_amt_usd\n",
    "    ,SUM(total_amt_usd) OVER account_year_window AS sum_total_amt_usd\n",
    "    ,COUNT(total_amt_usd) OVER account_year_window AS count_total_amt_usd\n",
    "    ,AVG(total_amt_usd) OVER account_year_window AS avg_total_amt_usd\n",
    "    ,MIN(total_amt_usd) OVER account_year_window AS min_total_amt_usd\n",
    "    ,MAX(total_amt_usd) OVER account_year_window AS max_total_amt_usd\n",
    "FROM orders\n",
    "WINDOW account_year_window AS (PARTITION BY account_id ORDER BY DATE_TRUNC('year', occurred_at))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5c8b36e-f92f-4673-aa51-b3e00796721b",
   "metadata": {
    "tags": []
   },
   "source": [
    "In the previous video, Derek outlines how to compare a row to a previous or subsequent row. This technique can be useful when analyzing time-based events. Imagine you're an analyst at Parch & Posey and you want to determine how the current order's total revenue (\"total\" meaning from sales of all types of paper) compares to the next order's total revenue.\n",
    "\n",
    "Modify Derek's query from the previous video in the SQL Explorer below to perform this analysis. You'll need to use occurred_at and total_amt_usd in the orders table along with LEAD to do so. In your query results, there should be four columns: occurred_at, total_amt_usd, lead, and lead_difference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "ec1cfc43-0405-464f-9506-4201ae0e932a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "6912 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>occurred_at</th>\n",
       "            <th>total_amt_usd</th>\n",
       "            <th>lead</th>\n",
       "            <th>lead_difference</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>2013-12-04 04:22:44</td>\n",
       "            <td>627.48</td>\n",
       "            <td>2646.77</td>\n",
       "            <td>2019.29</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2013-12-04 04:45:54</td>\n",
       "            <td>2646.77</td>\n",
       "            <td>2709.62</td>\n",
       "            <td>62.85</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2013-12-04 04:53:25</td>\n",
       "            <td>2709.62</td>\n",
       "            <td>277.13</td>\n",
       "            <td>-2432.49</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2013-12-05 20:29:16</td>\n",
       "            <td>277.13</td>\n",
       "            <td>3001.85</td>\n",
       "            <td>2724.72</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2013-12-05 20:33:56</td>\n",
       "            <td>3001.85</td>\n",
       "            <td>2802.90</td>\n",
       "            <td>-198.95</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(datetime.datetime(2013, 12, 4, 4, 22, 44), Decimal('627.48'), Decimal('2646.77'), Decimal('2019.29')),\n",
       " (datetime.datetime(2013, 12, 4, 4, 45, 54), Decimal('2646.77'), Decimal('2709.62'), Decimal('62.85')),\n",
       " (datetime.datetime(2013, 12, 4, 4, 53, 25), Decimal('2709.62'), Decimal('277.13'), Decimal('-2432.49')),\n",
       " (datetime.datetime(2013, 12, 5, 20, 29, 16), Decimal('277.13'), Decimal('3001.85'), Decimal('2724.72')),\n",
       " (datetime.datetime(2013, 12, 5, 20, 33, 56), Decimal('3001.85'), Decimal('2802.90'), Decimal('-198.95'))]"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT \n",
    "    occurred_at\n",
    "    ,total_amt_usd\n",
    "    ,LEAD(total_amt_usd) OVER (ORDER BY occurred_at) AS lead\n",
    "    ,LEAD(total_amt_usd) OVER (ORDER BY occurred_at) - total_amt_usd AS lead_difference\n",
    "FROM orders"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e958e7d2-71ad-4648-badb-0fb4e4ec88d1",
   "metadata": {
    "tags": []
   },
   "source": [
    "In the provided solution a subquery was run which calculated SUM(), GROUPed on occurred_at.\n",
    "I'm not sure why that was necessary. total_amt_usd already denotes a total order value for any order.\n",
    "\n",
    "Use the NTILE functionality to divide the accounts into 4 levels in terms of the amount of standard_qty for their orders. Your resulting table should have the account_id, the occurred_at time for each order, the total amount of standard_qty paper purchased, and one of four levels in a standard_quartile column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "dab7a768-29bc-4d1e-aa83-e4bc75ec75d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "6912 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>account_id</th>\n",
       "            <th>occurred_at</th>\n",
       "            <th>standard_qty</th>\n",
       "            <th>ntile</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>1001</td>\n",
       "            <td>2015-12-04 04:21:55</td>\n",
       "            <td>85</td>\n",
       "            <td>1</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1001</td>\n",
       "            <td>2016-05-31 21:22:48</td>\n",
       "            <td>91</td>\n",
       "            <td>1</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1001</td>\n",
       "            <td>2016-06-30 12:32:05</td>\n",
       "            <td>94</td>\n",
       "            <td>1</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1001</td>\n",
       "            <td>2016-05-01 15:55:51</td>\n",
       "            <td>95</td>\n",
       "            <td>1</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1001</td>\n",
       "            <td>2016-10-26 20:31:30</td>\n",
       "            <td>97</td>\n",
       "            <td>1</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(1001, datetime.datetime(2015, 12, 4, 4, 21, 55), 85, 1),\n",
       " (1001, datetime.datetime(2016, 5, 31, 21, 22, 48), 91, 1),\n",
       " (1001, datetime.datetime(2016, 6, 30, 12, 32, 5), 94, 1),\n",
       " (1001, datetime.datetime(2016, 5, 1, 15, 55, 51), 95, 1),\n",
       " (1001, datetime.datetime(2016, 10, 26, 20, 31, 30), 97, 1)]"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT\n",
    "    account_id\n",
    "    ,occurred_at\n",
    "    ,standard_qty\n",
    "    ,NTILE(4) OVER (PARTITION BY account_id ORDER BY standard_qty)\n",
    "FROM orders\n",
    "ORDER BY 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27248de6-1d85-4c1e-bce3-68595088c911",
   "metadata": {
    "tags": []
   },
   "source": [
    "Use the NTILE functionality to divide the accounts into two levels in terms of the amount of gloss_qty for their orders. Your resulting table should have the account_id, the occurred_at time for each order, the total amount of gloss_qty paper purchased, and one of two levels in a gloss_half column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "122b9cb6-09a7-48cb-b62e-1f71ee976283",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "6912 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>account_id</th>\n",
       "            <th>occurred_at</th>\n",
       "            <th>gloss_qty</th>\n",
       "            <th>ntile</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>1001</td>\n",
       "            <td>2016-09-26 23:28:25</td>\n",
       "            <td>10</td>\n",
       "            <td>1</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1001</td>\n",
       "            <td>2016-05-31 21:22:48</td>\n",
       "            <td>16</td>\n",
       "            <td>1</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1001</td>\n",
       "            <td>2015-10-06 17:31:14</td>\n",
       "            <td>22</td>\n",
       "            <td>1</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1001</td>\n",
       "            <td>2016-03-02 15:29:32</td>\n",
       "            <td>24</td>\n",
       "            <td>1</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1001</td>\n",
       "            <td>2016-02-01 19:27:27</td>\n",
       "            <td>29</td>\n",
       "            <td>1</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(1001, datetime.datetime(2016, 9, 26, 23, 28, 25), 10, 1),\n",
       " (1001, datetime.datetime(2016, 5, 31, 21, 22, 48), 16, 1),\n",
       " (1001, datetime.datetime(2015, 10, 6, 17, 31, 14), 22, 1),\n",
       " (1001, datetime.datetime(2016, 3, 2, 15, 29, 32), 24, 1),\n",
       " (1001, datetime.datetime(2016, 2, 1, 19, 27, 27), 29, 1)]"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT\n",
    "    account_id\n",
    "    ,occurred_at\n",
    "    ,gloss_qty\n",
    "    ,NTILE(2) OVER (PARTITION BY account_id ORDER BY gloss_qty)\n",
    "FROM orders\n",
    "ORDER BY 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cd88deb-86d9-4882-98d9-a2500e76f858",
   "metadata": {
    "tags": []
   },
   "source": [
    "Use the NTILE functionality to divide the orders for each account into 100 levels in terms of the amount of total_amt_usd for their orders. Your resulting table should have the account_id, the occurred_at time for each order, the total amount of total_amt_usd paper purchased, and one of 100 levels in a total_percentile column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "30bdfd68-7e8e-4b15-8786-25154238c5de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "6912 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>account_id</th>\n",
       "            <th>occurred_at</th>\n",
       "            <th>total_amt_usd</th>\n",
       "            <th>ntile</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>1001</td>\n",
       "            <td>2016-05-31 21:22:48</td>\n",
       "            <td>752.57</td>\n",
       "            <td>1</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1001</td>\n",
       "            <td>2016-07-30 03:26:30</td>\n",
       "            <td>773.63</td>\n",
       "            <td>2</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1001</td>\n",
       "            <td>2015-12-04 04:21:55</td>\n",
       "            <td>776.18</td>\n",
       "            <td>3</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1001</td>\n",
       "            <td>2016-06-30 12:32:05</td>\n",
       "            <td>878.56</td>\n",
       "            <td>4</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1001</td>\n",
       "            <td>2016-09-26 23:28:25</td>\n",
       "            <td>951.14</td>\n",
       "            <td>5</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(1001, datetime.datetime(2016, 5, 31, 21, 22, 48), Decimal('752.57'), 1),\n",
       " (1001, datetime.datetime(2016, 7, 30, 3, 26, 30), Decimal('773.63'), 2),\n",
       " (1001, datetime.datetime(2015, 12, 4, 4, 21, 55), Decimal('776.18'), 3),\n",
       " (1001, datetime.datetime(2016, 6, 30, 12, 32, 5), Decimal('878.56'), 4),\n",
       " (1001, datetime.datetime(2016, 9, 26, 23, 28, 25), Decimal('951.14'), 5)]"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT\n",
    "    account_id\n",
    "    ,occurred_at\n",
    "    ,total_amt_usd\n",
    "    ,NTILE(100) OVER (PARTITION BY account_id ORDER BY total_amt_usd)\n",
    "FROM orders\n",
    "ORDER BY 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f95cfa72-4001-4be3-b72c-318c35542090",
   "metadata": {
    "tags": []
   },
   "source": [
    "In the above solution, I noted that in many cases values towards zero were returned, and none close to 100.\n",
    "This is because NTILE() does not apportion the %age range over the input values as we'd expect. So each sequentially\n",
    "larger value seems to be assigned a +1 %age. So if there are 28 different values, the ntile column will only get\n",
    "to 28.\n",
    "\n",
    "This can be avoided by utilising larger NTILE size \"buckets\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ad4efda-99d5-442d-9769-03c52f4f8d64",
   "metadata": {},
   "source": [
    "## Self JOINs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eeb378bc-3912-484b-8854-725ddf8eb450",
   "metadata": {},
   "source": [
    "In the above solution, I noted that in many cases values towards zero were returned, and none close to 100.\n",
    "This is because NTILE() does not apportion the %age range over the input values as we'd expect. So each sequentially\n",
    "larger value seems to be assigned a +1 %age. So if there are 28 different values, the ntile column will only get\n",
    "to 28.\n",
    "\n",
    "This can be avoided by utilising larger NTILE size \"buckets\"\n",
    "\n",
    "One of the most common use cases for self JOINs is in cases where two events occurred, one after another. As you may have noticed in the previous video, using inequalities in conjunction with self JOINs is common.\n",
    "\n",
    "Modify the query from the previous video, which is pre-populated in the SQL Explorer below, to perform the same interval analysis except for the web_events table. Also:\n",
    "\n",
    "* Change the interval to 1 day to find those web events that occurred after, but not more than 1 day after, another web event\n",
    "* Add a column for the channel variable in both instances of the table in your query\n",
    "You can find more on the types of INTERVALS (and other date related functionality) in the Postgres documentation here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "e8eae3ef-a9a8-43c1-8d05-80be0097cd94",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * postgresql://localhost/parchposey\n",
      "9148 rows affected.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "    <thead>\n",
       "        <tr>\n",
       "            <th>w1_id</th>\n",
       "            <th>w1_account_id</th>\n",
       "            <th>w1_occurred_at</th>\n",
       "            <th>w1_channel</th>\n",
       "            <th>w2_id</th>\n",
       "            <th>w2_account_id</th>\n",
       "            <th>w2_occurred_at</th>\n",
       "            <th>w2_channel</th>\n",
       "        </tr>\n",
       "    </thead>\n",
       "    <tbody>\n",
       "        <tr>\n",
       "            <td>4394</td>\n",
       "            <td>1001</td>\n",
       "            <td>2015-10-06 04:22:11</td>\n",
       "            <td>facebook</td>\n",
       "            <td>1</td>\n",
       "            <td>1001</td>\n",
       "            <td>2015-10-06 17:13:58</td>\n",
       "            <td>direct</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>1</td>\n",
       "            <td>1001</td>\n",
       "            <td>2015-10-06 17:13:58</td>\n",
       "            <td>direct</td>\n",
       "            <td>None</td>\n",
       "            <td>None</td>\n",
       "            <td>None</td>\n",
       "            <td>None</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>4395</td>\n",
       "            <td>1001</td>\n",
       "            <td>2015-10-22 05:02:47</td>\n",
       "            <td>organic</td>\n",
       "            <td>4396</td>\n",
       "            <td>1001</td>\n",
       "            <td>2015-10-22 14:04:20</td>\n",
       "            <td>adwords</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>4396</td>\n",
       "            <td>1001</td>\n",
       "            <td>2015-10-22 14:04:20</td>\n",
       "            <td>adwords</td>\n",
       "            <td>None</td>\n",
       "            <td>None</td>\n",
       "            <td>None</td>\n",
       "            <td>None</td>\n",
       "        </tr>\n",
       "        <tr>\n",
       "            <td>2</td>\n",
       "            <td>1001</td>\n",
       "            <td>2015-11-05 03:08:26</td>\n",
       "            <td>direct</td>\n",
       "            <td>4397</td>\n",
       "            <td>1001</td>\n",
       "            <td>2015-11-05 17:18:54</td>\n",
       "            <td>direct</td>\n",
       "        </tr>\n",
       "    </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "[(4394, 1001, datetime.datetime(2015, 10, 6, 4, 22, 11), 'facebook', 1, 1001, datetime.datetime(2015, 10, 6, 17, 13, 58), 'direct'),\n",
       " (1, 1001, datetime.datetime(2015, 10, 6, 17, 13, 58), 'direct', None, None, None, None),\n",
       " (4395, 1001, datetime.datetime(2015, 10, 22, 5, 2, 47), 'organic', 4396, 1001, datetime.datetime(2015, 10, 22, 14, 4, 20), 'adwords'),\n",
       " (4396, 1001, datetime.datetime(2015, 10, 22, 14, 4, 20), 'adwords', None, None, None, None),\n",
       " (2, 1001, datetime.datetime(2015, 11, 5, 3, 8, 26), 'direct', 4397, 1001, datetime.datetime(2015, 11, 5, 17, 18, 54), 'direct')]"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%sql\n",
    "SELECT \n",
    "    w1.id AS w1_id\n",
    "    ,w1.account_id AS w1_account_id\n",
    "    ,w1.occurred_at AS w1_occurred_at\n",
    "    ,w1.channel AS w1_channel\n",
    "    ,w2.id AS w2_id\n",
    "    ,w2.account_id AS w2_account_id\n",
    "    ,w2.occurred_at AS w2_occurred_at\n",
    "    ,w2.channel AS w2_channel\n",
    "  FROM web_events w1\n",
    " LEFT JOIN web_events w2\n",
    "   ON w1.account_id = w2.account_id\n",
    "  AND w2.occurred_at > w1.occurred_at\n",
    "  AND w2.occurred_at <= w1.occurred_at + INTERVAL '1 day'\n",
    "ORDER BY w1.account_id, w1.occurred_at"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "199ad530-5987-40f1-85b5-66e3d7d916ba",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "p3_DAND_Jupyter",
   "language": "python",
   "name": "p3_dand_jupyter"
  },
  "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}