Access_DB2_on_Cloud_using_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/Logos/organization_logo/organization_logo.png\" width=\"300\" alt=\"cognitiveclass.ai logo\"  />\n",
    "</center>\n",
    "\n",
    "# Access DB2 on Cloud using Python\n",
    "\n",
    "Estimated time needed: **15** minutes\n",
    "\n",
    "## Objectives\n",
    "\n",
    "After completing this lab you will be able to:\n",
    "\n",
    "*   Create a table\n",
    "*   Insert data into the table\n",
    "*   Query data from the table\n",
    "*   Retrieve the result set into a pandas dataframe\n",
    "*   Close the database connection\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Notice:** Please follow the instructions given in the first Lab of this course to Create a database service instance of Db2 on Cloud.\n",
    "\n",
    "## Task 1: Import the `ibm_db` Python library\n",
    "\n",
    "The `ibm_db` [API ](https://pypi.python.org/pypi/ibm_db/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkDB0201ENSkillsNetwork20127838-2021-01-01) provides a variety of useful Python functions for accessing and manipulating data in an IBM® data server database, including functions for connecting to a database, preparing and issuing SQL statements, fetching rows from result sets, calling stored procedures, committing and rolling back transactions, handling errors, and retrieving metadata.\n",
    "\n",
    "We import the ibm_db library into our Python Application\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting ibm_db==3.1.0\n",
      "  Using cached ibm_db-3.1.0-cp37-cp37m-linux_x86_64.whl\n",
      "Collecting ibm_db_sa==0.3.7\n",
      "  Using cached ibm_db_sa-0.3.7-py3-none-any.whl\n",
      "Collecting sqlalchemy>=0.7.3\n",
      "  Using cached SQLAlchemy-1.4.27-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.6 MB)\n",
      "Collecting importlib-metadata\n",
      "  Using cached importlib_metadata-4.8.2-py3-none-any.whl (17 kB)\n",
      "Collecting greenlet!=0.4.17\n",
      "  Using cached greenlet-1.1.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (150 kB)\n",
      "Collecting typing-extensions>=3.6.4\n",
      "  Using cached typing_extensions-4.0.1-py3-none-any.whl (22 kB)\n",
      "Collecting zipp>=0.5\n",
      "  Using cached zipp-3.6.0-py3-none-any.whl (5.3 kB)\n",
      "Installing collected packages: zipp, typing-extensions, importlib-metadata, greenlet, sqlalchemy, ibm-db, ibm-db-sa\n",
      "  Attempting uninstall: zipp\n",
      "    Found existing installation: zipp 3.6.0\n",
      "    Uninstalling zipp-3.6.0:\n",
      "      Successfully uninstalled zipp-3.6.0\n",
      "  Attempting uninstall: typing-extensions\n",
      "    Found existing installation: typing-extensions 4.0.1\n",
      "    Uninstalling typing-extensions-4.0.1:\n",
      "      Successfully uninstalled typing-extensions-4.0.1\n",
      "  Attempting uninstall: importlib-metadata\n",
      "    Found existing installation: importlib-metadata 4.8.2\n",
      "    Uninstalling importlib-metadata-4.8.2:\n",
      "      Successfully uninstalled importlib-metadata-4.8.2\n",
      "  Attempting uninstall: greenlet\n",
      "    Found existing installation: greenlet 1.1.2\n",
      "    Uninstalling greenlet-1.1.2:\n",
      "      Successfully uninstalled greenlet-1.1.2\n",
      "  Attempting uninstall: sqlalchemy\n",
      "    Found existing installation: SQLAlchemy 1.4.27\n",
      "    Uninstalling SQLAlchemy-1.4.27:\n",
      "      Successfully uninstalled SQLAlchemy-1.4.27\n",
      "  Attempting uninstall: ibm-db\n",
      "    Found existing installation: ibm-db 3.1.0\n",
      "    Uninstalling ibm-db-3.1.0:\n",
      "      Successfully uninstalled ibm-db-3.1.0\n",
      "  Attempting uninstall: ibm-db-sa\n",
      "    Found existing installation: ibm-db-sa 0.3.7\n",
      "    Uninstalling ibm-db-sa-0.3.7:\n",
      "      Successfully uninstalled ibm-db-sa-0.3.7\n",
      "Successfully installed greenlet-1.1.2 ibm-db-3.1.0 ibm-db-sa-0.3.7 importlib-metadata-4.8.2 sqlalchemy-1.4.27 typing-extensions-4.0.1 zipp-3.6.0\n"
     ]
    }
   ],
   "source": [
    "!pip install --force-reinstall ibm_db==3.1.0 ibm_db_sa==0.3.7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import ibm_db"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the command above completes, the `ibm_db` library is loaded in your notebook.\n",
    "\n",
    "## Task 2: Identify the database connection credentials\n",
    "\n",
    "Connecting to dashDB or DB2 database requires the following information:\n",
    "\n",
    "*   Driver Name\n",
    "*   Database name\n",
    "*   Host DNS name or IP address\n",
    "*   Host port\n",
    "*   Connection protocol\n",
    "*   User ID\n",
    "*   User Password\n",
    "\n",
    "**Notice:** To obtain credentials please refer to the instructions given in the first Lab of this course\n",
    "\n",
    "Now enter your database credentials below\n",
    "\n",
    "Replace the placeholder values in angular brackets <> below with your actual database credentials\n",
    "\n",
    "e.g. replace \"database\" with \"BLUDB\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Replace the placeholder values with your actual Db2 hostname, username, and password:\n",
    "dsn_hostname = \"55fbc997-9266-4331-afd3-888b05e734c0.bs2io90l08kqb1od8lcg.databases.appdomain.cloud\" # e.g.: \"54a2f15b-5c0f-46df-8954-7e38e612c2bd.c1ogj3sd0tgtu0lqde00.databases.appdomain.cloud\"\n",
    "dsn_uid = \"wzw37676\"        # e.g. \"abc12345\"\n",
    "dsn_pwd = \"7tdf7kLUUuJtCwLR\"      # e.g. \"7dBZ3wWt9XN6$o0J\"\n",
    "\n",
    "dsn_driver = \"{IBM DB2 ODBC DRIVER}\"\n",
    "dsn_database = \"bludb\"            # e.g. \"BLUDB\"\n",
    "dsn_port = \"31929\"                # e.g. \"32733\" \n",
    "dsn_protocol = \"TCPIP\"            # i.e. \"TCPIP\"\n",
    "dsn_security = \"ssl\"              #i.e. \"SSL\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 3: Create the database connection\n",
    "\n",
    "Ibm_db API uses the IBM Data Server Driver for ODBC and CLI APIs to connect to IBM DB2 and Informix.\n",
    "\n",
    "Create the database connection\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Connected to database:  bludb as user:  wzw37676 on host:  55fbc997-9266-4331-afd3-888b05e734c0.bs2io90l08kqb1od8lcg.databases.appdomain.cloud\n"
     ]
    }
   ],
   "source": [
    "#Create database connection\n",
    "#DO NOT MODIFY THIS CELL. Just RUN it with Shift + Enter\n",
    "dsn = (\n",
    "    \"DRIVER={0};\"\n",
    "    \"DATABASE={1};\"\n",
    "    \"HOSTNAME={2};\"\n",
    "    \"PORT={3};\"\n",
    "    \"PROTOCOL={4};\"\n",
    "    \"UID={5};\"\n",
    "    \"PWD={6};\"\n",
    "    \"SECURITY={7};\").format(dsn_driver, dsn_database, dsn_hostname, dsn_port, dsn_protocol, dsn_uid, dsn_pwd,dsn_security)\n",
    "\n",
    "try:\n",
    "    conn = ibm_db.connect(dsn, \"\", \"\")\n",
    "    print (\"Connected to database: \", dsn_database, \"as user: \", dsn_uid, \"on host: \", dsn_hostname)\n",
    "\n",
    "except:\n",
    "    print (\"Unable to connect: \", ibm_db.conn_errormsg() )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 4: Create a table in the database\n",
    "\n",
    "In this step we will create a table in the database with following details:\n",
    "\n",
    "<img src = \"https://ibm.box.com/shared/static/ztd2cn4xkdoj5erlk4hhng39kbp63s1h.jpg\" align=\"center\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Lets first drop the table INSTRUCTOR in case it exists from a previous attempt\n",
    "dropQuery = \"drop table INSTRUCTOR\"\n",
    "\n",
    "#Now execute the drop statment\n",
    "dropStmt = ibm_db.exec_immediate(conn, dropQuery)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dont worry if you get this error:\n",
    "\n",
    "If you see an exception/error similar to the following, indicating that INSTRUCTOR is an undefined name, that's okay. It just implies that the INSTRUCTOR table does not exist in the table - which would be the case if you had not created it previously.\n",
    "\n",
    "Exception: \\[IBM]\\[CLI Driver]\\[DB2/LINUXX8664] SQL0204N  \"ABC12345.INSTRUCTOR\" is an undefined name.  SQLSTATE=42704 SQLCODE=-204\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Construct the Create Table DDL statement - replace the ... with rest of the statement\n",
    "createQuery = \"create table INSTRUCTOR(id INTEGER PRIMARY KEY NOT NULL, fname VARCHAR(15), lname VARCHAR(15), city VARCHAR(15), CCODE CHAR(10))\"\n",
    "\n",
    "#Now fill in the name of the method and execute the statement\n",
    "createStmt = ibm_db.exec_immediate(conn, createQuery)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "createQuery = \"create table INSTRUCTOR(ID INTEGER PRIMARY KEY NOT NULL, FNAME VARCHAR(20), LNAME VARCHAR(20), CITY VARCHAR(20), CCODE CHAR(2))\"\n",
    "\n",
    "createStmt = ibm_db.exec_immediate(conn,createQuery)\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 5: Insert data into the table\n",
    "\n",
    "In this step we will insert some rows of data into the table.\n",
    "\n",
    "The INSTRUCTOR table we created in the previous step contains 3 rows of data:\n",
    "\n",
    "<img src=\"https://ibm.box.com/shared/static/j5yjassxefrjknivfpekj7698dqe4d8i.jpg\" align=\"center\">\n",
    "\n",
    "We will start by inserting just the first row of data, i.e. for instructor Rav Ahuja\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Construct the query - replace ... with the insert statement\n",
    "insertQuery = \"insert into INSTRUCTOR values (1, 'Rav', 'Ahuja', 'TORONTTO', 'CA');\"\n",
    "\n",
    "#execute the insert statement\n",
    "insertStmt = ibm_db.exec_immediate(conn, insertQuery)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "insertQuery = \"insert into INSTRUCTOR values (1, 'Rav', 'Ahuja', 'TORONTO', 'CA')\"\n",
    "\n",
    "insertStmt = ibm_db.exec_immediate(conn, insertQuery)\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now use a single query to insert the remaining two rows of data\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "#replace ... with the insert statement that inerts the remaining two rows of data\n",
    "insertQuery2 = \"insert into INSTRUCTOR values (2, 'Raul', 'Chong', 'Markham', 'CA'), (3, 'Hima', 'Vasudevan', 'Chicago', 'US');\"\n",
    "\n",
    "#execute the statement\n",
    "insertStmt2 = ibm_db.exec_immediate(conn, insertQuery2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "insertQuery2 = \"insert into INSTRUCTOR values (2, 'Raul', 'Chong', 'Markham', 'CA'), (3, 'Hima', 'Vasudevan', 'Chicago', 'US')\"\n",
    "\n",
    "insertStmt2 = ibm_db.exec_immediate(conn, insertQuery2)\n",
    "\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 6: Query data in the table\n",
    "\n",
    "In this step we will retrieve data we inserted into the INSTRUCTOR table.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ID': 1,\n",
       " 0: 1,\n",
       " 'FNAME': 'Rav',\n",
       " 1: 'Rav',\n",
       " 'LNAME': 'Ahuja',\n",
       " 2: 'Ahuja',\n",
       " 'CITY': 'TORONTTO',\n",
       " 3: 'TORONTTO',\n",
       " 'CCODE': 'CA        ',\n",
       " 4: 'CA        '}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Construct the query that retrieves all rows from the INSTRUCTOR table\n",
    "selectQuery = \"select * from INSTRUCTOR\"\n",
    "\n",
    "#Execute the statement\n",
    "selectStmt = ibm_db.exec_immediate(conn, selectQuery)\n",
    "\n",
    "#Fetch the Dictionary (for the first row only) - replace ... with your code\n",
    "ibm_db.fetch_both(selectStmt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "#Construct the query that retrieves all rows from the INSTRUCTOR table\n",
    "selectQuery = \"select * from INSTRUCTOR\"\n",
    "\n",
    "#Execute the statement\n",
    "selectStmt = ibm_db.exec_immediate(conn, selectQuery)\n",
    "\n",
    "#Fetch the Dictionary (for the first row only)\n",
    "ibm_db.fetch_both(selectStmt)\n",
    "\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ID: 2  FNAME: Raul\n",
      " ID: 3  FNAME: Hima\n"
     ]
    }
   ],
   "source": [
    "#Fetch the rest of the rows and print the ID and FNAME for those rows\n",
    "while ibm_db.fetch_row(selectStmt) != False:\n",
    "   print (\" ID:\",  ibm_db.result(selectStmt, 0), \" FNAME:\",  ibm_db.result(selectStmt, \"FNAME\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "#Fetch the rest of the rows and print the ID and FNAME for those rows\n",
    "while ibm_db.fetch_row(selectStmt) != False:\n",
    "    print (\" ID:\",  ibm_db.result(selectStmt, 0), \" FNAME:\",  ibm_db.result(selectStmt, \"FNAME\"))\n",
    "\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bonus: now write and execute an update statement that changes the Rav's CITY to MOOSETOWN\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Enter your code below\n",
    "updateQuery = \"update INSTRUCTOR set CITY='MOOSETOWN' where FNAME='Rav'\"\n",
    "updateStmt = ibm_db.exec_immediate(conn, updateQuery)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "updateQuery = \"update INSTRUCTOR set CITY='MOOSETOWN' where FNAME='Rav'\"\n",
    "updateStmt = ibm_db.exec_immediate(conn, updateQuery)\n",
    "\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 7: Retrieve data into Pandas\n",
    "\n",
    "In this step we will retrieve the contents of the INSTRUCTOR table into a Pandas dataframe\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import pandas\n",
    "import ibm_db_dbi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#connection for pandas\n",
    "pconn = ibm_db_dbi.Connection(conn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ahuja'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#query statement to retrieve all rows in INSTRUCTOR table\n",
    "selectQuery = \"select * from INSTRUCTOR\"\n",
    "\n",
    "#retrieve the query results into a pandas dataframe\n",
    "pdf = pandas.read_sql(selectQuery, pconn)\n",
    "\n",
    "#print just the LNAME for first row in the pandas data frame\n",
    "pdf.LNAME[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "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>FNAME</th>\n",
       "      <th>LNAME</th>\n",
       "      <th>CITY</th>\n",
       "      <th>CCODE</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Rav</td>\n",
       "      <td>Ahuja</td>\n",
       "      <td>MOOSETOWN</td>\n",
       "      <td>CA</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>Raul</td>\n",
       "      <td>Chong</td>\n",
       "      <td>Markham</td>\n",
       "      <td>CA</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>Hima</td>\n",
       "      <td>Vasudevan</td>\n",
       "      <td>Chicago</td>\n",
       "      <td>US</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   ID FNAME      LNAME       CITY       CCODE\n",
       "0   1   Rav      Ahuja  MOOSETOWN  CA        \n",
       "1   2  Raul      Chong    Markham  CA        \n",
       "2   3  Hima  Vasudevan    Chicago  US        "
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#print the entire data frame\n",
    "pdf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once the data is in a Pandas dataframe, you can do the typical pandas operations on it.\n",
    "\n",
    "For example you can use the shape method to see how many rows and columns are in the dataframe\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 5)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pdf.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 8: Close the Connection\n",
    "\n",
    "We free all resources by closing the connection. Remember that it is always important to close connections so that we can avoid unused connections taking up resources.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ibm_db.close(conn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary\n",
    "\n",
    "In this tutorial you established a connection to a database instance of DB2 Warehouse on Cloud from a Python notebook using ibm_db API. Then created a table and insert a few rows of data into it. Then queried the data. You also retrieved the data into a pandas dataframe.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Author\n",
    "\n",
    "<a href=\"https://www.linkedin.com/in/ravahuja/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkDB0201ENSkillsNetwork20127838-2021-01-01\" target=\"_blank\">Rav Ahuja</a>\n",
    "\n",
    "## Change Log\n",
    "\n",
    "| Date (YYYY-MM-DD) | Version | Changed By | Change Description                 |\n",
    "| ----------------- | ------- | ---------- | ---------------------------------- |\n",
    "| 2021-11-17        | 2.2     | Lakshmi    | Updated library                    |\n",
    "| 2021-07-09        | 2.1     | Malika     | Updated connection string          |\n",
    "| 2020-08-28        | 2.0     | Lavanya    | Moved lab to course repo in GitLab |\n",
    "\n",
    "<hr>\n",
    "\n",
    "## <h3 align=\"center\"> © IBM Corporation 2020. All rights reserved. <h3/>\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python",
   "language": "python",
   "name": "conda-env-python-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.12"
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}