database_query_timer.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Database Query Timer\n",
    "\n",
    "Kenneth Burchfiel\n",
    "\n",
    "Released under the MIT license\n",
    "\n",
    "In this Jupyter notebook, I will test out the speed of 6 database types (AWS, GCP, Azure, Heroku, Snowflake, and Databricks) using a variety of conditions, then plot the results.\n",
    "\n",
    "## Disclaimer: \n",
    "**This notebook is by no means meant as a definitive assessment of the speeds of each database provider. My results were undoubtedly influenced by my configuration settings for each database, and different configuration settings would likely result in different outcomes. In addition, the tests I used may not match real-world usage scenarios. **Do not** use these results to make decisions about which database provider to use.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "start_time = time.time() # Allows the program's runtime to be measured\n",
    "import pandas as pd\n",
    "import sqlalchemy\n",
    "from pyairtable import Api, Base, Table # from https://pyairtable.readthedocs.io/en/latest/api.html\n",
    "import matplotlib.pyplot as plt\n",
    "from snowflake.connector.pandas_tools import pd_writer\n",
    "import pyodbc\n",
    "import speedtest # https://github.com/sivel/speedtest-cli/wiki\n",
    "import mpld3\n",
    "from mpld3 import plugins\n",
    "from mpld3 import fig_to_html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following cell contains configuration variables that determine which trials are run and under what conditions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "full_import_test = False\n",
    "import_test_trials_count = 5\n",
    "\n",
    "simple_query_test = False\n",
    "# Simple query test parameters are set prior to each instance of the test\n",
    "\n",
    "complex_query_test = False\n",
    "complex_query_test_query_count = 50\n",
    "complex_query_test_trials_count = 4\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, I'll extract my database passwords and then connect to each database using those passwords."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(r'C:\\Users\\kburc\\D1V1\\Documents\\!Dell64docs\\Programming\\py\\kjb3_programs\\key_paths\\path_to_keys_folder.txt') as file:\n",
    "    path_to_keys_folder = file.readline() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with open(path_to_keys_folder+'\\\\kb_ind_study_aws_db_pw.txt') as file:\n",
    "#     aws_pw = file.readline()\n",
    "\n",
    "with open(path_to_keys_folder+'\\\\kb-cheaper-aws-db_pw.txt') as file:\n",
    "    aws_pw = file.readline()\n",
    "\n",
    "with open(path_to_keys_folder+'\\\\kb_ind_study_gcp_db_pw.txt') as file:\n",
    "    gcp_pw = file.readline()\n",
    "\n",
    "with open(path_to_keys_folder+'\\\\kb_ind_study_azure_db_pw.txt') as file:\n",
    "    azure_pw = file.readline()\n",
    "\n",
    "with open(path_to_keys_folder+'\\\\snowflake_pw.txt') as file:\n",
    "    snowflake_pw = file.readline()\n",
    "\n",
    "with open(path_to_keys_folder+'\\\\airtable_api_key.txt') as file:\n",
    "    airtable_key = file.readline()\n",
    " \n",
    "with open(path_to_keys_folder+'\\\\heroku_db_pw.txt') as file:\n",
    "    heroku_pw = file.readline()\n",
    "\n",
    "with open(path_to_keys_folder+'\\\\databricks_paid_account_token.txt') as file:\n",
    "    databricks_paid_account_token = file.readline()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:red\"> **Note:** Due to its size, I could not upload sqlite_database.db, the SQLite database that this script connects to, directly to GitHub. You can instead find it via Google Drive at the following link:</span> \n",
    "\n",
    "https://drive.google.com/file/d/1THyBZYXXT4le6zQz2SBhQlIjMk2MjhYz/view?usp=sharing\n",
    "\n",
    "Once you have downloaded it, copy it into the data folder of your copy of the repository. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "sqlalchemy_sqlite_engine = sqlalchemy.create_engine('sqlite:///data\\\\sqlite_database.db')  # Based on https://docs.sqlalchemy.org/en/13/dialects/sqlite.html#connect-strings\n",
    "# This database was created within sqlite_database_builder.ipynb.\n",
    "\n",
    "aws_sqlalchemy_psql_engine = sqlalchemy.create_engine('postgresql://kburchfiel:'+str(aws_pw)+'@kb-cheaper-aws-db.cquawwv3qwid.us-east-1.rds.amazonaws.com:5432/postgres')\n",
    "\n",
    "# Based on https://stackoverflow.com/a/58208015/13097194\n",
    "# That answer can also be derived from:\n",
    "# 1. https://docs.sqlalchemy.org/en/14/core/engines.html\n",
    "# And: 2. https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_sql.html\n",
    "\n",
    "gcp_sqlalchemy_psql_engine = sqlalchemy.create_engine(\n",
    "    # Equivalent URL:\n",
    "    # postgresql+pg8000://<db_user>:<db_pass>@<db_host>:<db_port>/<db_name>\n",
    "    sqlalchemy.engine.url.URL.create(\n",
    "        drivername=\"postgresql\",\n",
    "        username='kb_gcp_db',  # e.g. \"my-database-user\"\n",
    "        password=gcp_pw,  # e.g. \"my-database-password\"\n",
    "        host='34.135.185.218',  # e.g. \"127.0.0.1\"\n",
    "        port=5432,  # e.g. 5432\n",
    "        database='postgres'  # e.g. \"my-database-name\"\n",
    "    )\n",
    ")\n",
    "\n",
    "azure_sqlalchemy_psql_engine = sqlalchemy.create_engine('postgresql://kbindstudy:'+str(azure_pw)+'@kb-ind-study-azure-server.postgres.database.azure.com/postgres?sslmode=require')\n",
    "# This string is based both on the Amazon connection string and the 'PostgreSQL connection URL' shown on the 'Connection strings' page within the Azure Database site.\n",
    "\n",
    "heroku_sqlalchemy_psql_engine = sqlalchemy.create_engine('postgresql://wtgddsmdmsipoo:'+str(heroku_pw)+'@ec2-23-23-199-57.compute-1.amazonaws.com:5432/ddc9jvn58br3tc')\n",
    "\n",
    "snowflake_engine = sqlalchemy.create_engine('snowflake://KBURCHFIEL:'+str(snowflake_pw)+'@RV85777.east-us-2.azure/KB_SNOWFLAKE_DB/PUBLIC')\n",
    "\n",
    "databricks_pyodbc_connection = pyodbc.connect(\"DSN=Databricks_Cluster\", autocommit=True)\n",
    "databricks_pyodbc_cursor = databricks_pyodbc_connection.cursor()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now I'll connect to my local SQLite database to retrieve a list of tables in that database. This list will correspond with the tables in the 6 online databases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['flights', 'photos', 'steps', 'music']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqlite_table_query = sqlalchemy_sqlite_engine.execute(\"Select name from sqlite_schema where type = 'table'\")\n",
    "# This method for extracting all tables comes from https://www.kite.com/python/answers/how-to-list-tables-using-sqlite3-in-python\n",
    "sqlite_table_tuple_list = sqlite_table_query.fetchall()\n",
    "sqlite_table_list = [query[0] for query in sqlite_table_tuple_list] # List comprehension extracts only the first part of each tuple stored in table_list.\n",
    "sqlite_table_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 1: Full database import test\n",
    "I will first measure how long it takes to download the entire contents of the flights, music, steps, and photos tables stored in the 6 online databases into DataFrames."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following function imports all tables from a given database into DataFrames and times how long it takes to do so."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_from_db(table_list, con_for_import):\n",
    "    print(\"Importing tables from database using the following connection:\",con_for_import)\n",
    "    import_start_time = time.time() \n",
    "    imported_table_df_list = [] \n",
    "    for table in table_list:\n",
    "        imported_df = pd.read_sql(\"select * from \"+table+\";\", con=con_for_import)\n",
    "        if imported_df.columns[0] == 'index': # If the table already has an index\n",
    "            # column, set that column as the index.\n",
    "            imported_df.set_index('index',inplace=True)\n",
    "        else: # Otherwise, if the index column is unnamed, give it the name 'index.'\n",
    "            imported_df.index.name = 'index'\n",
    "        imported_table_df_list.append(imported_df)\n",
    "    import_end_time = time.time()\n",
    "    import_run_time = import_end_time - import_start_time\n",
    "    import_run_minutes = import_run_time // 60\n",
    "    import_run_seconds = import_run_time % 60\n",
    "    print(\"Completed import at\",time.ctime(import_end_time),\"(local time)\")\n",
    "    print(\"Total run time:\",'{:.2f}'.format(import_run_time),\"second(s) (\"+str(import_run_minutes),\"minute(s) and\",'{:.2f}'.format(import_run_seconds),\"second(s))\")\n",
    "    return (imported_table_df_list, import_run_time) \n",
    "    # These components could also be returned as a list or class.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next function, time_database_imports, applies read_from_db to each database and outputs a dictionary containing the times it took to download each set of tables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def time_database_imports(trials_count):\n",
    "    import_times_dict_list = []\n",
    "    trials_count # Can be increased to create average upload times\n",
    "    for i in range(1, trials_count+1):\n",
    "        print(\"\\nTrial\",i)\n",
    "        print(\"\\n\\nAWS Import:\")\n",
    "        aws_imported_table_list, aws_run_time = read_from_db(sqlite_table_list, con_for_import = aws_sqlalchemy_psql_engine)\n",
    "        import_times_dict_list.append({\"Service\":\"AWS\", \"Time\": aws_run_time,\"Trial\":i})\n",
    "        print(\"\\n\\nGCP Import:\")\n",
    "        gcp_imported_table_list, gcp_run_time = read_from_db(sqlite_table_list, con_for_import = gcp_sqlalchemy_psql_engine)\n",
    "        import_times_dict_list.append({\"Service\":\"GCP\",\"Time\":gcp_run_time,\"Trial\":i})\n",
    "        print(\"\\n\\nAzure Import:\")\n",
    "        azure_imported_table_list, azure_run_time = read_from_db(sqlite_table_list, con_for_import = azure_sqlalchemy_psql_engine)\n",
    "        import_times_dict_list.append({\"Service\":'Azure', \"Time\":azure_run_time,\"Trial\":i})\n",
    "        print(\"\\n\\nHeroku Import:\")\n",
    "        heroku_imported_table_list, heroku_run_time = read_from_db(sqlite_table_list, con_for_import = heroku_sqlalchemy_psql_engine)\n",
    "        import_times_dict_list.append({\"Service\":'Heroku', \"Time\":heroku_run_time,\"Trial\":i})\n",
    "        print(\"\\n\\nSnowflake Import:\")\n",
    "        snowflake_imported_table_list, snowflake_run_time = read_from_db(sqlite_table_list, con_for_import = snowflake_engine)\n",
    "        import_times_dict_list.append({\"Service\":'Snowflake', \"Time\":snowflake_run_time,\"Trial\":i})\n",
    "        print(\"\\n\\nDatabricks Import:\")\n",
    "        databricks_imported_table_list, databricks_run_time = read_from_db(sqlite_table_list, con_for_import = databricks_pyodbc_connection)\n",
    "        import_times_dict_list.append({\"Service\":'Databricks', \"Time\":databricks_run_time,\"Trial\":i})\n",
    "\n",
    "    df_import_times = pd.DataFrame(import_times_dict_list)\n",
    "    df_import_times\n",
    "    return df_import_times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since internet connection times might impact my download/query times, I created a function that runs an internet speed test (from speedtest.com). Running this function before and after each set of database tests helps me identify changes in internet speed that might influence the results of the tests."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_speedtest():\n",
    "    # Code is based on https://github.com/sivel/speedtest-cli/wiki\n",
    "    servers = []\n",
    "    threads = None\n",
    "    s = speedtest.Speedtest()\n",
    "    s.get_servers(servers)\n",
    "    s.get_best_server()\n",
    "    s.download(threads=threads)\n",
    "    s.upload(threads=threads)\n",
    "    s.results.share()\n",
    "    results_dict = s.results.dict()\n",
    "    print(\"Download speed (in Mbps):\", round(results_dict['download']/1000000,2))\n",
    "    print(\"Upload speed (in Mbps):\", round(results_dict['upload']/1000000,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code block calculates the time required to download the flights, steps, photos, and music tables from each database into DataFrames. Setting trials_count to a number greater than 1 allows an average download speed to be calculated from multiple tests."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "if full_import_test == True:\n",
    "    print(\"Pre-test speedtest:\")\n",
    "    run_speedtest()\n",
    "    df_import_times = time_database_imports(trials_count = import_test_trials_count)\n",
    "    print(\"Post-test speedtest:\")\n",
    "    run_speedtest()\n",
    "    df_import_times.to_csv('metrics\\\\full_import_results.csv') # Saving the results to a\n",
    "    # .csv file means the data can be analyzed in the future without having \n",
    "    # to re-run the tests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mean import times for each database are shown below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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>Service</th>\n",
       "      <th>Import_Time</th>\n",
       "      <th>Import_Time_Rank</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Snowflake</td>\n",
       "      <td>17.480364</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Azure</td>\n",
       "      <td>40.748104</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>AWS</td>\n",
       "      <td>41.006784</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>GCP</td>\n",
       "      <td>41.315156</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Heroku</td>\n",
       "      <td>54.513024</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Databricks</td>\n",
       "      <td>65.536882</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Service  Import_Time  Import_Time_Rank\n",
       "0   Snowflake    17.480364                 1\n",
       "1       Azure    40.748104                 2\n",
       "2         AWS    41.006784                 3\n",
       "3         GCP    41.315156                 4\n",
       "4      Heroku    54.513024                 5\n",
       "5  Databricks    65.536882                 6"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_import_times = pd.read_csv('metrics\\\\full_import_results.csv') # Check headers\n",
    "mean_import_times = df_import_times[['Service', 'Time']].copy().groupby('Service').mean()\n",
    "mean_import_times.rename(columns={'Time':'Import_Time'},inplace=True)\n",
    "mean_import_times.sort_values('Import_Time',inplace=True)\n",
    "mean_import_times.reset_index(inplace=True)\n",
    "mean_import_times['Import_Time_Rank'] = mean_import_times.index+1 # Converts the index (which starts with 0) into a ranking that starts with 1\n",
    "mean_import_times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The plot_results() function below plots the contents of DataFrames formatted like df_import_times as a series of lines, each of which represents the download or query times for a particular database. plot_results() saves each chart as (1) a static .png image and (2) an interactive .html file that can be viewed in a web browser. The .html file displays each query/download time when the user hovers over a particular marker on the graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_results(df, title, save_string):\n",
    "    fig, axes = plt.subplots()\n",
    "    fig.set_facecolor('white')\n",
    "    line_list = []\n",
    "    line_list.append(axes.plot(df.query(\"Service == 'AWS'\")['Time'], label='AWS', marker='o'))\n",
    "    plugins.connect(fig, plugins.PointLabelTooltip(line_list[0][0], labels = list(df.query(\"Service == 'AWS'\")['Time'].round(3)))) # A second [0] is needed for the tooltips to show! See https://nbviewer.org/gist/aflaxman/f7d6fda45a69223c4200 and https://mpld3.github.io/modules/API.html. Note that they include a [0] even though there's just one line in their examples.\n",
    "    line_list.append(axes.plot(df.query(\"Service == 'GCP'\")['Time'], label = 'GCP', marker='o'))\n",
    "    plugins.connect(fig, plugins.PointLabelTooltip(line_list[1][0], labels = list(df.query(\"Service == 'GCP'\")['Time'].round(3))))\n",
    "    line_list.append(axes.plot(df.query(\"Service == 'Azure'\")['Time'], label = 'Azure', marker='o'))\n",
    "    plugins.connect(fig, plugins.PointLabelTooltip(line_list[2][0], labels = list(df.query(\"Service == 'Azure'\")['Time'].round(3))))\n",
    "    line_list.append(axes.plot(df.query(\"Service == 'Heroku'\")['Time'], label = 'Heroku', marker='o'))\n",
    "    plugins.connect(fig, plugins.PointLabelTooltip(line_list[3][0], labels = list(df.query(\"Service == 'Heroku'\")['Time'].round(3))))\n",
    "    line_list.append(axes.plot(df.query(\"Service == 'Snowflake'\")['Time'], label = 'Snowflake', marker='o'))\n",
    "    plugins.connect(fig, plugins.PointLabelTooltip(line_list[4][0], labels = list(df.query(\"Service == 'Snowflake'\")['Time'].round(3))))\n",
    "    line_list.append(axes.plot(df.query(\"Service == 'Databricks'\")['Time'], label = 'Databricks', marker='o', color = 'black')) # The default 6th color is hard to differentiate from another color, at least when I block blue light from my monitor\n",
    "    plugins.connect(fig, plugins.PointLabelTooltip(line_list[5][0], labels = list(df.query(\"Service == 'Databricks'\")['Time'].round(3))))\n",
    "    plt.title(title) # The wrap=True parameter doesn't appear to affect .html charts; therefore, I wrapped text for those titles by inserting an explicit newline character (\\n) where necessary.\n",
    "    plt.ylabel(\"Time (in seconds)\")\n",
    "    plt.xlabel(\"Trial number\")\n",
    "    plt.legend()\n",
    "    print(\"Line_list[0]:\",line_list[0])\n",
    "    mpld3.save_html(fig, 'metrics\\\\'+save_string+'.html')\n",
    "    plt.savefig('metrics\\\\'+save_string+'.png',dpi=400)\n",
    "    # plt.show()    \n",
    "    return fig\n",
    "\n",
    "    \n",
    "# for i in range(len(fig_line_list)):\n",
    "#         plugins.connect(test_fig, plugins.LineLabelTooltip(fig_line_list[0], label = 'test'))\n",
    "#mpld3.save_html(test_fig, 'new_output_test.html')\n",
    "# mpld3.display()\n",
    "# Once you get this to work, integrate it with the rest of the plot code, then save the html file within that code (based on the same title that you're giving the other charts--just with 'html' instead)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Line_list[0]: [<matplotlib.lines.Line2D object at 0x000001759F47B8E0>]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import_plot = plot_results(df_import_times, title = \"Time required to import 4 tables from each database over \"+str(import_test_trials_count)+\" trials\", save_string = 'full_import_time')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above chart shows that Snowflake's import times were consistently the lowest among all 5 providers, whereas Databricks imports tended to take the longest. AWS, GCP, and Azure all had very similar import times. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 2: Simple query tests\n",
    "\n",
    "The next two tests evaluate how long it takes to execute a simple query within each database. \n",
    "\n",
    "The query_test function applies a particular query to a database and times how long it takes for that query to be stored (in the query_result variable). Setting query_count above 1 allows the query to be applied multiple times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def query_test(query, query_count, connection, offset = False):\n",
    "    query_start_time = time.time() \n",
    "    if offset == True: # This condition causes a different row to be returned each time. For this to work, query_count has to be lower than the length of the results of the query.\n",
    "        for i in range(query_count):\n",
    "            query_result = connection.execute(query+\" limit 1 offset \"+str(i))\n",
    "    else:\n",
    "        for i in range(query_count):\n",
    "            query_result = connection.execute(query)\n",
    "    query_end_time = time.time()\n",
    "    query_run_time = query_end_time - query_start_time\n",
    "    return query_run_time\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The database_query_test function applies query_test to each database and stores the times needed to execute the function into a DataFrame. Its trials_count parameter determines how many times the function will apply query_count to each database."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def database_query_test(query, query_count, trials_count, offset = False, verbose = False):\n",
    "    query_times_dict_list = []\n",
    "    for i in range(1, trials_count+1):\n",
    "        print(\"\\nTrial\",i)\n",
    "        print(\"\\nRunning AWS Query\")\n",
    "        query_start_time = time.time()\n",
    "        aws_run_time = query_test(query, query_count, connection = aws_sqlalchemy_psql_engine, offset = offset)\n",
    "        query_times_dict_list.append({\"Service\":\"AWS\", \"Time\": aws_run_time,\"Trial\":i})\n",
    "        query_end_time = time.time()\n",
    "        query_length = query_end_time - query_start_time\n",
    "        if verbose == True:\n",
    "            print(\"Query time (in seconds):\",query_length)\n",
    "            print(\"Average time per query:\",query_length/query_count)\n",
    "\n",
    "        print(\"\\nRunning GCP Query\")\n",
    "        query_start_time = time.time()\n",
    "        gcp_run_time = query_test(query, query_count, connection = gcp_sqlalchemy_psql_engine, offset = offset)\n",
    "        query_times_dict_list.append({\"Service\":\"GCP\", \"Time\": gcp_run_time,\"Trial\":i})\n",
    "        query_end_time = time.time()\n",
    "        query_length = query_end_time - query_start_time\n",
    "        if verbose == True:\n",
    "            print(\"Query time (in seconds):\",query_length)\n",
    "            print(\"Average time per query:\",query_length/query_count)\n",
    "        \n",
    "        print(\"\\nRunning Azure Query\")\n",
    "        query_start_time = time.time()\n",
    "        azure_run_time = query_test(query, query_count, connection = azure_sqlalchemy_psql_engine, offset = offset)\n",
    "        query_times_dict_list.append({\"Service\":'Azure', \"Time\":azure_run_time,\"Trial\":i})\n",
    "        query_end_time = time.time()\n",
    "        query_length = query_end_time - query_start_time\n",
    "        if verbose == True:\n",
    "            print(\"Query time (in seconds):\",query_length)\n",
    "            print(\"Average time per query:\",query_length/query_count)\n",
    "\n",
    "        print(\"\\nRunning Heroku Query\")\n",
    "        query_start_time = time.time()\n",
    "        heroku_run_time = query_test(query, query_count, connection = heroku_sqlalchemy_psql_engine, offset = offset)\n",
    "        query_times_dict_list.append({\"Service\":'Heroku', \"Time\":heroku_run_time,\"Trial\":i})\n",
    "        query_end_time = time.time()\n",
    "        query_length = query_end_time - query_start_time\n",
    "        if verbose == True:\n",
    "            print(\"Query time (in seconds):\",query_length)\n",
    "            print(\"Average time per query:\",query_length/query_count)\n",
    "        \n",
    "        print(\"\\nRunning Snowflake Query\")\n",
    "        query_start_time = time.time()\n",
    "        snowflake_run_time = query_test(query, query_count, connection = snowflake_engine, offset = offset)\n",
    "        query_times_dict_list.append({\"Service\":'Snowflake', \"Time\":snowflake_run_time,\"Trial\":i})\n",
    "        query_end_time = time.time()\n",
    "        query_length = query_end_time - query_start_time\n",
    "        if verbose == True:\n",
    "            print(\"Query time (in seconds):\",query_length)\n",
    "            print(\"Average time per query:\",query_length/query_count)\n",
    "        \n",
    "        print(\"\\nRunning Databricks Query\")\n",
    "        query_start_time = time.time()\n",
    "        databricks_run_time = query_test(query, query_count, connection = databricks_pyodbc_connection, offset = offset)\n",
    "        query_times_dict_list.append({\"Service\":'Databricks', \"Time\":databricks_run_time,\"Trial\":i})\n",
    "        query_end_time = time.time()\n",
    "        query_length = query_end_time - query_start_time\n",
    "        if verbose == True:\n",
    "            print(\"Query time (in seconds):\",query_length)\n",
    "            print(\"Average time per query:\",query_length/query_count)\n",
    "\n",
    "    df_simple_query_results = pd.DataFrame(query_times_dict_list)    \n",
    "    return df_simple_query_results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first simple query test will apply a basic query to each database only once, then repeat this process 20 times in order to obtain an average query length for each database."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "simple_query = \"Select * from photos limit 1\"\n",
    "simple_query_count = 1\n",
    "simple_query_test_trials_count = 20\n",
    "\n",
    "if simple_query_test == True:\n",
    "    print(\"Pre-test speedtest:\")\n",
    "    run_speedtest()\n",
    "    simple_query_results = database_query_test(query = simple_query, query_count = simple_query_count, trials_count = simple_query_test_trials_count, offset = False)\n",
    "    print(\"Post-test speedtest:\")\n",
    "    run_speedtest()\n",
    "    simple_query_results.to_csv('metrics\\\\simple_query_test_1x.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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>Service</th>\n",
       "      <th>Simple_Query_1x_Time</th>\n",
       "      <th>Simple_Query_1x_Rank</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Heroku</td>\n",
       "      <td>0.056835</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>AWS</td>\n",
       "      <td>0.060395</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Azure</td>\n",
       "      <td>0.066731</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>GCP</td>\n",
       "      <td>0.123177</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Snowflake</td>\n",
       "      <td>0.139276</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Databricks</td>\n",
       "      <td>0.821429</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Service  Simple_Query_1x_Time  Simple_Query_1x_Rank\n",
       "0      Heroku              0.056835                     1\n",
       "1         AWS              0.060395                     2\n",
       "2       Azure              0.066731                     3\n",
       "3         GCP              0.123177                     4\n",
       "4   Snowflake              0.139276                     5\n",
       "5  Databricks              0.821429                     6"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simple_query_results_1x = pd.read_csv('metrics\\\\simple_query_test_1x.csv')\n",
    "mean_simple_query_results_1x = simple_query_results_1x[['Service', 'Time']].copy().groupby('Service').mean().sort_values('Time')\n",
    "mean_simple_query_results_1x.rename(columns={'Time':'Simple_Query_1x_Time'},inplace=True)\n",
    "mean_simple_query_results_1x.sort_values('Simple_Query_1x_Time',inplace=True)\n",
    "mean_simple_query_results_1x.reset_index(inplace=True)\n",
    "mean_simple_query_results_1x['Simple_Query_1x_Rank'] = mean_simple_query_results_1x.index+1 # Converts the index (which starts with 0) into a ranking that starts with 1\n",
    "mean_simple_query_results_1x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This table, sorted by execution time, shows the mean amount of time required to (1) execute the simple query on each database and (2) assign the result to a variable. Databricks queries took significantly longer than did queries of the other 5 databases, whereas Heroku had the fastest query speeds. GCP and Snowflake were slower than AWS and Azure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Line_list[0]: [<matplotlib.lines.Line2D object at 0x000001759F5DE4F0>]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "simple_query_1x_plot = plot_results(df = simple_query_results_1x, title = 'Time required to execute one simple query over '+str(simple_query_test_trials_count)+' trials', save_string = 'simple_query_results_1x')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above two plots (which are identical) show that, for every database, the first of the 20 queries took the longest."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Longer simple query test\n",
    "\n",
    "Now that I have calculated the length of time required for one query, I will determine the length of time needed to calculate that same query 1000 times in a row. The trials count was reduced from 20 to 2 to save time; even so, the following code block still took about 38 minutes to run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "simple_query_count = 1000\n",
    "simple_query_test_trials_count = 2 \n",
    "\n",
    "if simple_query_test == True:\n",
    "    print(\"Pre-test speedtest:\")\n",
    "    run_speedtest()\n",
    "    simple_query_results = database_query_test(query = simple_query, query_count = simple_query_count, trials_count = simple_query_test_trials_count, offset = False, verbose = True)\n",
    "    print(\"Post-test speedtest:\")\n",
    "    run_speedtest()\n",
    "    simple_query_results.to_csv('metrics\\\\simple_query_test_1000x.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "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>Service</th>\n",
       "      <th>Simple_Query_1000x_Time</th>\n",
       "      <th>Simple_Query_1000x_Time_Per_Query</th>\n",
       "      <th>Simple_Query_1000x_Rank</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>AWS</td>\n",
       "      <td>33.991590</td>\n",
       "      <td>0.033992</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Heroku</td>\n",
       "      <td>35.360053</td>\n",
       "      <td>0.035360</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Azure</td>\n",
       "      <td>37.267689</td>\n",
       "      <td>0.037268</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>GCP</td>\n",
       "      <td>100.523524</td>\n",
       "      <td>0.100524</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Snowflake</td>\n",
       "      <td>181.722105</td>\n",
       "      <td>0.181722</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Databricks</td>\n",
       "      <td>757.514256</td>\n",
       "      <td>0.757514</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Service  Simple_Query_1000x_Time  Simple_Query_1000x_Time_Per_Query  \\\n",
       "0         AWS                33.991590                           0.033992   \n",
       "1      Heroku                35.360053                           0.035360   \n",
       "2       Azure                37.267689                           0.037268   \n",
       "3         GCP               100.523524                           0.100524   \n",
       "4   Snowflake               181.722105                           0.181722   \n",
       "5  Databricks               757.514256                           0.757514   \n",
       "\n",
       "   Simple_Query_1000x_Rank  \n",
       "0                        1  \n",
       "1                        2  \n",
       "2                        3  \n",
       "3                        4  \n",
       "4                        5  \n",
       "5                        6  "
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simple_query_results_1000x = pd.read_csv('metrics\\\\simple_query_test_1000x.csv')\n",
    "mean_simple_query_results_1000x = simple_query_results_1000x[['Service', 'Time']].copy().groupby('Service').mean().sort_values('Time')\n",
    "mean_simple_query_results_1000x.rename(columns={'Time':'Simple_Query_1000x_Time'},inplace=True)\n",
    "mean_simple_query_results_1000x['Simple_Query_1000x_Time_Per_Query'] = mean_simple_query_results_1000x['Simple_Query_1000x_Time'] / simple_query_count\n",
    "mean_simple_query_results_1000x.sort_values('Simple_Query_1000x_Time',inplace=True)\n",
    "mean_simple_query_results_1000x.reset_index(inplace=True)\n",
    "mean_simple_query_results_1000x['Simple_Query_1000x_Rank'] = mean_simple_query_results_1000x.index+1 # Converts the index (which starts with 0) into a ranking that starts with 1\n",
    "mean_simple_query_results_1000x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above DataFrame shows the average amount of time needed to execute 1000 simple queries on each database. The ranking of the providers was similar to the single-query ranking, except that AWS's average time was now faster than Heroku. Databricks remained consistently slower than the other 5 databases, and GCP and Snowflake were considerably slower than AWS, Heroku, and Azure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Line_list[0]: [<matplotlib.lines.Line2D object at 0x00000175A06635B0>]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "simple_query_1000x_plot = plot_results(df = simple_query_results_1000x, title = 'Time required to execute '+str(simple_query_count)+' simple queries over '+str(simple_query_test_trials_count)+' trials', save_string = 'simple_query_results_1000x')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The query times remained relatively similar across the two trials, which is not surprising given that each time shown is the result of 1,000 queries (rather than just one as in the earlier simple query test)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Complex query test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Having examined the times needed to process a very simple query, I will now execute a more complex query. This query determines which airports have the highest average number of passengers per Delta flight. It involves aggregate functions along with WHERE, GROUP BY, and ORDER BY statements, and is applied to a table with over 29 million cells.\n",
    "Here is an example of the query applied to the flights table within my local sqlite database:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "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>sum(\"PASSENGERS\")</th>\n",
       "      <th>sum(\"DEPARTURES_PERFORMED\")</th>\n",
       "      <th>passengers_per_departure</th>\n",
       "      <th>destination_iata_code</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>282.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>282.000000</td>\n",
       "      <td>GOA</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>550.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>275.000000</td>\n",
       "      <td>MVD</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>540.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>270.000000</td>\n",
       "      <td>YHZ</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>96456.0</td>\n",
       "      <td>360.0</td>\n",
       "      <td>267.933333</td>\n",
       "      <td>TLV</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>92048.0</td>\n",
       "      <td>357.0</td>\n",
       "      <td>257.837535</td>\n",
       "      <td>JNB</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>257.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>257.000000</td>\n",
       "      <td>LGW</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>241441.0</td>\n",
       "      <td>961.0</td>\n",
       "      <td>251.239334</td>\n",
       "      <td>FCO</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>112596.0</td>\n",
       "      <td>469.0</td>\n",
       "      <td>240.076759</td>\n",
       "      <td>MXP</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>85956.0</td>\n",
       "      <td>359.0</td>\n",
       "      <td>239.431755</td>\n",
       "      <td>SYD</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>1426354.0</td>\n",
       "      <td>6009.0</td>\n",
       "      <td>237.369612</td>\n",
       "      <td>AMS</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>125616.0</td>\n",
       "      <td>533.0</td>\n",
       "      <td>235.677298</td>\n",
       "      <td>BCN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>171485.0</td>\n",
       "      <td>732.0</td>\n",
       "      <td>234.269126</td>\n",
       "      <td>HND</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>234.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>234.000000</td>\n",
       "      <td>YQX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>83992.0</td>\n",
       "      <td>363.0</td>\n",
       "      <td>231.382920</td>\n",
       "      <td>EZE</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>454.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>227.000000</td>\n",
       "      <td>VCP</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>224.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>224.000000</td>\n",
       "      <td>MDZ</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>150358.0</td>\n",
       "      <td>683.0</td>\n",
       "      <td>220.143485</td>\n",
       "      <td>PEK</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>74878.0</td>\n",
       "      <td>345.0</td>\n",
       "      <td>217.037681</td>\n",
       "      <td>VCE</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>430895.0</td>\n",
       "      <td>2004.0</td>\n",
       "      <td>215.017465</td>\n",
       "      <td>NRT</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>78187.0</td>\n",
       "      <td>365.0</td>\n",
       "      <td>214.210959</td>\n",
       "      <td>LIM</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>259142.0</td>\n",
       "      <td>1216.0</td>\n",
       "      <td>213.110197</td>\n",
       "      <td>GRU</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>130728.0</td>\n",
       "      <td>617.0</td>\n",
       "      <td>211.876823</td>\n",
       "      <td>MAD</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>152780.0</td>\n",
       "      <td>724.0</td>\n",
       "      <td>211.022099</td>\n",
       "      <td>DUB</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>50251.0</td>\n",
       "      <td>240.0</td>\n",
       "      <td>209.379167</td>\n",
       "      <td>HKG</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>869353.0</td>\n",
       "      <td>4173.0</td>\n",
       "      <td>208.328061</td>\n",
       "      <td>CDG</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>903740.0</td>\n",
       "      <td>4393.0</td>\n",
       "      <td>205.722741</td>\n",
       "      <td>HNL</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26</th>\n",
       "      <td>33532.0</td>\n",
       "      <td>163.0</td>\n",
       "      <td>205.717791</td>\n",
       "      <td>PRG</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>27</th>\n",
       "      <td>204.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>204.000000</td>\n",
       "      <td>GYE</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>66306.0</td>\n",
       "      <td>327.0</td>\n",
       "      <td>202.770642</td>\n",
       "      <td>STR</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>29</th>\n",
       "      <td>34958.0</td>\n",
       "      <td>173.0</td>\n",
       "      <td>202.069364</td>\n",
       "      <td>TXL</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    sum(\"PASSENGERS\")  sum(\"DEPARTURES_PERFORMED\")  passengers_per_departure  \\\n",
       "0               282.0                          1.0                282.000000   \n",
       "1               550.0                          2.0                275.000000   \n",
       "2               540.0                          2.0                270.000000   \n",
       "3             96456.0                        360.0                267.933333   \n",
       "4             92048.0                        357.0                257.837535   \n",
       "5               257.0                          1.0                257.000000   \n",
       "6            241441.0                        961.0                251.239334   \n",
       "7            112596.0                        469.0                240.076759   \n",
       "8             85956.0                        359.0                239.431755   \n",
       "9           1426354.0                       6009.0                237.369612   \n",
       "10           125616.0                        533.0                235.677298   \n",
       "11           171485.0                        732.0                234.269126   \n",
       "12              234.0                          1.0                234.000000   \n",
       "13            83992.0                        363.0                231.382920   \n",
       "14              454.0                          2.0                227.000000   \n",
       "15              224.0                          1.0                224.000000   \n",
       "16           150358.0                        683.0                220.143485   \n",
       "17            74878.0                        345.0                217.037681   \n",
       "18           430895.0                       2004.0                215.017465   \n",
       "19            78187.0                        365.0                214.210959   \n",
       "20           259142.0                       1216.0                213.110197   \n",
       "21           130728.0                        617.0                211.876823   \n",
       "22           152780.0                        724.0                211.022099   \n",
       "23            50251.0                        240.0                209.379167   \n",
       "24           869353.0                       4173.0                208.328061   \n",
       "25           903740.0                       4393.0                205.722741   \n",
       "26            33532.0                        163.0                205.717791   \n",
       "27              204.0                          1.0                204.000000   \n",
       "28            66306.0                        327.0                202.770642   \n",
       "29            34958.0                        173.0                202.069364   \n",
       "\n",
       "   destination_iata_code  \n",
       "0                    GOA  \n",
       "1                    MVD  \n",
       "2                    YHZ  \n",
       "3                    TLV  \n",
       "4                    JNB  \n",
       "5                    LGW  \n",
       "6                    FCO  \n",
       "7                    MXP  \n",
       "8                    SYD  \n",
       "9                    AMS  \n",
       "10                   BCN  \n",
       "11                   HND  \n",
       "12                   YQX  \n",
       "13                   EZE  \n",
       "14                   VCP  \n",
       "15                   MDZ  \n",
       "16                   PEK  \n",
       "17                   VCE  \n",
       "18                   NRT  \n",
       "19                   LIM  \n",
       "20                   GRU  \n",
       "21                   MAD  \n",
       "22                   DUB  \n",
       "23                   HKG  \n",
       "24                   CDG  \n",
       "25                   HNL  \n",
       "26                   PRG  \n",
       "27                   GYE  \n",
       "28                   STR  \n",
       "29                   TXL  "
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "complex_query = \"Select sum(\\\"PASSENGERS\\\"), sum(\\\"DEPARTURES_PERFORMED\\\"), sum(\\\"PASSENGERS\\\")/sum(\\\"DEPARTURES_PERFORMED\\\") as passengers_per_departure, destination_iata_code from flights where \\\"UNIQUE_CARRIER_NAME\\\" = 'Delta Air Lines Inc.' group by destination_iata_code order by passengers_per_departure desc\" # When using read_sql within PostgreSQL databases, if the original column name is capitalized or in all caps, you'll need to put the column name in quotes (preceded by backticks so they're not mistaken as beginning/ending a new string). This is because read_sql converts all column entries to lowercase. See https://stackoverflow.com/questions/68635773/column-does-not-exist-sqlalchemy-postgresql-trouble-with-quotation-marks\n",
    "# The quotes aren't necessary for SQLite; hence, the following code would also work:\n",
    "\n",
    "complex_query_for_sqlite = \"Select sum(PASSENGERS), sum(DEPARTURES_PERFORMED), sum(PASSENGERS)/sum(DEPARTURES_PERFORMED) as passengers_per_departure, destination_iata_code from flights where UNIQUE_CARRIER_NAME == 'Delta Air Lines Inc.' group by destination_iata_code order by passengers_per_departure desc\"\n",
    "\n",
    "\n",
    "\n",
    "test_result = pd.read_sql(complex_query, con = sqlalchemy_sqlite_engine)\n",
    "test_result.head(30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "if complex_query_test == True:\n",
    "    print(\"Pre-test speedtest:\")\n",
    "    run_speedtest()\n",
    "    complex_query_results = database_query_test(query = complex_query, query_count = complex_query_test_query_count, trials_count = complex_query_test_trials_count, offset = False, verbose = True)\n",
    "    print(\"Post-test speedtest:\")\n",
    "    run_speedtest()\n",
    "    complex_query_results.to_csv('metrics\\\\complex_query_test.csv')"
   ]
  },
  {
   "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>Service</th>\n",
       "      <th>Complex_Query_Time</th>\n",
       "      <th>Time_Per_Complex_Query</th>\n",
       "      <th>Complex_Query_Rank</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Snowflake</td>\n",
       "      <td>10.372686</td>\n",
       "      <td>0.207454</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Azure</td>\n",
       "      <td>16.240557</td>\n",
       "      <td>0.324811</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>AWS</td>\n",
       "      <td>53.415292</td>\n",
       "      <td>1.068306</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>GCP</td>\n",
       "      <td>54.259636</td>\n",
       "      <td>1.085193</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Databricks</td>\n",
       "      <td>63.377897</td>\n",
       "      <td>1.267558</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Heroku</td>\n",
       "      <td>135.697018</td>\n",
       "      <td>2.713940</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Service  Complex_Query_Time  Time_Per_Complex_Query  Complex_Query_Rank\n",
       "0   Snowflake           10.372686                0.207454                   1\n",
       "1       Azure           16.240557                0.324811                   2\n",
       "2         AWS           53.415292                1.068306                   3\n",
       "3         GCP           54.259636                1.085193                   4\n",
       "4  Databricks           63.377897                1.267558                   5\n",
       "5      Heroku          135.697018                2.713940                   6"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "complex_query_results = pd.read_csv('metrics\\\\complex_query_test.csv')\n",
    "mean_complex_query_times = complex_query_results[['Service', 'Time']].copy().groupby('Service').mean().sort_values('Time')\n",
    "mean_complex_query_times.rename(columns={'Time':'Complex_Query_Time'},inplace=True)\n",
    "mean_complex_query_times['Time_Per_Complex_Query'] = mean_complex_query_times['Complex_Query_Time'] / complex_query_test_query_count\n",
    "mean_complex_query_times.sort_values('Complex_Query_Time',inplace=True)\n",
    "mean_complex_query_times.reset_index(inplace=True)\n",
    "mean_complex_query_times['Complex_Query_Rank'] = mean_complex_query_times.index+1 # Converts the index (which starts with 0) into a ranking that starts with 1\n",
    "mean_complex_query_times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The complex queries took longer than the simple queries for all 6 providers. However, the complex query time/simple query time ratio varied widely, as df_query_time_comparison shows below. It was lowest for Snowflake (1.142), which exhibited the lowest complex query time overall, and highest for Heroku (76.75), which had the highest overall complex query time. Azure also had a significantly lower time than did AWS and GCP."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Line_list[0]: [<matplotlib.lines.Line2D object at 0x00000175A0732280>]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "complex_query_plot = plot_results(complex_query_results, title = 'Time required to execute '+str(complex_query_test_query_count)+' complex queries over '+str(complex_query_test_trials_count)+' trials', save_string = 'complex_query_time')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above chart shows that, while Azure, Snowflake, and Databricks had relatively consistent complex query times, the query times for AWS and Heroku increased over the 4 trials whereas GCP's decreased. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code block merges together all of the mean import/query time DataFrames, then creates a composite ranking of the 6 providers based on the sum of their 4 individual rankings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "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>Service</th>\n",
       "      <th>Composite ranking</th>\n",
       "      <th>Sum of ranks</th>\n",
       "      <th>Import_Time</th>\n",
       "      <th>Import_Time_Rank</th>\n",
       "      <th>Simple_Query_1x_Time</th>\n",
       "      <th>Simple_Query_1x_Rank</th>\n",
       "      <th>Simple_Query_1000x_Time</th>\n",
       "      <th>Simple_Query_1000x_Time_Per_Query</th>\n",
       "      <th>Simple_Query_1000x_Rank</th>\n",
       "      <th>Complex_Query_Time</th>\n",
       "      <th>Time_Per_Complex_Query</th>\n",
       "      <th>Complex_Query_Rank</th>\n",
       "      <th>Complex/Simple Query Ratio</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>AWS</td>\n",
       "      <td>1</td>\n",
       "      <td>9</td>\n",
       "      <td>41.006784</td>\n",
       "      <td>3</td>\n",
       "      <td>0.060395</td>\n",
       "      <td>2</td>\n",
       "      <td>33.991590</td>\n",
       "      <td>0.033992</td>\n",
       "      <td>1</td>\n",
       "      <td>53.415292</td>\n",
       "      <td>1.068306</td>\n",
       "      <td>3</td>\n",
       "      <td>31.428534</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Azure</td>\n",
       "      <td>2</td>\n",
       "      <td>10</td>\n",
       "      <td>40.748104</td>\n",
       "      <td>2</td>\n",
       "      <td>0.066731</td>\n",
       "      <td>3</td>\n",
       "      <td>37.267689</td>\n",
       "      <td>0.037268</td>\n",
       "      <td>3</td>\n",
       "      <td>16.240557</td>\n",
       "      <td>0.324811</td>\n",
       "      <td>2</td>\n",
       "      <td>8.715623</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Snowflake</td>\n",
       "      <td>3</td>\n",
       "      <td>12</td>\n",
       "      <td>17.480364</td>\n",
       "      <td>1</td>\n",
       "      <td>0.139276</td>\n",
       "      <td>5</td>\n",
       "      <td>181.722105</td>\n",
       "      <td>0.181722</td>\n",
       "      <td>5</td>\n",
       "      <td>10.372686</td>\n",
       "      <td>0.207454</td>\n",
       "      <td>1</td>\n",
       "      <td>1.141599</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Heroku</td>\n",
       "      <td>4</td>\n",
       "      <td>14</td>\n",
       "      <td>54.513024</td>\n",
       "      <td>5</td>\n",
       "      <td>0.056835</td>\n",
       "      <td>1</td>\n",
       "      <td>35.360053</td>\n",
       "      <td>0.035360</td>\n",
       "      <td>2</td>\n",
       "      <td>135.697018</td>\n",
       "      <td>2.713940</td>\n",
       "      <td>6</td>\n",
       "      <td>76.751592</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>GCP</td>\n",
       "      <td>5</td>\n",
       "      <td>16</td>\n",
       "      <td>41.315156</td>\n",
       "      <td>4</td>\n",
       "      <td>0.123177</td>\n",
       "      <td>4</td>\n",
       "      <td>100.523524</td>\n",
       "      <td>0.100524</td>\n",
       "      <td>4</td>\n",
       "      <td>54.259636</td>\n",
       "      <td>1.085193</td>\n",
       "      <td>4</td>\n",
       "      <td>10.795411</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Databricks</td>\n",
       "      <td>6</td>\n",
       "      <td>23</td>\n",
       "      <td>65.536882</td>\n",
       "      <td>6</td>\n",
       "      <td>0.821429</td>\n",
       "      <td>6</td>\n",
       "      <td>757.514256</td>\n",
       "      <td>0.757514</td>\n",
       "      <td>6</td>\n",
       "      <td>63.377897</td>\n",
       "      <td>1.267558</td>\n",
       "      <td>5</td>\n",
       "      <td>1.673312</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Service  Composite ranking  Sum of ranks  Import_Time  Import_Time_Rank  \\\n",
       "0         AWS                  1             9    41.006784                 3   \n",
       "1       Azure                  2            10    40.748104                 2   \n",
       "2   Snowflake                  3            12    17.480364                 1   \n",
       "3      Heroku                  4            14    54.513024                 5   \n",
       "4         GCP                  5            16    41.315156                 4   \n",
       "5  Databricks                  6            23    65.536882                 6   \n",
       "\n",
       "   Simple_Query_1x_Time  Simple_Query_1x_Rank  Simple_Query_1000x_Time  \\\n",
       "0              0.060395                     2                33.991590   \n",
       "1              0.066731                     3                37.267689   \n",
       "2              0.139276                     5               181.722105   \n",
       "3              0.056835                     1                35.360053   \n",
       "4              0.123177                     4               100.523524   \n",
       "5              0.821429                     6               757.514256   \n",
       "\n",
       "   Simple_Query_1000x_Time_Per_Query  Simple_Query_1000x_Rank  \\\n",
       "0                           0.033992                        1   \n",
       "1                           0.037268                        3   \n",
       "2                           0.181722                        5   \n",
       "3                           0.035360                        2   \n",
       "4                           0.100524                        4   \n",
       "5                           0.757514                        6   \n",
       "\n",
       "   Complex_Query_Time  Time_Per_Complex_Query  Complex_Query_Rank  \\\n",
       "0           53.415292                1.068306                   3   \n",
       "1           16.240557                0.324811                   2   \n",
       "2           10.372686                0.207454                   1   \n",
       "3          135.697018                2.713940                   6   \n",
       "4           54.259636                1.085193                   4   \n",
       "5           63.377897                1.267558                   5   \n",
       "\n",
       "   Complex/Simple Query Ratio  \n",
       "0                   31.428534  \n",
       "1                    8.715623  \n",
       "2                    1.141599  \n",
       "3                   76.751592  \n",
       "4                   10.795411  \n",
       "5                    1.673312  "
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_query_time_comparison = mean_import_times.merge(mean_simple_query_results_1x, on = 'Service').merge(mean_simple_query_results_1000x, on = 'Service').merge(mean_complex_query_times, on = 'Service')\n",
    "df_query_time_comparison.insert(1, 'Sum of ranks', df_query_time_comparison['Import_Time_Rank'] + df_query_time_comparison['Simple_Query_1x_Rank'] + df_query_time_comparison['Simple_Query_1000x_Rank'] + df_query_time_comparison['Complex_Query_Rank'])\n",
    "df_query_time_comparison['Complex/Simple Query Ratio'] = df_query_time_comparison['Time_Per_Complex_Query']/df_query_time_comparison['Simple_Query_1000x_Time_Per_Query']\n",
    "df_query_time_comparison.sort_values('Sum of ranks', inplace=True)\n",
    "df_query_time_comparison.reset_index(drop=True,inplace=True)\n",
    "df_query_time_comparison.insert(1, 'Composite ranking', df_query_time_comparison.index+1)\n",
    "df_query_time_comparison.to_csv('metrics\\\\overall_database_query_rankings.csv')\n",
    "df_query_time_comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Completed run at Mon Nov  8 19:05:46 2021 (local time)\n",
      "Total run time: 4.69 second(s) (0.0 minute(s) and 4.69 second(s))\n"
     ]
    }
   ],
   "source": [
    "end_time = time.time()\n",
    "run_time = end_time - start_time\n",
    "run_minutes = run_time // 60\n",
    "run_seconds = run_time % 60\n",
    "print(\"Completed run at\",time.ctime(end_time),\"(local time)\")\n",
    "print(\"Total run time:\",'{:.2f}'.format(run_time),\"second(s) (\"+str(run_minutes),\"minute(s) and\",'{:.2f}'.format(run_seconds),\"second(s))\") # Only meaningful when the program is run nonstop from start to finish\n"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "7a016a462c2a18f177a2554c94a9e2d8b52c0ae6e623363f8138b3d5b2656021"
  },
  "kernelspec": {
   "display_name": "Python 3.9.5 64-bit ('ga15pyd': conda)",
   "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.9.5"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}