exercises/Create_And_Query_EHR_Database.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c82d7193",
   "metadata": {},
   "source": [
    "# Creating and querying an EHR database\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2502982",
   "metadata": {},
   "source": [
    "In today's digital age, the ability to search for information quickly and efficiently has become more important than ever. Available methods range from the alphabetical or dictionary like search to more complicated search methods such as the Google algorithm.\n",
    "\n",
    "This is a simple create and query database exercise related to medicine for beginners. \n",
    "\n",
    "In this exercise we'll learn how to:\n",
    "- Create a SQL database with 1000s of dummy records.\n",
    "- Find a patient with an SQL query.\n",
    "- Create an input prompt for a patient search.\n",
    "- Make a for or while loop that searches for a patient.\n",
    "- Return a patient if certain criteria are satisfied.\n",
    "- Explore what effect additional algorithms could have on the workflow efficiency in the clinic during a patient search. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0e09066",
   "metadata": {},
   "source": [
    "## Part 1: "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04edb0bb",
   "metadata": {},
   "source": [
    "We first install the necessary module \"ipython-sql\" and \"pandas\" to connect to a database "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b50b48bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install pandas\n",
    "%pip install ipython-sql\n",
    "\n",
    "import sqlite3\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3de44a01",
   "metadata": {},
   "source": [
    "We create a connection to the database and a cursor that sends the query to the database. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c94d45e",
   "metadata": {},
   "outputs": [],
   "source": [
    "conn = sqlite3.connect('students.db')\n",
    "cursor = conn.cursor()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ef4d171",
   "metadata": {},
   "source": [
    "Now try to make a function in Python that creates a database table with an SQL query. The table should have social security number, name, address, email, phonenumber and insurance ID as column headers. You can add more columns if you want. Also think about datatypes you want for every column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49675ae0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Answer\n",
    "def make_table(conn, cursor, table_name):\n",
    "    query = \"CREATE TABLE \" + table_name + \"\"\"(\n",
    "                SSN NUMBER(10) PRIMARY KEY NOT NULL,\n",
    "                Name VARCHAR2(100) NOT NULL,\n",
    "                Address VARCHAR2(100) NOT NULL,\n",
    "                Email VARCHAR2(100) NOT NULL,\n",
    "                Phonenumber VARCHAR2(100) NOT NULL,\n",
    "                InsuranceID NUMBER(10) NOT NULL\n",
    "                )\"\"\"\n",
    "    cursor.execute(query)\n",
    "    conn.commit()\n",
    "\n",
    "make_table(conn, cursor, \"Patients\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca4b5e98",
   "metadata": {},
   "source": [
    "Now we finished the setup phase, try to make a Python function \"insert_patient_record()\" that uses SQL to insert a patient in the table with patient information  as an input. Run the function and Create the first patient in your EHR database :-P\n",
    "\n",
    "(This is not an easy task as it requires you to keep yourself to multiple syntax criteria at the same time: Python and that of SQL. Try to print out the query every time you test your function and remember that you can identify text that should be parsed as a string by \"\"\" , \" or ' in python. Use this to your advantage. )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd698ec2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# POPULATE TABLE PATIENT RECORDS\n",
    "def insert_patient_record(table_name, SSN, name, address, email, phonenumber, insurance_id):\n",
    "    query = \"\"\"INSERT INTO \"{table_name}\" (SSN, Name, Address, Email, InsuranceID, Phonenumber)\n",
    "            VALUES ({SSN_number}, \"{name_string}\", \"{address_string}\", \"{email_string}\", {insuranceid_number}, {phonenumber_str})\"\"\"\n",
    "    query = query.format(table_name=table_name, SSN_number=SSN, name_string=name, address_string=address, email_string=email, insuranceid_number=insurance_id, phonenumber_str=phonenumber)\n",
    "    print(query)\n",
    "    cursor.execute(query)\n",
    "    conn.commit()\n",
    "\n",
    "insert_patient_record(\"Patients\", 1234567890, \"John Smith\", \"123 Main St\", \"someting@email.com\", \"1234567890\", 1234567890)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a603e2b",
   "metadata": {},
   "source": [
    "Use the following code to create a test sample with your function from the former exercise. Try to understand whats happening. Place comments if you think that helps. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7926ace0",
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install names random_address\n",
    "\n",
    "import names\n",
    "import random\n",
    "from random_address import real_random_address\n",
    "\n",
    "# CREATE TEST SAMPLE\n",
    "def create_test_sample(n):\n",
    "\n",
    "    def random_SSN(n):\n",
    "        SSN_list = []\n",
    "        for i in range(n):\n",
    "            r = random.random()\n",
    "            random_SSN = '{:.15f}'.format(r)  # creates random number between 0 and 1 and suppress scientific notation https://stackoverflow.com/questions/658763/how-to-suppress-scientific-notation-when-printing-float-values\n",
    "            random_10_digits = random_SSN[-10:]\n",
    "            SSN = random_10_digits\n",
    "            SSN_list.append(int(SSN))\n",
    "        return SSN_list\n",
    "\n",
    "    def random_names(n):\n",
    "        name_list = []\n",
    "        for i in range(n):\n",
    "            name = names.get_full_name()\n",
    "            name_list.append(name)\n",
    "        return name_list\n",
    "\n",
    "    def random_real_address(n):\n",
    "        address_list = []\n",
    "        for i in range(n):\n",
    "            address = real_random_address()\n",
    "            try:\n",
    "                city = address['city']\n",
    "            except Exception as e:\n",
    "                address['city'] = \"Unknown\"\n",
    "            address = address['address1'] + \" \" + address['city'] + \" \" + address['postalCode']\n",
    "            address_list.append(address)\n",
    "        return address_list\n",
    "\n",
    "    def e_mail_generator(list_of_names):\n",
    "        e_mail_list = []\n",
    "        for i in list_of_names:\n",
    "            name = i\n",
    "            e_mail_list.append(name.split(\" \")[0] + \"@emailaddress.com\")\n",
    "        return e_mail_list\n",
    "\n",
    "    def random_phone_number(n):\n",
    "        phone_numbers_list = []\n",
    "        for i in range(n):\n",
    "            r = random.random()\n",
    "            random_time = '{:.15f}'.format(r)  # creates random number between 0 and 1\n",
    "            random_8_digits = random_time[-8:]\n",
    "            phone_number = \"06\" + random_8_digits\n",
    "            phone_numbers_list.append(str(phone_number))\n",
    "        return phone_numbers_list\n",
    "\n",
    "    def random_insuranceid(n):\n",
    "        insuranceid_list = []\n",
    "        for i in range(n):\n",
    "            r = random.random()\n",
    "            random_nr = '{:.15f}'.format(r)   # creates random number between 0 and 1\n",
    "            random_10_digits = random_nr[-10:]\n",
    "            insuranceid = random_10_digits\n",
    "            insuranceid_list.append(int(insuranceid))\n",
    "        return insuranceid_list\n",
    "\n",
    "    SSN_list = random_SSN(n)\n",
    "    name_list = random_names(n)\n",
    "    address_list = random_real_address(n)\n",
    "    e_mail_list = e_mail_generator(name_list)\n",
    "    phone_number_list = random_phone_number(n)\n",
    "    insuranceid_list = random_insuranceid(n)\n",
    "\n",
    "    # CHECK IF ALL LISTS ARE SAME LENGTH \n",
    "    for i in [SSN_list, name_list, address_list, e_mail_list, phone_number_list, insuranceid_list]:\n",
    "        if len(i) == n:\n",
    "            pass\n",
    "        else:\n",
    "            raise Exception(\"length lists not equal\")\n",
    "\n",
    "    # PRINT FIRST RECORDS OF TEST SAMPLE\n",
    "    # print(\"TEST SAMPLE COMPLETED, FIRST TWO RECORDS =\")\n",
    "    # for i in range(2):\n",
    "    #     print(SSN_list[i], name_list[i], address_list[i], e_mail_list[i], phone_number_list[i], insuranceid_list[i])\n",
    "\n",
    "    print(\"\")\n",
    "    print(\"STARTING WITH POPULATING DATABASE\")\n",
    "    for i in range(n):\n",
    "        insert_patient_record(\"Patients\", SSN_list[i], name_list[i], address_list[i], e_mail_list[i], phone_number_list[i], insuranceid_list[i])\n",
    "\n",
    "    print(\"\")\n",
    "    print(\"POPULATION COMPLETED\")\n",
    "    print(\"\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eac8d1b8",
   "metadata": {},
   "source": [
    "Now chose a sample size for your database of patients. Lets create 1000 patients over here. \n",
    "\n",
    "(For fun,  you could check out the speed of your computer for creating different patient populations: village, town, city, etc. You can use the Python inbuild time module for that. You could also checkout what the size in differences is of the files, or if you want to go hardcore, calculate the amount of harddisk size and time it would cost to include the world population in your EHR database.)\n",
    "\n",
    "Be carefull, the random name generator might make some unexpected names that interfere with the syntax of Python or SQL... You can try to fix this with the replace function in Python. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3f6ef8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "create_test_sample(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2ae0042",
   "metadata": {},
   "source": [
    "Try to display the database with a combination of Python and sql. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ac4bd24",
   "metadata": {},
   "outputs": [],
   "source": [
    "table_name=\"Patients\"\n",
    "query = \"\"\"SELECT * FROM \"\"\"+table_name\n",
    "cursor.execute(query)\n",
    "df = pd.DataFrame(cursor.fetchall())\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59f930e3",
   "metadata": {},
   "source": [
    "## Part 2: Inspecting the database"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "457f4691",
   "metadata": {},
   "source": [
    "We now have our database ready and can query the database. \n",
    "\n",
    "As you might knwo from reports you created in the past, when you work with 10.000s or millions of rows its hard to use excel for you data-analysis. Pandas can do this without letting your machine crash. \n",
    "\n",
    "Try to load the database into a pandas table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d20ad01",
   "metadata": {},
   "outputs": [],
   "source": [
    "query = \"\"\"SELECT * FROM \"\"\"+table_name\n",
    "cursor.execute(query)\n",
    "df = pd.DataFrame(cursor.fetchall())\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4d5084f",
   "metadata": {},
   "source": [
    "Try to find a patient using a new Python function that includes SQL."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5298b91",
   "metadata": {},
   "outputs": [],
   "source": [
    "# example solution\n",
    "def find_patient(table_name, name):\n",
    "    Str1 = name\n",
    "    query = \"\"\"SELECT * FROM \"\"\"+table_name+\"\"\" WHERE Name LIKE \"\"\" + Str1\n",
    "    # print(query)\n",
    "    # print(\"\")\n",
    "    cursor.execute(query)\n",
    "    row = cursor.fetchone()\n",
    "    print(row)\n",
    "    if row == None:\n",
    "        print(\"Patient not found\")\n",
    "        return\n",
    "    if row:\n",
    "        val = row[0]\n",
    "        print(\"Found patient with SSN number: \", val)\n",
    "\n",
    "    \n",
    "find_patient(\"Patients\", \"'John Smith'\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7aa8523",
   "metadata": {},
   "source": [
    "Get some descriptives of the table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5e3b0fb8",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(df.head(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bceec2b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(df.dtypes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65f8a090",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(df.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0e47d390",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(df.shape[0], df.shape[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5dc57ea1",
   "metadata": {},
   "source": [
    "## Part 3: Creating a conversation with the user"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c3d1f1e",
   "metadata": {},
   "source": [
    "We make a basic input prompt to ask for the input name and we search the second column of the dummy database for a matching name.\n",
    "\n",
    "If you're not sure, feel free to use the name \"William Delarosa\" (without the quotes), which is a patient in our database."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78c3b776",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get input from user\n",
    "name = input(\"Provide name: \\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bc0ae11",
   "metadata": {},
   "source": [
    "Create a for loop to find a patient based on the name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b1ac7a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "for index, row in df.iterrows():\n",
    "    if row[1] == name:\n",
    "        SSN = row[0]\n",
    "        name = row[1]\n",
    "        address = row[2]\n",
    "        email = row[3]\n",
    "\n",
    "print(SSN, name, address, email)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18478a21",
   "metadata": {},
   "source": [
    "## Part 4: Improving the search with Fuzzy Wuzzy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdab7f20",
   "metadata": {},
   "source": [
    "We now get to improving the clinical workflow. \n",
    "\n",
    "Often, in a multicultural area, you will find yourself unable or only partly able to write down a name accurately. At other times, names consist of two combined last names of which only one is used for verbally communicating information about a person. This impedes your working speed in the clinic and can also lead to errors. \n",
    "\n",
    "We can help the user with the Python Fuzzy Wuzzy package. This package leverages the Levenshtein distance to find the most similar string compared to the name that the user has given as an input. The Levenshtein distance is calculated by finding the shortest way to transform one string into another. It can be calculated with different protocols that you can find online. \n",
    "\n",
    "Try to find out which protocol is the best use case for your patient population.\n",
    "\n"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "6d5fe2a3",
   "metadata": {},
   "source": [
    "Performing some small experiments led to the following table in my case:\n",
    "![](attachment:image.png)\n",
    "\n",
    "Focusing on only a part of the string with the partial ratio protocol seems to eliminate the parts of names that can be confusing, such as second names or other additional words. So the partial ratio seems to be the most helpful.\n",
    "\n",
    "Install the fuzzy wuzzy package and try to incorporate a patient search function that utilizes the fuzzywuzze package. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4f22a6d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#install fuzzywuzzy\n",
    "%pip install fuzzywuzzy\n",
    "\n",
    "from fuzzywuzzy import fuzz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ca9cf62",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "name = \"Della Rosa\"\n",
    "# example solution\n",
    "for index, row in df.iterrows():\n",
    "    name_user_input = name\n",
    "    name_in_database = str(row[1])\n",
    "    partial_ratio = fuzz.partial_ratio(name_user_input.lower(), name_in_database.lower())\n",
    "    if partial_ratio > 80:\n",
    "        SSN = row[0]\n",
    "        name = row[1]\n",
    "        address = row[2]\n",
    "        email = row[3]\n",
    "        print(\"During search based the name,\", name_user_input, \" a match was found...\")\n",
    "        print(\"Partial string ratio =\", partial_ratio)\n",
    "        print(\"You can email this patient on:\", email)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "128e4e1e",
   "metadata": {},
   "source": [
    "## Next steps"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4802d298",
   "metadata": {},
   "source": [
    "- Try to make a database that includes birthdate and gender\n",
    "- Try to search based on only the last name instead of the fullname\n",
    "- Try to search on address"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce1e133e",
   "metadata": {},
   "source": [
    "Fill out the form below and we'll provide feedback on your code.\n",
    "\n",
    "**Any feedback on the exercise? Any questions? Want feedback on your code? Please fill out the form [here](https://docs.google.com/forms/d/e/1FAIpQLSdoOjVom8YKf11LxJ_bWN40afFMsWcoJ-xOrKhMbfBzgxTS9A/viewform).**"
   ]
  }
 ],
 "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.10.8"
  },
  "vscode": {
   "interpreter": {
    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}