sql_query_tom_db.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6975bebe-4249-4f69-8404-45224d1c9ccf",
   "metadata": {},
   "source": [
    "# Querying the TOM's database directly\n",
    "\n",
    "For this to work, you must have an account on the DESC TOM.  If you need one and don't have one, contact Rob Knop (e.g. on Slack).\n",
    "\n",
    "The interfaces below are based on python `requests` and `psycopg2` (for connecting to a PostgreSQL database).  Hopefully the examples will make clear everything you need, but some of this will be more obvious if you're familiar with those two things.\n",
    "\n",
    "## Overview\n",
    "\n",
    "The postgres database behind the DESC TOM is not externally available.  You may be able to get what you need by using the various REST interfaces the DESC TOM provides.  For a couple of examples:\n",
    "* https://github.com/LSSTDESC/elasticc_metrics/blob/main/elasticc2_rest_metric_demo.ipynb for querying ELAsTiCC2 metrics\n",
    "* https://github.com/LSSTDESC/tom_desc?tab=readme-ov-file#elasticc2spec for getting information about hot transients, requested spectra, and for pushing information about spectra you've taken.\n",
    "\n",
    "If you need to access the SQL database directly, there are two web APIs, one for fast queries, one for slow queries.\n",
    "\n",
    "## Fast Queries\n",
    "\n",
    "For fast queries, you can use the API endpoint `db/runsqlquery/`.  You POST to this URL with the query you want to run in the POST data, and get back JSON including the results of your query.  This is documented with examples below.\n",
    "\n",
    "## Slow Queries\n",
    "\n",
    "The web proxy to the TOM will time out if a request takes more than 5 minutes.  So, if your SQL query is going to run more than a couple of minutes, the `db/runsqlquery/` interface won't work.  (ELAsTiCC2 has 990 million forced source datapoints and 380 million broker classification messages, so all it takes is the right table join and your query can take minutes and minutes... or more.)\n",
    "\n",
    "To handle this, there's another interface that let's you submit a query (or a series of queries).  They will all one in one transaction, so you can do things like create temporary tables with these queries.  After submitting the query, you'll get back a query id, which you send to a couple of different web API endpoints to check the status of your query, and (if it's done) to get the results.  On the back end, there is a process that will run these slow queries.  (At the moment, there's only a single thread running those queries, but in the future I will make this multi-threaded so one person submitting a 3-day query doesn't block everybody else.)\n",
    "\n",
    "This second interface is also documented with examples below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "59c4bf2b-60f6-4a93-82ab-427082d5dd89",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import sys\n",
    "import os\n",
    "import io\n",
    "import math\n",
    "import requests\n",
    "import datetime\n",
    "import json\n",
    "import time\n",
    "import pandas\n",
    "import matplotlib.pyplot\n",
    "\n",
    "from tom_client import TomClient"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3bb262f-a622-4702-be13-2d3f62ed4c35",
   "metadata": {},
   "source": [
    "# Connecting to the TOM\n",
    "\n",
    "To use either fast query or slow query interface, you need to connect to the DESC TOM.  You could accomplish this entirely using the python `requests` module, but there are some annoying things that django (the framework that the TOM works on) wants to see in headers.  To this end, there is a python module [`tom_client.py`](https://github.com/LSSTDESC/tom_desc/blob/main/tom_client.py) that takes care of this stuff.\n",
    "\n",
    "Here, we create a variable `tomclient` that will log us into the TOM, and that we will use for the rest of the script to communicate with the TOM.\n",
    "\n",
    "__Note__ : you will need to edit the next cell for your own TOM username and password.  (Read the comments.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7b25f98b-4a00-4c3a-b325-3d8f61d114ff",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "url = \"https://desc-tom.lbl.gov\"\n",
    "# url = \"https://desc-tom-2.lbl.gov\"\n",
    "# url = \"https://desc-tom-rknop-dev.lbl.gov\"\n",
    "\n",
    "# Somehow you need to set the \"username\" and \"password\" variables.\n",
    "# Do NOT hardcode the password into any code that will be world\n",
    "# readable.  You can use the python input statement, or, as I do\n",
    "# here, read the password from a file that is only readable by\n",
    "# you.  (This isn't perfect, but it's better than having the\n",
    "# password sit around in a world readable file.)\n",
    "\n",
    "# username = \"root\"\n",
    "# passwordfile = \"tom_root_passwd\"\n",
    "username = \"rknop\"\n",
    "passwordfile = \"tom_rknop_passwd\"\n",
    "with open( os.path.join( os.getenv(\"HOME\"), \"secrets\", passwordfile ) ) as ifp:\n",
    "    password = ifp.readline().strip()\n",
    "    \n",
    "# I could also have skipped the previous line and just done\n",
    "#   tomclient = TomClient( url=url, username=username,\n",
    "#                          passwordfile=os.path.join( os.getenv('HOME'), \"secrets\", \"tom_rknop_passwd\" ) )\n",
    "\n",
    "tomclient = TomClient( url=url, username=username, password=password )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7afa2209-f668-4bd5-b2e7-a69c520ce87a",
   "metadata": {},
   "source": [
    "# The Fast Query Interface\n",
    "\n",
    "If your query is going to take less than a couple of minutes, this is the one to use.  To run it, you send POST data to the endpoint `db/runsqlquery` on the DESC TOM.  The POST data should be a JSON encoded dictionary with keys:\n",
    "* `query`: str or list of str.  The SQL query to run, or a list of queries to run in order in a single transaction.\n",
    "* `subdict`: dict, list of dict, or None (default).  You can include `%(varname)s` in your SQL query, where `varname` can be any string.  Then, in your subdict, you should have `varname` as a key, and the value is what should be substituted into the query.  (These are as used in  the [psycopg2 cursor](https://www.psycopg.org/docs/cursor.html) \"execute\" method.)\n",
    "\n",
    "You should practice good SQL hygiene and make sure to use `subdict` to interpolate any calculated or user-inputted parameters.  However, don't worry too much; unless Rob screwed up horribly, the back-end uses a read-only postgres user, so you won't be able to [Bobby Tables](https://xkcd.com/327/) the database.  (Note that even though it's a read-only user, you _can_ still create temporary tables.)\n",
    "\n",
    "If all is well, the HTTP response you get from posting to that URL will have a status code of 200 (successful response).  If it's something else, it means that something went wrong, perhaps a timeout, perhaps something wrong server-side.  If everything worked server-side, but your SQL had an error in it, you should still get an HTTP status code response of 200.\n",
    "\n",
    "The response body will be JSON encoded; you can extract this as a dictionary by calling the `json()` method of the response object.  One key of the dictionary will be `status`; if the value is `ok`, then there will be a second key `rows`, whose value is an array of dictionaries holding the results of your query (or of the last query, if you submitted a list).  If `status` is `error`, then something went wrong, almost certainly an error in your SQL.  In this case, look at the value of the `error` key in the dictionary to get an error message.  This is shown below; first, we define a boilerplate function that does all of the error parsing, so that we don't have to redo that every time we send a new query."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3ecad12f-7342-4248-9576-0c8159d4684a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# This function effectively pushes a cursor.execute( query, subdict ) through\n",
    "# the web API, returning the corresponding cursor.fetchrows().\n",
    "#\n",
    "# You can just post the SQL directly to tomclient.post(), sending \n",
    "# a dict in the postdata with keys \"query\" and \"subdict\".  The purpose\n",
    "# of this function is to do some boilerplate error checking.\n",
    "#\n",
    "# You can pass multiple queries, in which case query should\n",
    "# be a list of strings and subdict should be a list of dicts.\n",
    "# You will get back the rows from the last query.  (This is\n",
    "# how you would create temporary tables, for instance.)\n",
    "#\n",
    "# Depends on global variable tomclient\n",
    "\n",
    "def run_query( query, subdict=None ):\n",
    "    sendjson = { 'query': query }\n",
    "    if subdict is not None:\n",
    "        sendjson['subdict'] = subdict\n",
    "    result = tomclient.post( 'db/runsqlquery/', json=sendjson )\n",
    "    if ( result.status_code != 200 ):\n",
    "        raise RuntimeError( f\"Got http status {result.status_code}\" )\n",
    "    data = json.loads( result.text )\n",
    "    if ( 'status' in data ) and ( data['status'] == 'error' ):\n",
    "        sys.stderr.write( f\"ERROR: {data['error']}\" )\n",
    "        return []\n",
    "    elif ( 'status' not in data ) or ( data['status'] != 'ok' ):\n",
    "        raise RuntimeError( f\"Got unexpected response: {data}\" )\n",
    "    return data['rows']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "57f67386-6712-4902-8cb2-1a09ea42d85d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "classId   gentype    description\n",
      "---------------------------------\n",
      "      0      None    Meta\n",
      "    100      None    Meta/Other\n",
      "    200      None    Residual\n",
      "    300      None    NotClassified\n",
      "   1000      None    Static\n",
      "   1100      None    Static/Other\n",
      "   2000      None    Variable\n",
      "   2100      None    Variable/Other\n",
      "   2200      None    Non-Recurring\n",
      "   2210      None    Non-Recurring/Other\n",
      "   2220      None    SN-like\n",
      "   2221      None    SN-like/Other\n",
      "   2222        10    Ia\n",
      "   2223        20    Ib/c\n",
      "   2223        21    Ib/c\n",
      "   2223        25    Ib/c\n",
      "   2223        26    Ib/c\n",
      "   2223        27    Ib/c\n",
      "   2224        30    II\n",
      "   2224        31    II\n",
      "   2224        32    II\n",
      "   2224        35    II\n",
      "   2224        36    II\n",
      "   2224        37    II\n",
      "   2225        12    Iax\n",
      "   2226        11    91bg\n",
      "   2230      None    Fast\n",
      "   2231      None    Fast/Other\n",
      "   2232        50    KN\n",
      "   2232        51    KN\n",
      "   2233        82    M-dwarf Flare\n",
      "   2234        84    Dwarf Novae\n",
      "   2235        87    uLens\n",
      "   2235        88    uLens\n",
      "   2235        89    uLens\n",
      "   2240      None    Long\n",
      "   2241      None    Long/Other\n",
      "   2242        40    SLSN\n",
      "   2243        42    TDE\n",
      "   2244        45    ILOT\n",
      "   2245        46    CART\n",
      "   2246        59    PISN\n",
      "   2300      None    Recurring\n",
      "   2310      None    Recurring/Other\n",
      "   2320      None    Periodic\n",
      "   2321      None    Periodic/Other\n",
      "   2322        90    Cepheid\n",
      "   2323        80    RR Lyrae\n",
      "   2324        91    Delta Scuti\n",
      "   2325        83    EB\n",
      "   2326      None    LPV/Mira\n",
      "   2330      None    Non-Periodic\n",
      "   2331      None    Non-Periodic/Other\n",
      "   2332        60    AGN\n"
     ]
    }
   ],
   "source": [
    "# Example: look at the contents of the elasticc_gentypeofclassid table\n",
    "# (That's the table that you would use if you have a gentype in order\n",
    "# to figure out what classId a broker should supply for it.)\n",
    "#\n",
    "query = 'SELECT * FROM elasticc2_gentypeofclassid'\n",
    "rows = run_query( query )\n",
    "print( f'classId   gentype    description' )\n",
    "print( '---------------------------------' )\n",
    "for row in rows:\n",
    "    print( f'{row[\"classid\"]:7d}   '\n",
    "           f'{\"None\" if row[\"gentype\"] is None else str(row[\"gentype\"]):>7s}    '\n",
    "           f'{row[\"description\"]}' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c84dbbf5-0be1-4ec0-a9bc-6e7efa7bc3e7",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "classId   gentype    exactmatch categorymatch broadmatch generalmatch description\n",
      "----------------------------------------------------------------------------------\n",
      "   2000        10    False      False         True       False        Variable\n",
      "   2000        11    False      False         True       False        Variable\n",
      "   2000        12    False      False         True       False        Variable\n",
      "   2000        20    False      False         True       False        Variable\n",
      "   2000        21    False      False         True       False        Variable\n",
      "   2000        25    False      False         True       False        Variable\n",
      "   2000        26    False      False         True       False        Variable\n",
      "   2000        27    False      False         True       False        Variable\n",
      "   2000        30    False      False         True       False        Variable\n",
      "   2000        31    False      False         True       False        Variable\n",
      "   2000        32    False      False         True       False        Variable\n",
      "   2000        35    False      False         True       False        Variable\n",
      "   2000        36    False      False         True       False        Variable\n",
      "   2000        37    False      False         True       False        Variable\n",
      "   2000        40    False      False         True       False        Variable\n",
      "   2000        42    False      False         True       False        Variable\n",
      "   2000        45    False      False         True       False        Variable\n",
      "   2000        46    False      False         True       False        Variable\n",
      "   2000        50    False      False         True       False        Variable\n",
      "   2000        51    False      False         True       False        Variable\n",
      "   2000        59    False      False         True       False        Variable\n",
      "   2000        60    False      False         True       False        Variable\n",
      "   2000        80    False      False         True       False        Variable\n",
      "   2000        82    False      False         True       False        Variable\n",
      "   2000        83    False      False         True       False        Variable\n",
      "   2000        84    False      False         True       False        Variable\n",
      "   2000        87    False      False         True       False        Variable\n",
      "   2000        88    False      False         True       False        Variable\n",
      "   2000        89    False      False         True       False        Variable\n",
      "   2000        90    False      False         True       False        Variable\n",
      "   2000        91    False      False         True       False        Variable\n",
      "   2200        10    False      False         True       True         Non-Recurring\n",
      "   2200        11    False      False         True       True         Non-Recurring\n",
      "   2200        12    False      False         True       True         Non-Recurring\n",
      "   2200        20    False      False         True       True         Non-Recurring\n",
      "   2200        21    False      False         True       True         Non-Recurring\n",
      "   2200        25    False      False         True       True         Non-Recurring\n",
      "   2200        26    False      False         True       True         Non-Recurring\n",
      "   2200        27    False      False         True       True         Non-Recurring\n",
      "   2200        30    False      False         True       True         Non-Recurring\n",
      "   2200        31    False      False         True       True         Non-Recurring\n",
      "   2200        32    False      False         True       True         Non-Recurring\n",
      "   2200        35    False      False         True       True         Non-Recurring\n",
      "   2200        36    False      False         True       True         Non-Recurring\n",
      "   2200        37    False      False         True       True         Non-Recurring\n",
      "   2200        40    False      False         True       True         Non-Recurring\n",
      "   2200        42    False      False         True       True         Non-Recurring\n",
      "   2200        45    False      False         True       True         Non-Recurring\n",
      "   2200        46    False      False         True       True         Non-Recurring\n",
      "   2200        50    False      False         True       True         Non-Recurring\n",
      "   2200        51    False      False         True       True         Non-Recurring\n",
      "   2200        59    False      False         True       True         Non-Recurring\n",
      "   2200        82    False      False         True       True         Non-Recurring\n",
      "   2200        84    False      False         True       True         Non-Recurring\n",
      "   2200        87    False      False         True       True         Non-Recurring\n",
      "   2200        88    False      False         True       True         Non-Recurring\n",
      "   2200        89    False      False         True       True         Non-Recurring\n",
      "   2220        10    False      True          True       True         SN-like\n",
      "   2220        11    False      True          True       True         SN-like\n",
      "   2220        12    False      True          True       True         SN-like\n",
      "   2220        20    False      True          True       True         SN-like\n",
      "   2220        21    False      True          True       True         SN-like\n",
      "   2220        25    False      True          True       True         SN-like\n",
      "   2220        26    False      True          True       True         SN-like\n",
      "   2220        27    False      True          True       True         SN-like\n",
      "   2220        30    False      True          True       True         SN-like\n",
      "   2220        31    False      True          True       True         SN-like\n",
      "   2220        32    False      True          True       True         SN-like\n",
      "   2220        35    False      True          True       True         SN-like\n",
      "   2220        36    False      True          True       True         SN-like\n",
      "   2220        37    False      True          True       True         SN-like\n",
      "   2222        10    True       True          True       True         Ia\n",
      "   2226        11    True       True          True       True         91bg\n",
      "   2225        12    True       True          True       True         Iax\n",
      "   2223        20    True       True          True       True         Ib/c\n",
      "   2223        21    True       True          True       True         Ib/c\n",
      "   2223        25    True       True          True       True         Ib/c\n",
      "   2223        26    True       True          True       True         Ib/c\n",
      "   2223        27    True       True          True       True         Ib/c\n",
      "   2224        30    True       True          True       True         II\n",
      "   2224        31    True       True          True       True         II\n",
      "   2224        32    True       True          True       True         II\n",
      "   2224        35    True       True          True       True         II\n",
      "   2224        36    True       True          True       True         II\n",
      "   2224        37    True       True          True       True         II\n",
      "   2230        50    False      True          True       True         Fast\n",
      "   2230        51    False      True          True       True         Fast\n",
      "   2230        82    False      True          True       True         Fast\n",
      "   2230        84    False      True          True       True         Fast\n",
      "   2230        87    False      True          True       True         Fast\n",
      "   2230        88    False      True          True       True         Fast\n",
      "   2230        89    False      True          True       True         Fast\n",
      "   2232        50    True       True          True       True         KN\n",
      "   2232        51    True       True          True       True         KN\n",
      "   2233        82    True       True          True       True         M-dwarf Flare\n",
      "   2234        84    True       True          True       True         Dwarf Novae\n",
      "   2235        87    True       True          True       True         uLens\n",
      "   2235        88    True       True          True       True         uLens\n",
      "   2235        89    True       True          True       True         uLens\n",
      "   2240        40    False      True          True       True         Long\n",
      "   2240        42    False      True          True       True         Long\n",
      "   2240        45    False      True          True       True         Long\n",
      "   2240        46    False      True          True       True         Long\n",
      "   2240        59    False      True          True       True         Long\n",
      "   2242        40    True       True          True       True         SLSN\n",
      "   2243        42    True       True          True       True         TDE\n",
      "   2244        45    True       True          True       True         ILOT\n",
      "   2245        46    True       True          True       True         CART\n",
      "   2246        59    True       True          True       True         PISN\n",
      "   2300        60    False      False         True       True         Recurring\n",
      "   2300        80    False      False         True       True         Recurring\n",
      "   2300        83    False      False         True       True         Recurring\n",
      "   2300        90    False      False         True       True         Recurring\n",
      "   2300        91    False      False         True       True         Recurring\n",
      "   2320        80    False      True          True       True         Periodic\n",
      "   2320        83    False      True          True       True         Periodic\n",
      "   2320        90    False      True          True       True         Periodic\n",
      "   2320        91    False      True          True       True         Periodic\n",
      "   2322        90    True       True          True       True         Cepheid\n",
      "   2323        80    True       True          True       True         RR Lyrae\n",
      "   2324        91    True       True          True       True         Delta Scuti\n",
      "   2325        83    True       True          True       True         EB\n",
      "   2330        60    False      True          True       True         Non-Periodic\n",
      "   2332        60    True       True          True       True         AGN\n"
     ]
    }
   ],
   "source": [
    "# example: look at the contents of the classidofgentype table\n",
    "# (That's the table you would use given a classId from a broker\n",
    "# to figure out which gentypes (there could be more than one)\n",
    "# correspond to it.)\n",
    "#\n",
    "query = 'SELECT * FROM elasticc2_classidofgentype'\n",
    "rows = run_query( query )\n",
    "print( f'classId   gentype    exactmatch categorymatch broadmatch generalmatch description' )\n",
    "print( '----------------------------------------------------------------------------------' )\n",
    "for row in rows:\n",
    "    print( f'{row[\"classid\"]:7d}   '\n",
    "           f'{\"None\" if row[\"gentype\"] is None else str(row[\"gentype\"]):>7s}    '\n",
    "           f'{str(row[\"exactmatch\"]):10s} '\n",
    "           f'{str(row[\"categorymatch\"]):13s} '\n",
    "           f'{str(row[\"broadmatch\"]):10s} '\n",
    "           f'{str(row[\"generalmatch\"]):12s} '\n",
    "           f'{row[\"description\"]}' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "97cc6ea0-f2c7-48b8-8c97-566fe8858207",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Request took 0.05 seconds"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[{'diaobject_id': 1000065, 'ndets': 15},\n",
       " {'diaobject_id': 1000154, 'ndets': 21},\n",
       " {'diaobject_id': 1000720, 'ndets': 34},\n",
       " {'diaobject_id': 1000755, 'ndets': 6},\n",
       " {'diaobject_id': 1001012, 'ndets': 32},\n",
       " {'diaobject_id': 1001015, 'ndets': 12},\n",
       " {'diaobject_id': 1001227, 'ndets': 23},\n",
       " {'diaobject_id': 1001305, 'ndets': 15},\n",
       " {'diaobject_id': 1001572, 'ndets': 7},\n",
       " {'diaobject_id': 1001760, 'ndets': 11}]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example: we want to look at a SNIa lightcurve.  Pick out a SNIa from the truth table\n",
    "# that has at least 5 detections.\n",
    "query = ( 'SELECT diaobject_id,ndets FROM '\n",
    "          ' ( SELECT ot.diaobject_id,COUNT(s.diasource_id) AS ndets FROM elasticc2_diaobjecttruth ot '\n",
    "          '   INNER JOIN elasticc2_diasource s ON ot.diaobject_id=s.diaobject_id '\n",
    "          '   INNER JOIN elasticc2_ppdbalert a ON s.diasource_id=a.diasource_id '\n",
    "          '   WHERE a.alertsenttimestamp IS NOT NULL '\n",
    "          '     AND ot.gentype=10 '\n",
    "          '   GROUP BY ot.diaobject_id ) subq '\n",
    "          '   WHERE ndets > 5 LIMIT 10 ' )\n",
    "t0 = time.perf_counter()\n",
    "objlist = run_query( query )\n",
    "t1 = time.perf_counter()\n",
    "sys.stderr.write( f\"Request took {t1-t0:.2f} seconds\" ) \n",
    "objlist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f969fe57-fe17-4d16-91bb-8da8ab7a34fe",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Got 75 forced photometry points.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Request took 0.05 seconds."
     ]
    }
   ],
   "source": [
    "# I like the look of the 3rd one I got when I ran this query so let's get that one's lightcurve.\n",
    "#\n",
    "# Get the lightcurve that would have been in the most recent alert that's been sent.  To do that:\n",
    "# * Find the latest alert that has alertSentTimestamp that's not NULL.\n",
    "# * Find the first alert for that object\n",
    "# * Return everything in diaForcedSource that is between (first alert - 30 days) and (latest alert)\n",
    "#\n",
    "# (Note that because elasticc2 is over, all alerts were sent, so this is kind of gratuitous; I\n",
    "# could have just gotten all the points.  But, for demo purposes...)\n",
    "\n",
    "objid = objlist[2]['diaobject_id']\n",
    "query = ( 'SELECT midpointtai,filtername,psflux,psfluxerr FROM elasticc2_diaforcedsource '\n",
    "          'WHERE diaobject_id=%(objid)s '\n",
    "          'AND midPointTai >= ( SELECT midpointtai-30 FROM elasticc2_diasource '\n",
    "          '                     WHERE diaobject_id=%(objid)s '\n",
    "          '                     ORDER BY midpointtai LIMIT 1 ) '\n",
    "          'AND midPointTai <= ( SELECT midpointtai FROM elasticc2_diasource s '\n",
    "          '                     INNER JOIN elasticc2_ppdbalert a ON s.diasource_id=a.diasource_id '\n",
    "          '                     WHERE a.alertsenttimestamp IS NOT NULL AND s.diaobject_id=%(objid)s'\n",
    "          '                     ORDER BY s.midpointtai DESC LIMIT 1 ) ' )\n",
    "t0 = time.perf_counter()\n",
    "rows = run_query( query, { 'objid': objid } )\n",
    "t1 = time.perf_counter()\n",
    "sys.stderr.write( f\"Request took {t1-t0:.2f} seconds.\" )\n",
    "print( f\"Got {len(rows)} forced photometry points.\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "0b5b3435-3958-4df3-85fe-63a00827ade9",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot!\n",
    "df = pandas.DataFrame( rows )\n",
    "filters = df['filtername'].unique()\n",
    "mint = df['midpointtai'].min()\n",
    "maxt = df['midpointtai'].max()\n",
    "dt = maxt-mint\n",
    "mint -= 0.05*dt\n",
    "maxt += 0.05*dt\n",
    "ncols = 3\n",
    "nrows = math.ceil( len(filters) / ncols )\n",
    "fig = matplotlib.pyplot.figure( figsize=(12,3*nrows), tight_layout=True )\n",
    "for i, filter in enumerate(filters):\n",
    "    subdf = df[ df['filtername'] == filter ]\n",
    "    ax = fig.add_subplot( nrows, ncols, i+1 )\n",
    "    ax.errorbar( subdf['midpointtai']-mint, subdf['psflux'], subdf['psfluxerr'], linestyle='None', marker='o' )\n",
    "    ax.set_title( f'{filter}-band', fontsize=18 )\n",
    "    ax.set_xlabel( f'MJD - {mint}', fontsize=16 )\n",
    "    ax.set_ylabel( 'Flux', fontsize=16 )\n",
    "    ax.tick_params( 'both', labelsize=14 )\n",
    "    ymin, ymax = ax.get_ylim()\n",
    "    if ymin > 0:\n",
    "        ax.set_ylim( 0, ymax )\n",
    "    else:\n",
    "        ax.axhline( color='black' )\n",
    "    ax.set_xlim( 0, maxt-mint )\n",
    "fig.show()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0f976896-434e-4a7e-9e62-8d81b7bdac16",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alertId          diaSourceId       diaObjectId      indirect_object\n",
      "--------------------------------------------------------------------------\n",
      "  13521318000051   13521318000051        135213180        135213180\n",
      "  13521318000068   13521318000068        135213180        135213180\n",
      "  13521318000070   13521318000070        135213180        135213180\n",
      "  13521318000074   13521318000074        135213180        135213180\n",
      "  13521318000076   13521318000076        135213180        135213180\n",
      "  13521318000081   13521318000081        135213180        135213180\n",
      "  13521318000084   13521318000084        135213180        135213180\n",
      "  13521318000093   13521318000093        135213180        135213180\n",
      "  13521318000095   13521318000095        135213180        135213180\n",
      "  13521318000099   13521318000099        135213180        135213180\n",
      "  13521318000102   13521318000102        135213180        135213180\n",
      "  13521318000113   13521318000113        135213180        135213180\n",
      "   4768919800101    4768919800101         47689198         47689198\n",
      "   4768919800108    4768919800108         47689198         47689198\n",
      "   4768919800110    4768919800110         47689198         47689198\n",
      "   4768919800112    4768919800112         47689198         47689198\n",
      "   4768919800128    4768919800128         47689198         47689198\n",
      "   4768919800130    4768919800130         47689198         47689198\n",
      "   4768919800132    4768919800132         47689198         47689198\n",
      "   4768919800133    4768919800133         47689198         47689198\n",
      "   4768919800135    4768919800135         47689198         47689198\n",
      "   4768919800138    4768919800138         47689198         47689198\n",
      "   4768919800142    4768919800142         47689198         47689198\n",
      "   4768919800144    4768919800144         47689198         47689198\n",
      "   4768919800146    4768919800146         47689198         47689198\n",
      "   4768919800147    4768919800147         47689198         47689198\n",
      "   4768919800150    4768919800150         47689198         47689198\n",
      "   4768919800155    4768919800155         47689198         47689198\n",
      "   4768919800157    4768919800157         47689198         47689198\n",
      "   7328930702796    7328930702796         73289307         73289307\n",
      "   4768919800167    4768919800167         47689198         47689198\n",
      "  13521318000127   13521318000127        135213180        135213180\n",
      "  13521318000128   13521318000128        135213180        135213180\n",
      "  13521318000133   13521318000133        135213180        135213180\n",
      "  13521318000135   13521318000135        135213180        135213180\n",
      "  13521318000137   13521318000137        135213180        135213180\n",
      "   4768919800186    4768919800186         47689198         47689198\n",
      "  13521318000143   13521318000143        135213180        135213180\n",
      "   4768919800187    4768919800187         47689198         47689198\n",
      "   4768919800190    4768919800190         47689198         47689198\n",
      "   4768919800191    4768919800191         47689198         47689198\n",
      "   4768919800196    4768919800196         47689198         47689198\n",
      "  13521318000148   13521318000148        135213180        135213180\n",
      "  13521318000149   13521318000149        135213180        135213180\n",
      "   4768919800209    4768919800209         47689198         47689198\n",
      "   4768919800213    4768919800213         47689198         47689198\n",
      "   4768919800216    4768919800216         47689198         47689198\n",
      "   4768919800218    4768919800218         47689198         47689198\n",
      "   4768919800222    4768919800222         47689198         47689198\n",
      "   4768919800225    4768919800225         47689198         47689198\n",
      "   4768919800230    4768919800230         47689198         47689198\n",
      "   4768919800231    4768919800231         47689198         47689198\n",
      "   4768919800233    4768919800233         47689198         47689198\n",
      "   4768919800234    4768919800234         47689198         47689198\n",
      "   4768919800239    4768919800239         47689198         47689198\n",
      "   4768919800244    4768919800244         47689198         47689198\n",
      "   4768919800254    4768919800254         47689198         47689198\n",
      "   4768919800257    4768919800257         47689198         47689198\n",
      "   4768919800258    4768919800258         47689198         47689198\n",
      "   4768919800261    4768919800261         47689198         47689198\n",
      "   4768919800266    4768919800266         47689198         47689198\n",
      "  15485703424333   15485703424333        154857034        154857034\n",
      "  15485703424334   15485703424334        154857034        154857034\n",
      "  13521318000181   13521318000181        135213180        135213180\n",
      "  13521318000185   13521318000185        135213180        135213180\n",
      "  13521318000186   13521318000186        135213180        135213180\n",
      "  13521318000189   13521318000189        135213180        135213180\n",
      "  13521318000190   13521318000190        135213180        135213180\n",
      "  13521318000191   13521318000191        135213180        135213180\n",
      "  13521318000193   13521318000193        135213180        135213180\n",
      "  13521318000194   13521318000194        135213180        135213180\n",
      "  13521318000195   13521318000195        135213180        135213180\n",
      "   4768919800331    4768919800331         47689198         47689198\n",
      "   4768919800339    4768919800339         47689198         47689198\n",
      "   4768919800267    4768919800267         47689198         47689198\n",
      "   4768919800268    4768919800268         47689198         47689198\n",
      "   4768919800269    4768919800269         47689198         47689198\n",
      "   4768919800271    4768919800271         47689198         47689198\n",
      "   4768919800276    4768919800276         47689198         47689198\n",
      "   4768919800281    4768919800281         47689198         47689198\n",
      "   4768919800284    4768919800284         47689198         47689198\n",
      "   4768919800285    4768919800285         47689198         47689198\n",
      "   4768919800286    4768919800286         47689198         47689198\n",
      "   4768919800287    4768919800287         47689198         47689198\n",
      "   4768919800290    4768919800290         47689198         47689198\n",
      "   4768919800294    4768919800294         47689198         47689198\n",
      "   4768919800295    4768919800295         47689198         47689198\n",
      "   4768919800299    4768919800299         47689198         47689198\n",
      "   4768919800301    4768919800301         47689198         47689198\n",
      "   4768919800311    4768919800311         47689198         47689198\n",
      "   4768919800312    4768919800312         47689198         47689198\n",
      "   4768919800316    4768919800316         47689198         47689198\n",
      "   4768919800317    4768919800317         47689198         47689198\n",
      "   4768919800319    4768919800319         47689198         47689198\n",
      "   4768919800320    4768919800320         47689198         47689198\n",
      "   4768919800321    4768919800321         47689198         47689198\n",
      "   4768919800004    4768919800004         47689198         47689198\n",
      "   4768919800007    4768919800007         47689198         47689198\n",
      "   4768919800010    4768919800010         47689198         47689198\n",
      "   4768919800013    4768919800013         47689198         47689198\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Request took 0.06 seconds\n"
     ]
    }
   ],
   "source": [
    "# Gratuitous multiple query example\n",
    "\n",
    "queries = [ 'SELECT a.alert_id,a.diasource_id,a.diaobject_id,s.diaobject_id AS indirect_object '\n",
    "            'INTO TEMP TABLE gratuitous_table '\n",
    "            'FROM elasticc2_ppdbalert a'\n",
    "            '  INNER JOIN elasticc2_diasource s ON a.diasource_id=s.diasource_id '\n",
    "            'LIMIT 100 '\n",
    "           ,\n",
    "            'SELECT * FROM pg_temp.gratuitous_table' ]\n",
    "t0 = time.perf_counter()\n",
    "rows = run_query( queries )\n",
    "t1 = time.perf_counter()\n",
    "sys.stderr.write( f\"Request took {t1-t0:.2f} seconds\\n\" )\n",
    "print( \"alertId          diaSourceId       diaObjectId      indirect_object\\n\"\n",
    "       \"--------------------------------------------------------------------------\" )\n",
    "for row in rows:\n",
    "    print( f\"{row['alert_id']:16d} {row['diasource_id']:16d} {row['diaobject_id']:16d} {row['indirect_object']:16d}\" )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6577205-f66c-4c94-b546-142e0748737e",
   "metadata": {},
   "source": [
    "# The Slow Query Interface\n",
    "\n",
    "The slow query interface is inevitably going to be less convenient to use.  The overview of how to use it is:\n",
    "\n",
    "* POST to API endpoint `db/submitsqlquery/` to submit your query (or queries) and get an id for your query.  Save this id, because it's the only way to get the results of your query later!  (At the moment, there's no interface to see all queries you've submitted.  I will hopefully add that at some point.)\n",
    "* Wait\n",
    "* POST to API endpoint `checksqlquery/<queryid>/` to see if your query is done.  If so, go on.  If not, wait, and repeat this step.\n",
    "* POST to API endpoint `getsqlqueryresults/<queryid>/` to get the results of your query\n",
    "\n",
    "(Notice the slashes at the ends of the URLs; that's another annoying djangoism.)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2f74014-ed80-4cf2-8126-fa2b4ddafb9a",
   "metadata": {},
   "source": [
    "## Submitting a query\n",
    "\n",
    "The POST data to `db/submitsqlquery/` must be a JSON-encoded dictionary with keys:\n",
    "* `query: str or list of str` : the query to run (or a list of queries), with possible `%(varname)s` variables to be interpolated.  (See the docs on the fast query interface above.)\n",
    "* `subdict: dict` : the substitution dictionary to go with `query`, or a list of dictionaries if `query` was a list.  Optional, if you have no variables to substitute.  If using lists, the length of this list and the list in `query` must be the same.\n",
    "* `format: str` : the format you will want your data returned in; one of `csv`, `pandas`, or `numpy`.  If `csv`, you will get back text data in csv format (with actual commas separating the fields).  If `pandas`, you will get back a binary blob that is a pickled pandas object.  If `numpy`, you will get back an error, because that format isn't implemented yet.  If you don't specify `format`, it will default to `csv` (the least efficient, but most likely to be readable, format).\n",
    "\n",
    "If all is well, the response you get will have status code 200, and the body of the response will be a JSON-encoded dictionary; call that `resdict`.  (You can get `resdict` with something like `resdict=resp.json()`, if `resp` is the thing returned by your `TomClient.post()` call.)  If `resdict['status']` is `ok`, then `resdict['queryid']` has the id of your query.  Save this!  If you lose it, you won't be able to get your query results.  If `resdict['status']` is `error`, then look at `resdict['error']` to see if there's anything helpful there.\n",
    "\n",
    "For example:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f57c7e2e-4f2d-4ca5-b5f2-fbac2bcd497c",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitted query 7b3c111a-8b0b-4e6c-90ba-0934fea35458\n"
     ]
    }
   ],
   "source": [
    "queryid = None\n",
    "\n",
    "res = tomclient.post( 'db/submitsqlquery/', json={ 'query': 'SELECT * FROM elasticc2_ppdbdiaobject' } )\n",
    "if res.status_code != 200:\n",
    "    sys.stderr.write( f\"ERROR, got status {res.status_code}\\n\" )\n",
    "elif res.headers['Content-Type'][:16] != 'application/json':\n",
    "    sys.stderr.write( f\"ERROR, didn't get json, got {res.headers['Content-Type']}\" )\n",
    "else:\n",
    "    data = res.json()\n",
    "    if 'status' not in data.keys():\n",
    "        sys.stderr.write( f\"Unexpected response: {data}\\n\" )\n",
    "    elif data['status'] == 'error':\n",
    "        sys.stderr.write( f\"Got an error: {data['error']}\\n\" )\n",
    "    elif data['status'] != 'ok':\n",
    "        sys.stderr.write( f\"status is {data['status']} and I don't know how to cope.\\n\" )\n",
    "    else:\n",
    "        queryid = data['queryid']\n",
    "        print( f\"Submitted query {queryid}\" )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d65ae09-5d86-45c4-be06-ef4cf6233be6",
   "metadata": {},
   "source": [
    "## Checking the status of your query\n",
    "\n",
    "POST to `db/checksqlquery/<queryid>/`, where `<queryid>` is the id you got back above.  If all is well, the response will have status code 200, and the response body will be a JSON-encoded dictionary, call it `resdict`.  `resdict['status']` will have one of the following values:\n",
    "* `queued` : your query is waiting to run\n",
    "* `started` : your query has started, but not finished\n",
    "* `finished` : your query is finished\n",
    "* `error` : something went wrong, perhaps an SQL error.  Look at `resdict['error']`, there may be something helpful there.\n",
    "\n",
    "Repeat this until you get a finished or error status.  Don't do this in a rapid `while` loop!  You shouldn't post to this API more than once a minute.  The backend process that actually performs the queries only looks for things to do once a minute, so in the best case it will take up to a minute for your query to start.  Once your query has started, if you expect it to finish in less than a minute or so, you would have been better off using the fast query interface described above.  Really, what you should so is submit your query, and then go get a cup of coffee, or sleep for the night, or go on a vacation to Paris.  When you're back, check to see if the query is done.  (Then, fix the typo in your SQL and repeat the process, including the vacation.)\n",
    "\n",
    "If after a long time your query is not started, it's possible that the back-end process that actually makes these queries is not running.  There's no easy way to diagnose that other than talking to Rob (e.g. on Slack).  It's also possible that somebody else has submitted a really long query, and your query is waiting.  At the moment, only a single query can run at once, but if there are problems, I'll run multiple processes so we can have multiple queries running at once.\n",
    "\n",
    "If your query has started, but not finished, nor errored out, it's possible that something went wrong that failed to generate an error message; you should only suspect this if there has been ample time to run your query (which could be a lot of time).  There's no easy way to diagnose this other than bugging Rob.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e6964f01-4fbe-4d6b-ad0e-a8e78f82c776",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Query was submitted: 2024-04-25T16:55:27.539971+00:00\n",
      "Sequence of queries to run:\n",
      "    SELECT * FROM elasticc2_ppdbdiaobject   {}\n",
      "Status of query is: finished\n",
      "Query started: 2024-04-25T16:55:42.252463+00:00\n",
      "Query finished: 2024-04-25T17:00:34.672105+00:00\n"
     ]
    }
   ],
   "source": [
    "# Check the query status to see if the query is done.  Keep rerunning\n",
    "# this until you see the query is done.\n",
    "\n",
    "res = tomclient.post( f'db/checksqlquery/{queryid}/' )\n",
    "if res.status_code != 200:\n",
    "    sys.stderr.write( f\"ERROR, got status {res.status_code}\\n\" )\n",
    "else:\n",
    "    data = res.json()\n",
    "    status = data['status']\n",
    "    \n",
    "    if status == 'error':\n",
    "        print( f\"Got error response\\n{json.dumps(data,indent=2)}\" )\n",
    "    else:\n",
    "        submittime = data['submitted']\n",
    "        queries = data['queries']\n",
    "        subdicts = data['subdicts']\n",
    "\n",
    "        print( f\"Query was submitted: {submittime}\" )\n",
    "        print( f\"Sequence of queries to run:\" )\n",
    "        for q, s in zip( queries, subdicts ):\n",
    "            print( f\"    {q}   {s}\" )\n",
    "        print( f\"Status of query is: {status}\" )\n",
    "\n",
    "        if ( status == 'started' ) or ( status == 'finished' ):\n",
    "            print( f\"Query started: {data['started']}\" )\n",
    "        if status == \"finished\":\n",
    "            print( f\"Query finished: {data['finished']}\" )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "729ba3df-d54b-4cba-86ef-68de47038374",
   "metadata": {},
   "source": [
    "## Reading the results\n",
    "\n",
    "POST to URL `db/getsqlqueryresults/<queryid>/`.  If things go wrong, the response will have a status code of 500 (probably).  If the status code is 200, you'll get back either `text/csv` with the contents of the CSV file in `resp.text` (assuming `resp` is the variable where you stored the return value of your call to TomClient.post()), or `application/octest-stream` with a binary blob in `resp.contents`.  What you get depends on the format you asked for when you submitted the query.\n",
    "\n",
    "If you get back a `csv`, you can make an `io.StringIO` object, feeding it `resp.text`.  Pass that to `pandas.read_csv`, and you'll get a DataFrame.  This is what happens in the example below.\n",
    "\n",
    "If you get back a binary blob, and you asked for pandas format, then you could initialize a `io.BytesIO` object with `resp.content`.  Feed that `BytesIO` object to `pandas.read_pickle()`, and viola, you should have a DataFrame with the results of your query.\n",
    "\n",
    "(It's possible that the pickle read will fail if the pandas/python version you're running is sufficiently differet from the one running on the TOM server.)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "933f9190-296c-42ca-ac95-6da8ccccaa97",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Posting at 2024-04-25T10:10:43.406423\n",
      "Importing at 2024-04-25T10:10:56.940814\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Unnamed: 0</th>\n",
       "      <th>diaobject_id</th>\n",
       "      <th>simversion</th>\n",
       "      <th>ra</th>\n",
       "      <th>decl</th>\n",
       "      <th>mwebv</th>\n",
       "      <th>mwebv_err</th>\n",
       "      <th>z_final</th>\n",
       "      <th>z_final_err</th>\n",
       "      <th>hostgal_ellipticity</th>\n",
       "      <th>...</th>\n",
       "      <th>hostgal2_ra</th>\n",
       "      <th>hostgal2_dec</th>\n",
       "      <th>hostgal2_snsep</th>\n",
       "      <th>hostgal2_magerr_u</th>\n",
       "      <th>hostgal2_magerr_g</th>\n",
       "      <th>hostgal2_magerr_r</th>\n",
       "      <th>hostgal2_magerr_i</th>\n",
       "      <th>hostgal2_magerr_z</th>\n",
       "      <th>hostgal2_magerr_y</th>\n",
       "      <th>isddf</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>47689198</td>\n",
       "      <td>20231017</td>\n",
       "      <td>309.075402</td>\n",
       "      <td>-51.439603</td>\n",
       "      <td>0.023297</td>\n",
       "      <td>0.001165</td>\n",
       "      <td>0.021997</td>\n",
       "      <td>0.06511</td>\n",
       "      <td>0.3727</td>\n",
       "      <td>...</td>\n",
       "      <td>-999.0</td>\n",
       "      <td>-999.0</td>\n",
       "      <td>-9.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>135213180</td>\n",
       "      <td>20231017</td>\n",
       "      <td>190.347900</td>\n",
       "      <td>-11.042899</td>\n",
       "      <td>0.037242</td>\n",
       "      <td>0.001862</td>\n",
       "      <td>0.023652</td>\n",
       "      <td>0.06511</td>\n",
       "      <td>-9999.0000</td>\n",
       "      <td>...</td>\n",
       "      <td>-999.0</td>\n",
       "      <td>-999.0</td>\n",
       "      <td>-9.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>4801027</td>\n",
       "      <td>20231017</td>\n",
       "      <td>200.443806</td>\n",
       "      <td>-15.984347</td>\n",
       "      <td>0.060404</td>\n",
       "      <td>0.003020</td>\n",
       "      <td>0.023543</td>\n",
       "      <td>0.06511</td>\n",
       "      <td>-9999.0000</td>\n",
       "      <td>...</td>\n",
       "      <td>-999.0</td>\n",
       "      <td>-999.0</td>\n",
       "      <td>-9.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>89581103</td>\n",
       "      <td>20231017</td>\n",
       "      <td>348.996243</td>\n",
       "      <td>-57.294989</td>\n",
       "      <td>0.014253</td>\n",
       "      <td>0.000713</td>\n",
       "      <td>1.390210</td>\n",
       "      <td>1.38814</td>\n",
       "      <td>0.6308</td>\n",
       "      <td>...</td>\n",
       "      <td>-999.0</td>\n",
       "      <td>-999.0</td>\n",
       "      <td>-9.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>46630002</td>\n",
       "      <td>20231017</td>\n",
       "      <td>270.310224</td>\n",
       "      <td>-29.040784</td>\n",
       "      <td>0.794051</td>\n",
       "      <td>0.039703</td>\n",
       "      <td>0.576428</td>\n",
       "      <td>0.60311</td>\n",
       "      <td>0.4358</td>\n",
       "      <td>...</td>\n",
       "      <td>-999.0</td>\n",
       "      <td>-999.0</td>\n",
       "      <td>-9.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4119317</th>\n",
       "      <td>4119317</td>\n",
       "      <td>52330434</td>\n",
       "      <td>20231017</td>\n",
       "      <td>62.112554</td>\n",
       "      <td>-17.085374</td>\n",
       "      <td>0.019704</td>\n",
       "      <td>0.000985</td>\n",
       "      <td>-9.000000</td>\n",
       "      <td>-9.00000</td>\n",
       "      <td>-9999.0000</td>\n",
       "      <td>...</td>\n",
       "      <td>-999.0</td>\n",
       "      <td>-999.0</td>\n",
       "      <td>-9.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4119318</th>\n",
       "      <td>4119318</td>\n",
       "      <td>30275730</td>\n",
       "      <td>20231017</td>\n",
       "      <td>60.872780</td>\n",
       "      <td>-8.803361</td>\n",
       "      <td>0.037803</td>\n",
       "      <td>0.001890</td>\n",
       "      <td>-9.000000</td>\n",
       "      <td>-9.00000</td>\n",
       "      <td>-9999.0000</td>\n",
       "      <td>...</td>\n",
       "      <td>-999.0</td>\n",
       "      <td>-999.0</td>\n",
       "      <td>-9.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4119319</th>\n",
       "      <td>4119319</td>\n",
       "      <td>1660527</td>\n",
       "      <td>20231017</td>\n",
       "      <td>161.589301</td>\n",
       "      <td>-58.121086</td>\n",
       "      <td>0.846858</td>\n",
       "      <td>0.042343</td>\n",
       "      <td>-9.000000</td>\n",
       "      <td>-9.00000</td>\n",
       "      <td>-9999.0000</td>\n",
       "      <td>...</td>\n",
       "      <td>-999.0</td>\n",
       "      <td>-999.0</td>\n",
       "      <td>-9.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4119320</th>\n",
       "      <td>4119320</td>\n",
       "      <td>94612614</td>\n",
       "      <td>20231017</td>\n",
       "      <td>108.423938</td>\n",
       "      <td>-29.449632</td>\n",
       "      <td>0.141966</td>\n",
       "      <td>0.007098</td>\n",
       "      <td>-9.000000</td>\n",
       "      <td>-9.00000</td>\n",
       "      <td>-9999.0000</td>\n",
       "      <td>...</td>\n",
       "      <td>-999.0</td>\n",
       "      <td>-999.0</td>\n",
       "      <td>-9.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4119321</th>\n",
       "      <td>4119321</td>\n",
       "      <td>22627766</td>\n",
       "      <td>20231017</td>\n",
       "      <td>162.880233</td>\n",
       "      <td>-13.802104</td>\n",
       "      <td>0.046654</td>\n",
       "      <td>0.002333</td>\n",
       "      <td>-9.000000</td>\n",
       "      <td>-9.00000</td>\n",
       "      <td>-9999.0000</td>\n",
       "      <td>...</td>\n",
       "      <td>-999.0</td>\n",
       "      <td>-999.0</td>\n",
       "      <td>-9.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>999.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>4119322 rows × 74 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "         Unnamed: 0  diaobject_id  simversion          ra       decl  \\\n",
       "0                 0      47689198    20231017  309.075402 -51.439603   \n",
       "1                 1     135213180    20231017  190.347900 -11.042899   \n",
       "2                 2       4801027    20231017  200.443806 -15.984347   \n",
       "3                 3      89581103    20231017  348.996243 -57.294989   \n",
       "4                 4      46630002    20231017  270.310224 -29.040784   \n",
       "...             ...           ...         ...         ...        ...   \n",
       "4119317     4119317      52330434    20231017   62.112554 -17.085374   \n",
       "4119318     4119318      30275730    20231017   60.872780  -8.803361   \n",
       "4119319     4119319       1660527    20231017  161.589301 -58.121086   \n",
       "4119320     4119320      94612614    20231017  108.423938 -29.449632   \n",
       "4119321     4119321      22627766    20231017  162.880233 -13.802104   \n",
       "\n",
       "            mwebv  mwebv_err   z_final  z_final_err  hostgal_ellipticity  ...  \\\n",
       "0        0.023297   0.001165  0.021997      0.06511               0.3727  ...   \n",
       "1        0.037242   0.001862  0.023652      0.06511           -9999.0000  ...   \n",
       "2        0.060404   0.003020  0.023543      0.06511           -9999.0000  ...   \n",
       "3        0.014253   0.000713  1.390210      1.38814               0.6308  ...   \n",
       "4        0.794051   0.039703  0.576428      0.60311               0.4358  ...   \n",
       "...           ...        ...       ...          ...                  ...  ...   \n",
       "4119317  0.019704   0.000985 -9.000000     -9.00000           -9999.0000  ...   \n",
       "4119318  0.037803   0.001890 -9.000000     -9.00000           -9999.0000  ...   \n",
       "4119319  0.846858   0.042343 -9.000000     -9.00000           -9999.0000  ...   \n",
       "4119320  0.141966   0.007098 -9.000000     -9.00000           -9999.0000  ...   \n",
       "4119321  0.046654   0.002333 -9.000000     -9.00000           -9999.0000  ...   \n",
       "\n",
       "         hostgal2_ra  hostgal2_dec  hostgal2_snsep  hostgal2_magerr_u  \\\n",
       "0             -999.0        -999.0            -9.0              999.0   \n",
       "1             -999.0        -999.0            -9.0              999.0   \n",
       "2             -999.0        -999.0            -9.0              999.0   \n",
       "3             -999.0        -999.0            -9.0              999.0   \n",
       "4             -999.0        -999.0            -9.0              999.0   \n",
       "...              ...           ...             ...                ...   \n",
       "4119317       -999.0        -999.0            -9.0              999.0   \n",
       "4119318       -999.0        -999.0            -9.0              999.0   \n",
       "4119319       -999.0        -999.0            -9.0              999.0   \n",
       "4119320       -999.0        -999.0            -9.0              999.0   \n",
       "4119321       -999.0        -999.0            -9.0              999.0   \n",
       "\n",
       "         hostgal2_magerr_g  hostgal2_magerr_r  hostgal2_magerr_i  \\\n",
       "0                    999.0              999.0              999.0   \n",
       "1                    999.0              999.0              999.0   \n",
       "2                    999.0              999.0              999.0   \n",
       "3                    999.0              999.0              999.0   \n",
       "4                    999.0              999.0              999.0   \n",
       "...                    ...                ...                ...   \n",
       "4119317              999.0              999.0              999.0   \n",
       "4119318              999.0              999.0              999.0   \n",
       "4119319              999.0              999.0              999.0   \n",
       "4119320              999.0              999.0              999.0   \n",
       "4119321              999.0              999.0              999.0   \n",
       "\n",
       "         hostgal2_magerr_z  hostgal2_magerr_y  isddf  \n",
       "0                    999.0              999.0  False  \n",
       "1                    999.0              999.0  False  \n",
       "2                    999.0              999.0  False  \n",
       "3                    999.0              999.0  False  \n",
       "4                    999.0              999.0  False  \n",
       "...                    ...                ...    ...  \n",
       "4119317              999.0              999.0  False  \n",
       "4119318              999.0              999.0  False  \n",
       "4119319              999.0              999.0  False  \n",
       "4119320              999.0              999.0  False  \n",
       "4119321              999.0              999.0  False  \n",
       "\n",
       "[4119322 rows x 74 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Done at 2024-04-25T10:11:26.431118\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "35"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# If the query is finished, we can get the results.  In this case, we asked\n",
    "#  for a csv file, but it's probably more efficient to ask for a pickled\n",
    "#  pandas file.\n",
    "\n",
    "sys.stderr.write( f\"Posting at {datetime.datetime.now().isoformat()}\\n\" )\n",
    "res = tomclient.post( f'db/getsqlqueryresults/{queryid}/' )\n",
    "if res.status_code != 200:\n",
    "    sys.stderr.write( f\"ERROR, got status {res.status_code}; look at res.text\" )\n",
    "else:\n",
    "    sys.stderr.write( f\"Importing at {datetime.datetime.now().isoformat()}\\n\" )\n",
    "    sio = io.StringIO( res.text )\n",
    "    df = pandas.read_csv( sio )\n",
    "    # Free up memory\n",
    "    sio = None\n",
    "    res = None\n",
    "    display(df)\n",
    "sys.stderr.write( f\"Done at {datetime.datetime.now().isoformat()}\\n\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e5e2b79b-86c0-41a7-82b7-16e3a71a1b4b",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "NERSC Python",
   "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}