Notebooks/05_SQLAlchemy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction to Databases\n",
    "\n",
    "### Using SQLAlchemy \n",
    "\n",
    "Based in [this](https://medium.com/hacking-datascience/sqlalchemy-python-tutorial-abcc2ec77b57), [this](https://medium.com/dataexplorations/sqlalchemy-orm-a-more-pythonic-way-of-interacting-with-your-database-935b57fd2d4d) and [this](https://auth0.com/blog/sqlalchemy-orm-tutorial-for-python-developers/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SQLAlchemy provides a nice “Pythonic” way of interacting with databases. So rather than dealing with the differences between specific dialects of traditional SQL such as MySQL or PostgreSQL or Oracle, you can leverage the Pythonic framework of SQLAlchemy to streamline your workflow and more efficiently query your data.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip install mysqlclient\n",
    "#!pip install python-dotenv\n",
    "#!pip install sqlalchemy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import getpass\n",
    "import pandas as pd\n",
    "\n",
    "import sqlalchemy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Connecting to a database\n",
    "\n",
    "To start interacting with the database we first we need to establish a connection.  \n",
    "\n",
    "Some examples of connecting to various databases can be found [here](http://docs.sqlalchemy.org/en/latest/core/engines.html#postgresql)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Viewing Table Details\n",
    "\n",
    "SQLAlchemy can be used to automatically load tables from a database using something called reflection. Reflection is the process of reading the database and building the metadata based on that information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "engine = sqlalchemy.create_engine('sqlite:///../SampleDBs/chinook.sqlite')\n",
    "connection = engine.connect()\n",
    "metadata = sqlalchemy.MetaData()\n",
    "\n",
    "albums = sqlalchemy.Table('albums', metadata, autoload=True, autoload_with=engine)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sqlalchemy.sql.schema.Table"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(albums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['AlbumId', 'Title', 'ArtistId']\n"
     ]
    }
   ],
   "source": [
    "# Print the column names\n",
    "print(albums.columns.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Table('albums', MetaData(), Column('AlbumId', INTEGER(), table=<albums>, primary_key=True, nullable=False), Column('Title', NVARCHAR(length=160), table=<albums>, nullable=False), Column('ArtistId', INTEGER(), ForeignKey('artists.ArtistId'), table=<albums>, nullable=False), schema=None)\n"
     ]
    }
   ],
   "source": [
    "# Print full table metadata\n",
    "print(repr(metadata.tables['albums']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Querying\n",
    "\n",
    "ResultProxy: The object returned by the .execute() method. It can be used in a variety of ways to get the data returned by the query.  \n",
    "\n",
    "ResultSet: The actual data asked for in the query when using a fetch method such as .fetchall() on a ResultProxy.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Equivalent to 'SELECT * FROM albums'\n",
    "query = sqlalchemy.select([albums])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 'For Those About To Rock We Salute You', 1),\n",
       " (2, 'Balls to the Wall', 2),\n",
       " (3, 'Restless and Wild', 2)]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ResultProxy = connection.execute(query)\n",
    "ResultSet = ResultProxy.fetchall()\n",
    "#partial_results = ResultProxy.fetchmany(50)\n",
    "ResultSet[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert to dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>AlbumId</th>\n",
       "      <th>Title</th>\n",
       "      <th>ArtistId</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>For Those About To Rock We Salute You</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>Balls to the Wall</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>Restless and Wild</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>Let There Be Rock</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>Big Ones</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   AlbumId                                  Title  ArtistId\n",
       "0        1  For Those About To Rock We Salute You         1\n",
       "1        2                      Balls to the Wall         2\n",
       "2        3                      Restless and Wild         2\n",
       "3        4                      Let There Be Rock         1\n",
       "4        5                               Big Ones         3"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame(ResultSet)\n",
    "df.columns = ResultSet[0].keys()\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Filtering data\n",
    "\n",
    "Let's see some examples of raw SQLite Queries and queries using SQLAlchemy.\n",
    "\n",
    "#### where"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(16, 'Caetano Veloso')]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## SQL :SELECT * FROM artists WHERE Name = \"Caetano Veloso\" :\n",
    "\n",
    "artists = sqlalchemy.Table('artists', metadata, autoload=True, autoload_with=engine)\n",
    "\n",
    "query = sqlalchemy.select([artists]).where(artists.columns.Name == 'Caetano Veloso')\n",
    "ResultProxy = connection.execute(query)\n",
    "ResultSet = ResultProxy.fetchall()\n",
    "ResultSet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### in"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Roberto', 'Almeida'), ('Michelle', 'Brooks')]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## SQL : SELECT FirstName, LastName FROM customers WHERE state IN (\"Rio de Janeiro\", \"New York\")\n",
    "\n",
    "customers = sqlalchemy.Table('customers', metadata, autoload=True, autoload_with=engine)\n",
    "\n",
    "query = sqlalchemy.select([customers.columns.FirstName, \n",
    "                           customers.columns.LastName]).where(customers.columns.City.in_(['Rio de Janeiro', 'New York']))\n",
    "\n",
    "ResultProxy = connection.execute(query)\n",
    "ResultSet = ResultProxy.fetchall()\n",
    "ResultSet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### and, or, not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(12, 'Roberto', 'Almeida', 'Riotur', 'Praça Pio X, 119', 'Rio de Janeiro', 'RJ', 'Brazil', '20040-020', '+55 (21) 2271-7000', '+55 (21) 2271-7070', 'roberto.almeida@riotur.gov.br', 3)]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## SQL :SELECT * FROM customers WHERE City = 'Rio de Janeiro' AND NOT FirstName = 'Roberta'\n",
    "    \n",
    "customers = sqlalchemy.Table('customers', metadata, autoload=True, autoload_with=engine)\n",
    "\n",
    "query = sqlalchemy.select([customers]).where(sqlalchemy.and_(customers.columns.City == \"Rio de Janeiro\",\n",
    "                                                             customers.columns.FirstName != \"Roberta\")\n",
    "                                            )\n",
    "ResultProxy = connection.execute(query)\n",
    "ResultSet = ResultProxy.fetchall()\n",
    "ResultSet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### order by"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(33, 'Ellie', 'Sullivan', None, '5112 48 Street', 'Yellowknife', 'NT', 'Canada', 'X1A 1N6', '+1 (867) 920-2233', None, 'ellie.sullivan@shaw.ca', 3),\n",
       " (32, 'Aaron', 'Mitchell', None, '696 Osborne Street', 'Winnipeg', 'MB', 'Canada', 'R3L 2B9', '+1 (204) 452-6452', None, 'aaronmitchell@yahoo.ca', 4),\n",
       " (49, 'Stanisław', 'Wójcik', None, 'Ordynacka 10', 'Warsaw', None, 'Poland', '00-358', '+48 22 828 37 39', None, 'stanisław.wójcik@wp.pl', 4)]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## SQL : SELECT * FROM customers ORDER BY City DESC, Country\n",
    "\n",
    "customers = sqlalchemy.Table('customers', metadata, autoload=True, autoload_with=engine)\n",
    "\n",
    "query = sqlalchemy.select([customers]).order_by(sqlalchemy.desc(customers.columns.City), customers.columns.Country)\n",
    "ResultProxy = connection.execute(query)\n",
    "ResultSet = ResultProxy.fetchall()\n",
    "ResultSet[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### [functions](https://docs.sqlalchemy.org/en/14/core/functions.html)  \n",
    "other functions include avg, count, min, max…  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:6: SAWarning: Dialect sqlite+pysqlite does *not* support Decimal objects natively, and SQLAlchemy must convert from floating point - rounding errors and other issues may occur. Please consider storing Decimal numbers as strings or integers on this platform for lossless storage.\n",
      "  \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[(Decimal('2328.60'),)]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "##SQL : SELECT SUM(Total) FROM invoices \n",
    "    \n",
    "invoices = sqlalchemy.Table('invoices', metadata, autoload=True, autoload_with=engine)\n",
    "\n",
    "query = sqlalchemy.select([sqlalchemy.func.sum(invoices.columns.Total)])\n",
    "ResultProxy = connection.execute(query)\n",
    "ResultSet = ResultProxy.fetchall()\n",
    "ResultSet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### group by"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(Decimal('1.98'), datetime.datetime(2009, 1, 1, 0, 0)),\n",
       " (Decimal('3.96'), datetime.datetime(2009, 1, 2, 0, 0)),\n",
       " (Decimal('5.94'), datetime.datetime(2009, 1, 3, 0, 0)),\n",
       " (Decimal('8.91'), datetime.datetime(2009, 1, 6, 0, 0)),\n",
       " (Decimal('13.86'), datetime.datetime(2009, 1, 11, 0, 0))]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "##SQL : SELECT SUM(Total) as Total, InvoiceDate FROM invoices GROUP BY InvoiceDate\n",
    "\n",
    "invoices = sqlalchemy.Table('invoices', metadata, autoload=True, autoload_with=engine)\n",
    "\n",
    "query = sqlalchemy.select([sqlalchemy.func.sum(invoices.columns.Total).label('Total'), \n",
    "                           invoices.columns.InvoiceDate]).group_by(invoices.columns.InvoiceDate)\n",
    "\n",
    "ResultProxy = connection.execute(query)\n",
    "ResultSet = ResultProxy.fetchall()\n",
    "ResultSet[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### distinct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1,), (2,), (3,), (4,), (5,)]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## SQL : SELECT DISTINCT state FROM censusSQLAlchemy :\n",
    "\n",
    "invoices = sqlalchemy.Table('invoices', metadata, autoload=True, autoload_with=engine)\n",
    "\n",
    "query = sqlalchemy.select([invoices.columns.CustomerId.distinct()])\n",
    "\n",
    "ResultProxy = connection.execute(query)\n",
    "ResultSet = ResultProxy.fetchall()\n",
    "ResultSet[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### joins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Defining Table objects\n",
    "\n",
    "artists = sqlalchemy.Table('artists', metadata, autoload=True, autoload_with=engine)\n",
    "albums = sqlalchemy.Table('albums', metadata, autoload=True, autoload_with=engine)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Automatic Join"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:4: SAWarning: SELECT statement has a cartesian product between FROM element(s) \"artists\" and FROM element \"albums\".  Apply join condition(s) between each element to resolve.\n",
      "  after removing the cwd from sys.path.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ArtistId</th>\n",
       "      <th>Name</th>\n",
       "      <th>AlbumId</th>\n",
       "      <th>Title</th>\n",
       "      <th>ArtistId_1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>AC/DC</td>\n",
       "      <td>1</td>\n",
       "      <td>For Those About To Rock We Salute You</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>AC/DC</td>\n",
       "      <td>2</td>\n",
       "      <td>Balls to the Wall</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>AC/DC</td>\n",
       "      <td>3</td>\n",
       "      <td>Restless and Wild</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>AC/DC</td>\n",
       "      <td>4</td>\n",
       "      <td>Let There Be Rock</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>AC/DC</td>\n",
       "      <td>5</td>\n",
       "      <td>Big Ones</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   ArtistId   Name  AlbumId                                  Title  ArtistId_1\n",
       "0         1  AC/DC        1  For Those About To Rock We Salute You           1\n",
       "1         1  AC/DC        2                      Balls to the Wall           2\n",
       "2         1  AC/DC        3                      Restless and Wild           2\n",
       "3         1  AC/DC        4                      Let There Be Rock           1\n",
       "4         1  AC/DC        5                               Big Ones           3"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "query = sqlalchemy.select([artists, albums])\n",
    "#query = sqlalchemy.select([artists.columns.Name, albums.columns.Title])\n",
    "\n",
    "results = connection.execute(query).fetchall()\n",
    "df = pd.DataFrame(results)\n",
    "df.columns = results[0].keys()\n",
    "df.head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Manual Join"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ArtistId</th>\n",
       "      <th>Name</th>\n",
       "      <th>AlbumId</th>\n",
       "      <th>Title</th>\n",
       "      <th>ArtistId_1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>AC/DC</td>\n",
       "      <td>1</td>\n",
       "      <td>For Those About To Rock We Salute You</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>Accept</td>\n",
       "      <td>2</td>\n",
       "      <td>Balls to the Wall</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>Accept</td>\n",
       "      <td>3</td>\n",
       "      <td>Restless and Wild</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>AC/DC</td>\n",
       "      <td>4</td>\n",
       "      <td>Let There Be Rock</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3</td>\n",
       "      <td>Aerosmith</td>\n",
       "      <td>5</td>\n",
       "      <td>Big Ones</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   ArtistId       Name  AlbumId                                  Title  \\\n",
       "0         1      AC/DC        1  For Those About To Rock We Salute You   \n",
       "1         2     Accept        2                      Balls to the Wall   \n",
       "2         2     Accept        3                      Restless and Wild   \n",
       "3         1      AC/DC        4                      Let There Be Rock   \n",
       "4         3  Aerosmith        5                               Big Ones   \n",
       "\n",
       "   ArtistId_1  \n",
       "0           1  \n",
       "1           2  \n",
       "2           2  \n",
       "3           1  \n",
       "4           3  "
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "query = sqlalchemy.select([artists, albums])\n",
    "query = query.select_from(artists.join(albums, artists.columns.ArtistId == albums.columns.ArtistId))\n",
    "\n",
    "results = connection.execute(query).fetchall()\n",
    "df = pd.DataFrame(results)\n",
    "df.columns = results[0].keys()\n",
    "df.head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating and Inserting Data into Tables\n",
    "\n",
    "By passing the database which is not present, to the engine then sqlalchemy automatically creates a new database."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create test.sqlite if not exists\n",
    "\n",
    "engine = sqlalchemy.create_engine('sqlite:///../SampleDBs/test.sqlite')\n",
    "\n",
    "connection = engine.connect()\n",
    "metadata = sqlalchemy.MetaData()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "emp = sqlalchemy.Table('emp', metadata,\n",
    "                       sqlalchemy.Column('Id', sqlalchemy.Integer()),\n",
    "                       sqlalchemy.Column('name', sqlalchemy.String(255), nullable=False),\n",
    "                       sqlalchemy.Column('salary', sqlalchemy.Float(), default=100.0),\n",
    "                       sqlalchemy.Column('active', sqlalchemy.Boolean(), default=True)\n",
    "                      )\n",
    "\n",
    "metadata.create_all(engine) #Creates the table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Inserting record one by one\n",
    "\n",
    "query = sqlalchemy.insert(emp).values(Id=1, name='naveen', salary=60000.00, active=True) \n",
    "ResultProxy = connection.execute(query)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Inserting many records at ones\n",
    "\n",
    "query = sqlalchemy.insert(emp) \n",
    "values_list = [{'Id':'2', 'name':'ram', 'salary':80000, 'active':False},\n",
    "               {'Id':'3', 'name':'ramesh', 'salary':70000, 'active':True}]\n",
    "\n",
    "ResultProxy = connection.execute(query,values_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Id</th>\n",
       "      <th>name</th>\n",
       "      <th>salary</th>\n",
       "      <th>active</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>naveen</td>\n",
       "      <td>60000.0</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>ram</td>\n",
       "      <td>80000.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>ramesh</td>\n",
       "      <td>70000.0</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Id    name   salary  active\n",
       "0   1  naveen  60000.0    True\n",
       "1   2     ram  80000.0   False\n",
       "2   3  ramesh  70000.0    True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results = connection.execute(sqlalchemy.select([emp])).fetchall()\n",
    "df = pd.DataFrame(results)\n",
    "df.columns = results[0].keys()\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Updating data in Databases\n",
    "\n",
    "db.update(table_name).values(attribute = new_value).where(condition)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Id</th>\n",
       "      <th>name</th>\n",
       "      <th>salary</th>\n",
       "      <th>active</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>naveen</td>\n",
       "      <td>60000.0</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>ram</td>\n",
       "      <td>80000.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>ramesh</td>\n",
       "      <td>70000.0</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Id    name   salary  active\n",
       "0   1  naveen  60000.0    True\n",
       "1   2     ram  80000.0   False\n",
       "2   3  ramesh  70000.0    True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results = connection.execute(sqlalchemy.select([emp])).fetchall()\n",
    "\n",
    "df = pd.DataFrame(results)\n",
    "df.columns = results[0].keys()\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build a statement to update the salary of Id = 1 to to 100000\n",
    "\n",
    "query = sqlalchemy.update(emp).values(salary = 100000)\n",
    "query = query.where(emp.columns.Id == 1)\n",
    "results = connection.execute(query)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Id</th>\n",
       "      <th>name</th>\n",
       "      <th>salary</th>\n",
       "      <th>active</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>naveen</td>\n",
       "      <td>100000.0</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>ram</td>\n",
       "      <td>80000.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>ramesh</td>\n",
       "      <td>70000.0</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Id    name    salary  active\n",
       "0   1  naveen  100000.0    True\n",
       "1   2     ram   80000.0   False\n",
       "2   3  ramesh   70000.0    True"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results = connection.execute(sqlalchemy.select([emp])).fetchall()\n",
    "df = pd.DataFrame(results)\n",
    "df.columns = results[0].keys()\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Delete tuples from Table\n",
    "\n",
    "db.delete(table_name).where(condition)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Id</th>\n",
       "      <th>name</th>\n",
       "      <th>salary</th>\n",
       "      <th>active</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>naveen</td>\n",
       "      <td>100000.0</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>ram</td>\n",
       "      <td>80000.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>ramesh</td>\n",
       "      <td>70000.0</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Id    name    salary  active\n",
       "0   1  naveen  100000.0    True\n",
       "1   2     ram   80000.0   False\n",
       "2   3  ramesh   70000.0    True"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results = connection.execute(sqlalchemy.select([emp])).fetchall()\n",
    "df = pd.DataFrame(results)\n",
    "df.columns = results[0].keys()\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build a statement to delete where salary < 80000\n",
    "\n",
    "query = sqlalchemy.delete(emp)\n",
    "query = query.where(emp.columns.salary < 80000)\n",
    "results = connection.execute(query)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Id</th>\n",
       "      <th>name</th>\n",
       "      <th>salary</th>\n",
       "      <th>active</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>naveen</td>\n",
       "      <td>100000.0</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>ram</td>\n",
       "      <td>80000.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Id    name    salary  active\n",
       "0   1  naveen  100000.0    True\n",
       "1   2     ram   80000.0   False"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results = connection.execute(sqlalchemy.select([emp])).fetchall()\n",
    "df = pd.DataFrame(results)\n",
    "df.columns = results[0].keys()\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dropping a Table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "##drops a single table  \n",
    "# table_name.drop(engine) \n",
    "\n",
    "##drops all the tables in the database\n",
    "# metadata.drop_all(engine) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Removing the database"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file in use or not found\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    os.remove('../SampleDBs/test.sqlite')\n",
    "    print(\"removed file\")\n",
    "except:\n",
    "    print(\"file in use or not found\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating ERM Model using SQLAlchemy ORM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Option 1 — Raw SQL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sqlalchemy import create_engine\n",
    "#db = create_engine('dialect+driver://user:pass@host:port/db')\n",
    "#db = create_engine(f'postgresql://{DB_USER}:{DB_PASS}@{IP}:{DB_PORT}/{DB_NAME}')\n",
    "\n",
    "db = create_engine('sqlite:///../SampleDBs/college.sqlite')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<sqlalchemy.engine.cursor.LegacyCursorResult at 0x1e40a297448>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "db.execute(\"\"\"\n",
    "CREATE TABLE IF NOT EXISTS students (\n",
    "    id integer PRIMARY KEY,\n",
    "    name VARCHAR,\n",
    "    lastname VARCHAR)\n",
    "    \"\"\")\n",
    "\n",
    "db.execute(\"\"\"\n",
    "CREATE TABLE IF NOT EXISTS addresses (\n",
    "    id integer PRIMARY KEY,\n",
    "    st_id INTEGER,\n",
    "    postal_add VARCHAR,\n",
    "    email_add VARCHAR,\n",
    "    FOREIGN KEY(st_id) REFERENCES students (id))\n",
    "    \"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Deleting Database"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "removed file\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    os.remove(\"../SampleDBs/college.sqlite\")\n",
    "    print(\"removed file\")\n",
    "except:\n",
    "    print(\"file in use or not found\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Option 2 — SQLAlchemy Core"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String, Sequence, Float, PrimaryKeyConstraint, ForeignKey\n",
    "from sqlalchemy.ext.declarative import declarative_base\n",
    "from sqlalchemy.orm import sessionmaker, relationship, backref\n",
    "from sqlalchemy.sql import select"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "db = create_engine('sqlite:///../SampleDBs/college.sqlite', echo=True)\n",
    "meta = MetaData()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:33,768 INFO sqlalchemy.engine.Engine BEGIN (implicit)\n",
      "2021-10-27 12:40:33,769 INFO sqlalchemy.engine.Engine PRAGMA main.table_info(\"students\")\n",
      "2021-10-27 12:40:33,770 INFO sqlalchemy.engine.Engine [raw sql] ()\n",
      "2021-10-27 12:40:33,771 INFO sqlalchemy.engine.Engine PRAGMA temp.table_info(\"students\")\n",
      "2021-10-27 12:40:33,773 INFO sqlalchemy.engine.Engine [raw sql] ()\n",
      "2021-10-27 12:40:33,774 INFO sqlalchemy.engine.Engine PRAGMA main.table_info(\"addresses\")\n",
      "2021-10-27 12:40:33,775 INFO sqlalchemy.engine.Engine [raw sql] ()\n",
      "2021-10-27 12:40:33,776 INFO sqlalchemy.engine.Engine PRAGMA temp.table_info(\"addresses\")\n",
      "2021-10-27 12:40:33,777 INFO sqlalchemy.engine.Engine [raw sql] ()\n",
      "2021-10-27 12:40:33,778 INFO sqlalchemy.engine.Engine \n",
      "CREATE TABLE students (\n",
      "\tid INTEGER NOT NULL, \n",
      "\tname VARCHAR, \n",
      "\tlastname VARCHAR, \n",
      "\tPRIMARY KEY (id)\n",
      ")\n",
      "\n",
      "\n",
      "2021-10-27 12:40:33,779 INFO sqlalchemy.engine.Engine [no key 0.00112s] ()\n",
      "2021-10-27 12:40:33,838 INFO sqlalchemy.engine.Engine \n",
      "CREATE TABLE addresses (\n",
      "\tid INTEGER NOT NULL, \n",
      "\tst_id INTEGER, \n",
      "\tpostal_add VARCHAR, \n",
      "\temail_add VARCHAR, \n",
      "\tPRIMARY KEY (id), \n",
      "\tFOREIGN KEY(st_id) REFERENCES students (id)\n",
      ")\n",
      "\n",
      "\n",
      "2021-10-27 12:40:33,838 INFO sqlalchemy.engine.Engine [no key 0.00066s] ()\n",
      "2021-10-27 12:40:33,883 INFO sqlalchemy.engine.Engine COMMIT\n"
     ]
    }
   ],
   "source": [
    "students = Table('students', meta,\n",
    "                 Column('id', Integer, primary_key = True), \n",
    "                 Column('name', String), \n",
    "                 Column('lastname', String), \n",
    "                )\n",
    "\n",
    "addresses = Table('addresses', meta, \n",
    "                  Column('id', Integer, primary_key = True), \n",
    "                  Column('st_id', Integer, ForeignKey('students.id')), \n",
    "                  Column('postal_add', String), \n",
    "                  Column('email_add', String))\n",
    "\n",
    "meta.create_all(db)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Adding some data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:33,899 INFO sqlalchemy.engine.Engine INSERT INTO students (name, lastname) VALUES (?, ?)\n",
      "2021-10-27 12:40:33,902 INFO sqlalchemy.engine.Engine [generated in 0.00327s] (('Renato', 'Nieztsche'), ('Leonardo', 'Steinberg'), ('Pedro', 'Rocha'), ('Roberto', 'Souza'), ('Ana Maria', 'Medeiros'))\n",
      "2021-10-27 12:40:33,910 INFO sqlalchemy.engine.Engine COMMIT\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<sqlalchemy.engine.cursor.LegacyCursorResult at 0x1e40ae796c8>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conn = db.connect()\n",
    "\n",
    "conn.execute(students.insert(), [\n",
    "   {'name':'Renato', 'lastname':'Nieztsche'},\n",
    "   {'name':'Leonardo', 'lastname' : 'Steinberg'},\n",
    "   {'name':'Pedro','lastname' : 'Rocha'},\n",
    "   {'name':'Roberto','lastname' : 'Souza'},\n",
    "   {'name':'Ana Maria','lastname' : 'Medeiros'},\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:33,962 INFO sqlalchemy.engine.Engine INSERT INTO addresses (st_id, postal_add, email_add) VALUES (?, ?, ?)\n",
      "2021-10-27 12:40:33,962 INFO sqlalchemy.engine.Engine [generated in 0.00094s] ((1, 'Ap #505-6795 Tincidunt Street', 'rnieztsche@gmail.com'), (1, 'Ap #619-5142 Imperdiet St', 'lstein@gmail.com'), (3, 'P.O. Box 733, 9483 Amet St.', 'procha@gmail.com'), (5, '307-2719 Mi, St.', 'rrobs@yahoo.com'), (2, '589-8925 Odio Ave', 'amares@protonmail.com'))\n",
      "2021-10-27 12:40:33,973 INFO sqlalchemy.engine.Engine COMMIT\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<sqlalchemy.engine.cursor.LegacyCursorResult at 0x1e40a297cc8>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conn.execute(addresses.insert(), [\n",
    "   {'st_id':1, 'postal_add':'Ap #505-6795 Tincidunt Street', 'email_add':'rnieztsche@gmail.com'},\n",
    "   {'st_id':1, 'postal_add':'Ap #619-5142 Imperdiet St', 'email_add':'lstein@gmail.com'},\n",
    "   {'st_id':3, 'postal_add':'P.O. Box 733, 9483 Amet St.', 'email_add':'procha@gmail.com'},\n",
    "   {'st_id':5, 'postal_add':'307-2719 Mi, St.', 'email_add':'rrobs@yahoo.com'},\n",
    "   {'st_id':2, 'postal_add':'589-8925 Odio Ave', 'email_add':'amares@protonmail.com'},\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:34,041 INFO sqlalchemy.engine.Engine SELECT students.id, students.name, students.lastname, addresses.id AS id_1, addresses.st_id, addresses.postal_add, addresses.email_add \n",
      "FROM students, addresses \n",
      "WHERE students.id = addresses.st_id\n",
      "2021-10-27 12:40:34,042 INFO sqlalchemy.engine.Engine [generated in 0.00075s] ()\n",
      "(1, 'Renato', 'Nieztsche', 1, 1, 'Ap #505-6795 Tincidunt Street', 'rnieztsche@gmail.com')\n",
      "(1, 'Renato', 'Nieztsche', 2, 1, 'Ap #619-5142 Imperdiet St', 'lstein@gmail.com')\n",
      "(3, 'Pedro', 'Rocha', 3, 3, 'P.O. Box 733, 9483 Amet St.', 'procha@gmail.com')\n",
      "(5, 'Ana Maria', 'Medeiros', 4, 5, '307-2719 Mi, St.', 'rrobs@yahoo.com')\n",
      "(2, 'Leonardo', 'Steinberg', 5, 2, '589-8925 Odio Ave', 'amares@protonmail.com')\n"
     ]
    }
   ],
   "source": [
    "s = select([students, addresses]).where(students.c.id == addresses.c.st_id)\n",
    "result = conn.execute(s)\n",
    "\n",
    "for row in result:\n",
    "    print(row)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file in use or not found\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    os.remove(\"../SampleDBs/college.sqlite\")\n",
    "    print(\"removed file\")\n",
    "except:\n",
    "    print(\"file in use or not found\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Option 3 — [SQLAlchemy ORM](https://www.tutorialspoint.com/sqlalchemy/sqlalchemy_orm_declaring_mapping.htm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sqlalchemy import create_engine\n",
    "db = create_engine('sqlite:///../SampleDBs/sales.db', echo=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sqlalchemy.ext.declarative import declarative_base\n",
    "Base = declarative_base()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:34,259 INFO sqlalchemy.engine.Engine BEGIN (implicit)\n",
      "2021-10-27 12:40:34,259 INFO sqlalchemy.engine.Engine PRAGMA main.table_info(\"customers\")\n",
      "2021-10-27 12:40:34,260 INFO sqlalchemy.engine.Engine [raw sql] ()\n",
      "2021-10-27 12:40:34,261 INFO sqlalchemy.engine.Engine PRAGMA temp.table_info(\"customers\")\n",
      "2021-10-27 12:40:34,262 INFO sqlalchemy.engine.Engine [raw sql] ()\n",
      "2021-10-27 12:40:34,264 INFO sqlalchemy.engine.Engine \n",
      "CREATE TABLE customers (\n",
      "\tid INTEGER NOT NULL, \n",
      "\tname VARCHAR, \n",
      "\taddress VARCHAR, \n",
      "\temail VARCHAR, \n",
      "\tPRIMARY KEY (id)\n",
      ")\n",
      "\n",
      "\n",
      "2021-10-27 12:40:34,266 INFO sqlalchemy.engine.Engine [no key 0.00218s] ()\n",
      "2021-10-27 12:40:34,297 INFO sqlalchemy.engine.Engine COMMIT\n"
     ]
    }
   ],
   "source": [
    "class Customers(Base):\n",
    "    __tablename__ = 'customers'\n",
    "    id = Column(Integer, primary_key=True)\n",
    "    name = Column(String)\n",
    "    address = Column(String)\n",
    "    email = Column(String)\n",
    "\n",
    "Base.metadata.create_all(db)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sqlalchemy.orm import sessionmaker\n",
    "Session = sessionmaker(bind = db)\n",
    "session = Session()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Adding records"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:34,351 INFO sqlalchemy.engine.Engine BEGIN (implicit)\n",
      "2021-10-27 12:40:34,353 INFO sqlalchemy.engine.Engine INSERT INTO customers (name, address, email) VALUES (?, ?, ?)\n",
      "2021-10-27 12:40:34,354 INFO sqlalchemy.engine.Engine [generated in 0.00115s] ('Renato Souza', 'Sagedergasse 21A', 'meu_email@gmail.com')\n",
      "2021-10-27 12:40:34,360 INFO sqlalchemy.engine.Engine COMMIT\n"
     ]
    }
   ],
   "source": [
    "c1 = Customers(name = 'Renato Souza', address = 'Sagedergasse 21A', email = 'meu_email@gmail.com')\n",
    "\n",
    "session.add(c1)\n",
    "session.commit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:34,400 INFO sqlalchemy.engine.Engine BEGIN (implicit)\n",
      "2021-10-27 12:40:34,401 INFO sqlalchemy.engine.Engine INSERT INTO customers (name, address, email) VALUES (?, ?, ?)\n",
      "2021-10-27 12:40:34,402 INFO sqlalchemy.engine.Engine [cached since 0.04781s ago] ('Hans Andersen', 'Yellow Brick Road, 43', 'hca_thebest@gmail.com')\n",
      "2021-10-27 12:40:34,405 INFO sqlalchemy.engine.Engine INSERT INTO customers (name, address, email) VALUES (?, ?, ?)\n",
      "2021-10-27 12:40:34,405 INFO sqlalchemy.engine.Engine [cached since 0.05155s ago] ('Monteiro Lobato', 'Raiffeisengürtel, 1234', 'narizinho@gmail.com')\n",
      "2021-10-27 12:40:34,406 INFO sqlalchemy.engine.Engine INSERT INTO customers (name, address, email) VALUES (?, ?, ?)\n",
      "2021-10-27 12:40:34,407 INFO sqlalchemy.engine.Engine [cached since 0.05327s ago] ('Rolando Lero', 'Rua do Lavradio, 34', 'chico@gmail.com')\n",
      "2021-10-27 12:40:34,408 INFO sqlalchemy.engine.Engine COMMIT\n"
     ]
    }
   ],
   "source": [
    "session.add_all([\n",
    "   Customers(name = 'Hans Andersen', address = 'Yellow Brick Road, 43', email = 'hca_thebest@gmail.com'), \n",
    "   Customers(name = 'Monteiro Lobato', address = 'Raiffeisengürtel, 1234', email = 'narizinho@gmail.com'), \n",
    "   Customers(name = 'Rolando Lero', address = 'Rua do Lavradio, 34', email = 'chico@gmail.com')]\n",
    ")\n",
    "\n",
    "session.commit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Querying"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:34,483 INFO sqlalchemy.engine.Engine BEGIN (implicit)\n",
      "2021-10-27 12:40:34,492 INFO sqlalchemy.engine.Engine SELECT customers.id AS customers_id, customers.name AS customers_name, customers.address AS customers_address, customers.email AS customers_email \n",
      "FROM customers\n",
      "2021-10-27 12:40:34,494 INFO sqlalchemy.engine.Engine [generated in 0.00236s] ()\n",
      "Name:  Renato Souza Address: Sagedergasse 21A Email: meu_email@gmail.com\n",
      "Name:  Hans Andersen Address: Yellow Brick Road, 43 Email: hca_thebest@gmail.com\n",
      "Name:  Monteiro Lobato Address: Raiffeisengürtel, 1234 Email: narizinho@gmail.com\n",
      "Name:  Rolando Lero Address: Rua do Lavradio, 34 Email: chico@gmail.com\n"
     ]
    }
   ],
   "source": [
    "result = session.query(Customers).all()\n",
    "\n",
    "for row in result:\n",
    "    print (\"Name: \",row.name, \"Address:\",row.address, \"Email:\",row.email)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### [Updating](https://www.tutorialspoint.com/sqlalchemy/sqlalchemy_orm_updating_objects.htm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name:  Renato Souza Address: Sagedergasse 21A Email: meu_email@gmail.com\n"
     ]
    }
   ],
   "source": [
    "x = session.query(Customers).get(1)\n",
    "print (\"Name: \", x.name, \"Address:\", x.address, \"Email:\", x.email)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "x.address = 'New Address modified'\n",
    "#session.commit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Changes are displayed but not commited"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:34,587 INFO sqlalchemy.engine.Engine UPDATE customers SET address=? WHERE customers.id = ?\n",
      "2021-10-27 12:40:34,588 INFO sqlalchemy.engine.Engine [generated in 0.00086s] ('New Address modified', 1)\n",
      "2021-10-27 12:40:34,600 INFO sqlalchemy.engine.Engine SELECT customers.id AS customers_id, customers.name AS customers_name, customers.address AS customers_address, customers.email AS customers_email \n",
      "FROM customers\n",
      " LIMIT ? OFFSET ?\n",
      "2021-10-27 12:40:34,607 INFO sqlalchemy.engine.Engine [generated in 0.00780s] (1, 0)\n",
      "Name:  Renato Souza Address: New Address modified Email: meu_email@gmail.com\n"
     ]
    }
   ],
   "source": [
    "x = session.query(Customers).first()\n",
    "print (\"Name: \", x.name, \"Address:\", x.address, \"Email:\", x.email)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If not commited, it can be rolled back"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:34,638 INFO sqlalchemy.engine.Engine ROLLBACK\n",
      "2021-10-27 12:40:34,647 INFO sqlalchemy.engine.Engine BEGIN (implicit)\n",
      "2021-10-27 12:40:34,650 INFO sqlalchemy.engine.Engine SELECT customers.id AS customers_id, customers.name AS customers_name, customers.address AS customers_address, customers.email AS customers_email \n",
      "FROM customers \n",
      "WHERE customers.id = ?\n",
      "2021-10-27 12:40:34,651 INFO sqlalchemy.engine.Engine [generated in 0.00209s] (1,)\n",
      "Name:  Renato Souza Address: Sagedergasse 21A Email: meu_email@gmail.com\n"
     ]
    }
   ],
   "source": [
    "session.rollback()\n",
    "\n",
    "print (\"Name: \", x.name, \"Address:\", x.address, \"Email:\", x.email)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Filtering (<, >, ==, !=, Regex, in, ...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:34,671 INFO sqlalchemy.engine.Engine SELECT customers.id AS customers_id, customers.name AS customers_name, customers.address AS customers_address, customers.email AS customers_email \n",
      "FROM customers \n",
      "WHERE customers.id > ?\n",
      "2021-10-27 12:40:34,674 INFO sqlalchemy.engine.Engine [generated in 0.00274s] (2,)\n",
      "ID: 3 Name:  Monteiro Lobato Address: Raiffeisengürtel, 1234 Email: narizinho@gmail.com\n",
      "ID: 4 Name:  Rolando Lero Address: Rua do Lavradio, 34 Email: chico@gmail.com\n"
     ]
    }
   ],
   "source": [
    "result = session.query(Customers).filter(Customers.id > 2)\n",
    "\n",
    "for row in result:\n",
    "    print (\"ID:\", row.id, \"Name: \",row.name, \"Address:\",row.address, \"Email:\",row.email)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:34,699 INFO sqlalchemy.engine.Engine SELECT customers.id AS customers_id, customers.name AS customers_name, customers.address AS customers_address, customers.email AS customers_email \n",
      "FROM customers \n",
      "WHERE customers.id = ?\n",
      "2021-10-27 12:40:34,701 INFO sqlalchemy.engine.Engine [generated in 0.00236s] (2,)\n",
      "ID: 2 Name:  Hans Andersen Address: Yellow Brick Road, 43 Email: hca_thebest@gmail.com\n"
     ]
    }
   ],
   "source": [
    "result = session.query(Customers).filter(Customers.id == 2)\n",
    "\n",
    "for row in result:\n",
    "   print (\"ID:\", row.id, \"Name: \",row.name, \"Address:\",row.address, \"Email:\",row.email)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:34,730 INFO sqlalchemy.engine.Engine SELECT customers.id AS customers_id, customers.name AS customers_name, customers.address AS customers_address, customers.email AS customers_email \n",
      "FROM customers \n",
      "WHERE customers.id != ?\n",
      "2021-10-27 12:40:34,734 INFO sqlalchemy.engine.Engine [generated in 0.00436s] (2,)\n",
      "ID: 1 Name:  Renato Souza Address: Sagedergasse 21A Email: meu_email@gmail.com\n",
      "ID: 3 Name:  Monteiro Lobato Address: Raiffeisengürtel, 1234 Email: narizinho@gmail.com\n",
      "ID: 4 Name:  Rolando Lero Address: Rua do Lavradio, 34 Email: chico@gmail.com\n"
     ]
    }
   ],
   "source": [
    "result = session.query(Customers).filter(Customers.id != 2)\n",
    "\n",
    "for row in result:\n",
    "   print (\"ID:\", row.id, \"Name: \",row.name, \"Address:\",row.address, \"Email:\",row.email)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:34,769 INFO sqlalchemy.engine.Engine SELECT customers.id AS customers_id, customers.name AS customers_name, customers.address AS customers_address, customers.email AS customers_email \n",
      "FROM customers \n",
      "WHERE customers.name LIKE ?\n",
      "2021-10-27 12:40:34,772 INFO sqlalchemy.engine.Engine [generated in 0.00309s] ('Ra%',)\n"
     ]
    }
   ],
   "source": [
    "result = session.query(Customers).filter(Customers.name.like('Ra%'))\n",
    "\n",
    "for row in result:\n",
    "    print (\"ID:\", row.id, \"Name: \",row.name, \"Address:\",row.address, \"Email:\",row.email)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:34,797 INFO sqlalchemy.engine.Engine SELECT customers.id AS customers_id, customers.name AS customers_name, customers.address AS customers_address, customers.email AS customers_email \n",
      "FROM customers \n",
      "WHERE customers.id IN (?, ?)\n",
      "2021-10-27 12:40:34,800 INFO sqlalchemy.engine.Engine [generated in 0.00301s] (1, 3)\n",
      "ID: 1 Name:  Renato Souza Address: Sagedergasse 21A Email: meu_email@gmail.com\n",
      "ID: 3 Name:  Monteiro Lobato Address: Raiffeisengürtel, 1234 Email: narizinho@gmail.com\n"
     ]
    }
   ],
   "source": [
    "result = session.query(Customers).filter(Customers.id.in_([1,3]))\n",
    "\n",
    "for row in result:\n",
    "    print (\"ID:\", row.id, \"Name: \",row.name, \"Address:\",row.address, \"Email:\",row.email)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:34,843 INFO sqlalchemy.engine.Engine SELECT customers.id AS customers_id, customers.name AS customers_name, customers.address AS customers_address, customers.email AS customers_email \n",
      "FROM customers \n",
      "WHERE customers.id > ? AND customers.name LIKE ?\n",
      "2021-10-27 12:40:34,850 INFO sqlalchemy.engine.Engine [generated in 0.00715s] (2, 'Ra%')\n"
     ]
    }
   ],
   "source": [
    "result = session.query(Customers).filter(Customers.id > 2, Customers.name.like('Ra%'))\n",
    "\n",
    "for row in result:\n",
    "    print (\"ID:\", row.id, \"Name: \",row.name, \"Address:\",row.address, \"Email:\",row.email)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:34,899 INFO sqlalchemy.engine.Engine SELECT customers.id AS customers_id, customers.name AS customers_name, customers.address AS customers_address, customers.email AS customers_email \n",
      "FROM customers \n",
      "WHERE customers.id > ? AND customers.name LIKE ?\n",
      "2021-10-27 12:40:34,901 INFO sqlalchemy.engine.Engine [generated in 0.00180s] (2, 'Ra%')\n"
     ]
    }
   ],
   "source": [
    "from sqlalchemy import and_\n",
    "result = session.query(Customers).filter(and_(Customers.id > 2, Customers.name.like('Ra%')))\n",
    "\n",
    "for row in result:\n",
    "    print (\"ID:\", row.id, \"Name: \",row.name, \"Address:\",row.address, \"Email:\",rorow.email)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:34,923 INFO sqlalchemy.engine.Engine SELECT customers.id AS customers_id, customers.name AS customers_name, customers.address AS customers_address, customers.email AS customers_email \n",
      "FROM customers \n",
      "WHERE customers.id > ? OR customers.name LIKE ?\n",
      "2021-10-27 12:40:34,924 INFO sqlalchemy.engine.Engine [generated in 0.00168s] (2, 'Ra%')\n",
      "ID: 3 Name:  Monteiro Lobato Address: Raiffeisengürtel, 1234 Email: narizinho@gmail.com\n",
      "ID: 4 Name:  Rolando Lero Address: Rua do Lavradio, 34 Email: chico@gmail.com\n"
     ]
    }
   ],
   "source": [
    "from sqlalchemy import or_\n",
    "result = session.query(Customers).filter(or_(Customers.id > 2, Customers.name.like('Ra%')))\n",
    "\n",
    "for row in result:\n",
    "    print (\"ID:\", row.id, \"Name: \",row.name, \"Address:\",row.address, \"Email:\",row.email)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file does not exist\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    os.remove(\"../SampleDBs/sales.db\")\n",
    "    print(\"removed file\")\n",
    "except:\n",
    "    print(\"file does not exist\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### [Building Relationships](https://www.tutorialspoint.com/sqlalchemy/sqlalchemy_orm_building_relationship.htm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:35,044 INFO sqlalchemy.engine.Engine BEGIN (implicit)\n",
      "2021-10-27 12:40:35,048 INFO sqlalchemy.engine.Engine PRAGMA main.table_info(\"customers\")\n",
      "2021-10-27 12:40:35,050 INFO sqlalchemy.engine.Engine [raw sql] ()\n",
      "2021-10-27 12:40:35,054 INFO sqlalchemy.engine.Engine PRAGMA main.table_info(\"invoices\")\n",
      "2021-10-27 12:40:35,056 INFO sqlalchemy.engine.Engine [raw sql] ()\n",
      "2021-10-27 12:40:35,057 INFO sqlalchemy.engine.Engine PRAGMA temp.table_info(\"invoices\")\n",
      "2021-10-27 12:40:35,059 INFO sqlalchemy.engine.Engine [raw sql] ()\n",
      "2021-10-27 12:40:35,062 INFO sqlalchemy.engine.Engine \n",
      "CREATE TABLE invoices (\n",
      "\tid INTEGER NOT NULL, \n",
      "\tcustid INTEGER, \n",
      "\tinvno INTEGER, \n",
      "\tamount INTEGER, \n",
      "\tPRIMARY KEY (id), \n",
      "\tFOREIGN KEY(custid) REFERENCES customers (id)\n",
      ")\n",
      "\n",
      "\n",
      "2021-10-27 12:40:35,064 INFO sqlalchemy.engine.Engine [no key 0.00199s] ()\n",
      "2021-10-27 12:40:35,103 INFO sqlalchemy.engine.Engine COMMIT\n"
     ]
    }
   ],
   "source": [
    "from sqlalchemy import create_engine, ForeignKey, Column, Integer, String\n",
    "from sqlalchemy.orm import relationship\n",
    "from sqlalchemy.ext.declarative import declarative_base\n",
    "from sqlalchemy.orm import sessionmaker\n",
    "\n",
    "db = create_engine('sqlite:///../SampleDBs/sales.db', echo=True)\n",
    "Base = declarative_base()\n",
    "\n",
    "class Customer(Base):\n",
    "    __tablename__ = 'customers'\n",
    "    id = Column(Integer, primary_key = True)\n",
    "    name = Column(String)\n",
    "    address = Column(String)\n",
    "    email = Column(String)\n",
    "\n",
    "class Invoice(Base):\n",
    "    __tablename__ = 'invoices'\n",
    "    id = Column(Integer, primary_key = True)\n",
    "    custid = Column(Integer, ForeignKey('customers.id'))\n",
    "    invno = Column(Integer)\n",
    "    amount = Column(Integer)\n",
    "    customer = relationship(\"Customer\", back_populates = \"invoices\")\n",
    "\n",
    "Customer.invoices = relationship(\"Invoice\", order_by = Invoice.id, back_populates = \"customer\")\n",
    "Base.metadata.create_all(db)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "c1 = Customer(name = \"Arnold Hinton\", address = \"Bank Street\", email = \"arnold@gmail.com\")\n",
    "c1.invoices = [Invoice(invno = 10, amount = 15000), Invoice(invno = 14, amount = 3850)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:35,195 INFO sqlalchemy.engine.Engine BEGIN (implicit)\n",
      "2021-10-27 12:40:35,196 INFO sqlalchemy.engine.Engine INSERT INTO customers (name, address, email) VALUES (?, ?, ?)\n",
      "2021-10-27 12:40:35,199 INFO sqlalchemy.engine.Engine [generated in 0.00243s] ('Arnold Hinton', 'Bank Street', 'arnold@gmail.com')\n",
      "2021-10-27 12:40:35,205 INFO sqlalchemy.engine.Engine INSERT INTO invoices (custid, invno, amount) VALUES (?, ?, ?)\n",
      "2021-10-27 12:40:35,208 INFO sqlalchemy.engine.Engine [generated in 0.00346s] (5, 10, 15000)\n",
      "2021-10-27 12:40:35,210 INFO sqlalchemy.engine.Engine INSERT INTO invoices (custid, invno, amount) VALUES (?, ?, ?)\n",
      "2021-10-27 12:40:35,210 INFO sqlalchemy.engine.Engine [cached since 0.005515s ago] (5, 14, 3850)\n",
      "2021-10-27 12:40:35,212 INFO sqlalchemy.engine.Engine COMMIT\n"
     ]
    }
   ],
   "source": [
    "Session = sessionmaker(bind=db)\n",
    "session = Session()\n",
    "session.add(c1)\n",
    "session.commit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:35,290 INFO sqlalchemy.engine.Engine BEGIN (implicit)\n",
      "2021-10-27 12:40:35,296 INFO sqlalchemy.engine.Engine INSERT INTO customers (name, address, email) VALUES (?, ?, ?)\n",
      "2021-10-27 12:40:35,298 INFO sqlalchemy.engine.Engine [cached since 0.1019s ago] ('Mick Jagger', 'Abbey Road, 5', 'mick@jagger.com')\n",
      "2021-10-27 12:40:35,306 INFO sqlalchemy.engine.Engine INSERT INTO invoices (custid, invno, amount) VALUES (?, ?, ?)\n",
      "2021-10-27 12:40:35,307 INFO sqlalchemy.engine.Engine [cached since 0.1026s ago] (6, 3, 10000)\n",
      "2021-10-27 12:40:35,309 INFO sqlalchemy.engine.Engine INSERT INTO invoices (custid, invno, amount) VALUES (?, ?, ?)\n",
      "2021-10-27 12:40:35,310 INFO sqlalchemy.engine.Engine [cached since 0.1048s ago] (6, 4, 5000)\n",
      "2021-10-27 12:40:35,311 INFO sqlalchemy.engine.Engine COMMIT\n"
     ]
    }
   ],
   "source": [
    "c2 = [\n",
    "   Customer(\n",
    "      name = \"Mick Jagger\", \n",
    "      address = \"Abbey Road, 5\",\n",
    "      email = \"mick@jagger.com\",\n",
    "      invoices = [Invoice(invno = 3, amount = 10000), \n",
    "      Invoice(invno = 4, amount = 5000)]\n",
    "   )\n",
    "]\n",
    "\n",
    "session.add(c2[0])\n",
    "session.commit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:35,380 INFO sqlalchemy.engine.Engine BEGIN (implicit)\n",
      "2021-10-27 12:40:35,383 INFO sqlalchemy.engine.Engine INSERT INTO customers (name, address, email) VALUES (?, ?, ?)\n",
      "2021-10-27 12:40:35,385 INFO sqlalchemy.engine.Engine [cached since 0.1891s ago] ('Govind Kala', 'Gulmandi Aurangabad', 'kala@gmail.com')\n",
      "2021-10-27 12:40:35,396 INFO sqlalchemy.engine.Engine INSERT INTO customers (name, address, email) VALUES (?, ?, ?)\n",
      "2021-10-27 12:40:35,398 INFO sqlalchemy.engine.Engine [cached since 0.2015s ago] ('Abdul Rahman', 'Rohtak', 'abdulr@gmail.com')\n",
      "2021-10-27 12:40:35,400 INFO sqlalchemy.engine.Engine INSERT INTO invoices (custid, invno, amount) VALUES (?, ?, ?)\n",
      "2021-10-27 12:40:35,404 INFO sqlalchemy.engine.Engine [cached since 0.1994s ago] (7, 7, 12000)\n",
      "2021-10-27 12:40:35,406 INFO sqlalchemy.engine.Engine INSERT INTO invoices (custid, invno, amount) VALUES (?, ?, ?)\n",
      "2021-10-27 12:40:35,408 INFO sqlalchemy.engine.Engine [cached since 0.2025s ago] (7, 8, 18500)\n",
      "2021-10-27 12:40:35,409 INFO sqlalchemy.engine.Engine INSERT INTO invoices (custid, invno, amount) VALUES (?, ?, ?)\n",
      "2021-10-27 12:40:35,410 INFO sqlalchemy.engine.Engine [cached since 0.2051s ago] (8, 9, 15000)\n",
      "2021-10-27 12:40:35,411 INFO sqlalchemy.engine.Engine INSERT INTO invoices (custid, invno, amount) VALUES (?, ?, ?)\n",
      "2021-10-27 12:40:35,412 INFO sqlalchemy.engine.Engine [cached since 0.2069s ago] (8, 11, 6000)\n",
      "2021-10-27 12:40:35,413 INFO sqlalchemy.engine.Engine COMMIT\n"
     ]
    }
   ],
   "source": [
    "rows = [\n",
    "   Customer(\n",
    "      name = \"Govind Kala\", \n",
    "      address = \"Gulmandi Aurangabad\", \n",
    "      email = \"kala@gmail.com\", \n",
    "      invoices = [Invoice(invno = 7, amount = 12000), Invoice(invno = 8, amount = 18500)]),\n",
    "\n",
    "   Customer(\n",
    "      name = \"Abdul Rahman\", \n",
    "      address = \"Rohtak\", \n",
    "      email = \"abdulr@gmail.com\",\n",
    "      invoices = [Invoice(invno = 9, amount = 15000), \n",
    "      Invoice(invno = 11, amount = 6000)\n",
    "   ])\n",
    "]\n",
    "\n",
    "session.add_all(rows)\n",
    "session.commit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Querying](https://www.tutorialspoint.com/sqlalchemy/sqlalchemy_orm_using_query.htm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:35,485 INFO sqlalchemy.engine.Engine BEGIN (implicit)\n",
      "2021-10-27 12:40:35,488 INFO sqlalchemy.engine.Engine SELECT customers.id AS customers_id, customers.name AS customers_name, customers.address AS customers_address, customers.email AS customers_email \n",
      "FROM customers\n",
      "2021-10-27 12:40:35,490 INFO sqlalchemy.engine.Engine [generated in 0.00236s] ()\n",
      "Name:  Renato Souza Address: Sagedergasse 21A Email: meu_email@gmail.com\n",
      "Name:  Hans Andersen Address: Yellow Brick Road, 43 Email: hca_thebest@gmail.com\n",
      "Name:  Monteiro Lobato Address: Raiffeisengürtel, 1234 Email: narizinho@gmail.com\n",
      "Name:  Rolando Lero Address: Rua do Lavradio, 34 Email: chico@gmail.com\n",
      "Name:  Arnold Hinton Address: Bank Street Email: arnold@gmail.com\n",
      "Name:  Mick Jagger Address: Abbey Road, 5 Email: mick@jagger.com\n",
      "Name:  Govind Kala Address: Gulmandi Aurangabad Email: kala@gmail.com\n",
      "Name:  Abdul Rahman Address: Rohtak Email: abdulr@gmail.com\n"
     ]
    }
   ],
   "source": [
    "result = session.query(Customers).all()\n",
    "\n",
    "for row in result:\n",
    "   print (\"Name: \",row.name, \"Address:\",row.address, \"Email:\",row.email)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### [Joins](https://www.tutorialspoint.com/sqlalchemy/sqlalchemy_orm_working_with_joins.htm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-27 12:40:35,530 INFO sqlalchemy.engine.Engine SELECT customers.id AS customers_id, customers.name AS customers_name, customers.address AS customers_address, customers.email AS customers_email \n",
      "FROM customers JOIN invoices ON customers.id = invoices.custid \n",
      "WHERE invoices.amount = ?\n",
      "2021-10-27 12:40:35,532 INFO sqlalchemy.engine.Engine [generated in 0.00127s] (8500,)\n"
     ]
    }
   ],
   "source": [
    "result = session.query(Customer).join(Invoice).filter(Invoice.amount == 8500)\n",
    "for row in result:\n",
    "    for inv in row.invoices:\n",
    "        print (row.id, row.name, inv.invno, inv.amount)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file does not exist\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    os.remove(\"../SampleDBs/sales.db\")\n",
    "    print(\"removed file\")\n",
    "except:\n",
    "    print(\"file does not exist\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualizing ER Diagrams with [ERAlchemy](https://github.com/Alexis-benoist/eralchemy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!sudo apt-get install python3-dev build-essential\n",
    "#!sudo apt-get install -y graphviz \n",
    "#!pip install eralchemy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "#from eralchemy import render_er\n",
    "## Draw from SQLAlchemy base\n",
    "#render_er(Base, 'erd_from_sqlalchemy.png')\n",
    "\n",
    "## Draw from database\n",
    "#render_er(\"sqlite:///relative/path/to/db.db\", 'erd_from_sqlite.png')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}