Db2 Jupyter Extensions Tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Db2 Jupyter Notebook Extensions Tutorial\n",
    "\n",
    "The SQL code tutorials for Db2 rely on a Jupyter notebook extension, commonly refer to as a \"magic\" command. The beginning of all of the notebooks begin with the following command which will load the extension and allow the remainder of the notebook to use the %sql magic command.\n",
    "<pre>\n",
    "&#37;run db2.ipynb\n",
    "</pre>\n",
    "The cell below will load the Db2 extension. Note that it will take a few seconds for the extension to load, so you should generally wait until the \"Db2 Extensions Loaded\" message is displayed in your notebook. In the event you get an error on the load of the ibm_db library, modify the command to include the -update option:\n",
    "```\n",
    "run db2.ipynb -update\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%run db2.ipynb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Connections to Db2\n",
    "\n",
    "Before any SQL commands can be issued, a connection needs to be made to the Db2 database that you will be using. The connection can be done manually (through the use of the CONNECT command), or automatically when the first `%sql` command is issued.\n",
    "\n",
    "The Db2 magic command tracks whether or not a connection has occured in the past and saves this information between notebooks and sessions. When you start up a notebook and issue a command, the program will reconnect to the database using your credentials from the last session. In the event that you have not connected before, the system will prompt you for all the information it needs to connect. This information includes:\n",
    "\n",
    "- Database name (SAMPLE) \n",
    "- Hostname - localhost (enter an IP address if you need to connect to a remote server) \n",
    "- PORT - 50000 (this is the default but it could be different) \n",
    "- Userid - DB2INST1 \n",
    "- Password - No password is provided so you have to enter a value \n",
    "- Maximum Rows - 10 lines of output are displayed when a result set is returned \n",
    "\n",
    "There will be default values presented in the panels that you can accept, or enter your own values. All of the information will be stored in the directory that the notebooks are stored on. Once you have entered the information, the system will attempt to connect to the database for you and then you can run all of the SQL scripts. More details on the CONNECT syntax will be found in a section below.\n",
    "\n",
    "The next statement will force a CONNECT to occur with the default values. If you have not connected before, it will prompt you for the information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%sql CONNECT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Line versus Cell Command\n",
    "The Db2 extension is made up of one magic command that works either at the LINE level (`%sql`) or at the CELL level (`%%sql`). If you only want to execute a SQL command on one line in your script, use the %sql form of the command. If you want to run a larger block of SQL, then use the `%%sql` form. Note that when you use the `%%sql` form of the command, the entire contents of the cell is considered part of the command, so you cannot mix other commands in the cell.\n",
    "\n",
    "The following is an example of a line command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%sql VALUES 'HELLO THERE'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have SQL that requires multiple lines, of if you need to execute many lines of SQL, then you should \n",
    "be using the CELL version of the `%sql` command. To start a block of SQL, start the cell with `%%sql` and do not place any SQL following the command. Subsequent lines can contain SQL code, with each SQL statement delimited with the semicolon (`;`). You can change the delimiter if required for procedures, etc... More details on this later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%sql\n",
    "VALUES\n",
    "  1,\n",
    "  2,\n",
    "  3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you are using a single statement then there is no need to use a delimiter. However, if you are combining a number of commands then you must use the semicolon."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%sql\n",
    "DROP TABLE STUFF;\n",
    "CREATE TABLE STUFF (A INT);\n",
    "INSERT INTO STUFF VALUES\n",
    "  1,2,3;\n",
    "SELECT * FROM STUFF;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The script will generate messages and output as it executes. Each SQL statement that generates results will have a table displayed with the result set. If a command is executed, the results of the execution get listed as well. The script you just ran probably generated an error on the DROP table command."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Options\n",
    "Both forms of the `%sql` command have options that can be used to change the behavior of the code. For both forms of the command (`%sql`, `%%sql`), the options must be on the same line as the command:\n",
    "<pre>\n",
    "%sql -t ...\n",
    "%%sql -t\n",
    "</pre>\n",
    "\n",
    "The only difference is that the `%sql` command can have SQL following the parameters, while the `%%sql` requires the SQL to be placed on subsequent lines.\n",
    "\n",
    "There are a number of parameters that you can specify as part of the `%sql` statement. \n",
    "\n",
    "* -d - Use alternative delimiter\n",
    "* -t - Time the statement execution\n",
    "* -q - Suppress messages \n",
    "* -j - JSON formatting of a column\n",
    "* -a - Show all output\n",
    "* -pb - Bar chart of results\n",
    "* -pp - Pie chart of results \n",
    "* -pl - Line chart of results\n",
    "* -i - Interactive mode with Pixiedust\n",
    "* -sampledata Load the database with the sample EMPLOYEE and DEPARTMENT tables\n",
    "* -r - Return the results into a variable (list of rows)\n",
    "\n",
    "Multiple parameters are allowed on a command line. Each option should be separated by a space:\n",
    "<pre>\n",
    "%sql -a -j ...\n",
    "</pre>\n",
    "\n",
    "A SELECT statement will return the results as a dataframe and display the results as a table in the notebook. If you use the assignment statement, the dataframe will be placed into the variable and the results will not be displayed:\n",
    "<pre>\n",
    "r = %sql SELECT * FROM EMPLOYEE\n",
    "</pre>\n",
    "\n",
    "The sections below will explain the options in more detail."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Delimiters\n",
    "The default delimiter for all SQL statements is the semicolon. However, this becomes a problem when you try to create a trigger, function, or procedure that uses SQLPL (or PL/SQL). Use the -d option to turn the SQL delimiter into the at (`@`) sign and -q to suppress error messages. The semi-colon is then ignored as a delimiter.\n",
    "\n",
    "For example, the following SQL will use the `@` sign as the delimiter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%sql -d -q\n",
    "DROP TABLE STUFF\n",
    "@\n",
    "CREATE TABLE STUFF (A INT)\n",
    "@\n",
    "INSERT INTO STUFF VALUES\n",
    "  1,2,3\n",
    "@\n",
    "SELECT * FROM STUFF\n",
    "@"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The delimiter change will only take place for the statements following the `%%sql` command. Subsequent cells\n",
    "in the notebook will still use the semicolon. You must use the -d option for every cell that needs to use the\n",
    "semicolon in the script."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Limiting Result Sets\n",
    "The default number of rows displayed for any result set is 10. You have the option of changing this option when initially connecting to the database. If you want to override the number of rows display you can either update\n",
    "the control variable, or use the -a option. The -a option will display all of the rows in the answer set. For instance, the following SQL will only show 10 rows even though we inserted 15 values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%sql values 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will notice that the displayed result will split the visible rows to the first 5 rows and the last 5 rows.\n",
    "Using the -a option will display all values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%sql -a values 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To change the default value of rows displayed, you can either do a CONNECT RESET (discussed later) or set the\n",
    "Db2 control variable maxrows to a different value. A value of -1 will display all rows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Save previous version of maximum rows\n",
    "last_max = _settings['maxrows']\n",
    "_settings['maxrows'] = 5\n",
    "%sql values 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A special note regarding the output from a SELECT statement. If the SQL statement is the last line of a block, the results will be displayed by default (unless you assigned the results to a variable). If the SQL is in the middle of a block of statements, the results will not be displayed. To explicitly display the results you must use the display function (or pDisplay if you have imported another library like pixiedust which overrides the pandas display function). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Set the maximum back\n",
    "_settings['maxrows'] = last_max\n",
    "%sql values 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quiet Mode\n",
    "Every SQL statement will result in some output. You will either get an answer set (SELECT), or an indication if\n",
    "the command worked. For instance, the following set of SQL will generate some error messages since the tables \n",
    "will probably not exist:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%sql\n",
    "DROP TABLE TABLE_NOT_FOUND;\n",
    "DROP TABLE TABLE_SPELLED_WRONG;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you know that these errors may occur you can silence them with the -q option."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%sql -q\n",
    "DROP TABLE TABLE_NOT_FOUND;\n",
    "DROP TABLE TABLE_SPELLED_WRONG;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SQL output will not be suppressed, so the following command will still show the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%sql -q\n",
    "DROP TABLE TABLE_NOT_FOUND;\n",
    "DROP TABLE TABLE_SPELLED_WRONG;\n",
    "VALUES 1,2,3;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables in %sql Blocks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `%sql` syntax allows you to pass local variables to a script. There are 5 predefined variables defined in the program:\n",
    "\n",
    "- database - The name of the database you are connected to\n",
    "- uid - The userid that you connected with\n",
    "- host = The IP address of the host system\n",
    "- port - The port number of the host system\n",
    "- max - The maximum number of rows to return in an answer set\n",
    "\n",
    "These variables are all part of a structure called _settings. To pass a value to a LINE script, use the braces {} to surround the name of the variable:\n",
    "\n",
    "<pre>\n",
    "   {_settings[\"database\"]}\n",
    "</pre>\n",
    "\n",
    "The next line will display the currently connected database."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%sql VALUES '{_settings[\"database\"]}'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You cannot use variable substitution with the CELL version of the `%%sql` command. If your SQL statement extends beyond one line, and you want to use variable substitution, you can use a couple of techniques to make it look like one line. The simplest way is to add the backslash character (```\\```) at the end of every line.  The following example illustrates the technique."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "empno = '000010'\n",
    "%sql SELECT LASTNAME FROM \\\n",
    "       EMPLOYEE \\\n",
    "     WHERE \\\n",
    "       EMPNO = '{empno}'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The other option for passing variables to a `%sql` or `%%sql` statement is to use the embedded variable format. This requires that the variable be prefixed with a colon (`:`) in front of it. When using this format, you do not need to use quote characters around the variables since its value is extracted at run time. The first example uses the value of the variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "empno = '000010'\n",
    "%sql select lastname from employee where empno='{empno}'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This example uses the embedded variable name (`:empno`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%sql select lastname from employee where empno=:empno"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Timing SQL Statements\n",
    "Sometimes you want to see how the execution of a statement changes with the addition of indexes or other\n",
    "optimization changes. The -t option will run the statement on the LINE or one SQL statement in the CELL for \n",
    "exactly one second. The results will be displayed and optionally placed into a variable. The syntax of the\n",
    "command is:\n",
    "<pre>\n",
    "sql_time = %sql -t SELECT * FROM EMPLOYEE\n",
    "</pre>\n",
    "For instance, the following SQL will time the VALUES clause."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%sql -t VALUES 1,2,3,4,5,6,7,8,9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When timing a statement, no output will be displayed. If your SQL statement takes longer than one second you\n",
    "will need to modify the db2 _runtime variable. This variable must be set to the number of seconds that you\n",
    "want to run the statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "_runtime = 5\n",
    "%sql -t VALUES 1,2,3,4,5,6,7,8,9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## JSON Formatting\n",
    "Db2 supports querying JSON that is stored in a column within a table. Standard output would just display the \n",
    "JSON as a string. For instance, the following statement would just return a large string of output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%sql\n",
    "VALUES \n",
    "      '{\n",
    "      \"empno\":\"000010\",\n",
    "      \"firstnme\":\"CHRISTINE\",\n",
    "      \"midinit\":\"I\",\n",
    "      \"lastname\":\"HAAS\",\n",
    "      \"workdept\":\"A00\",\n",
    "      \"phoneno\":[3978],\n",
    "      \"hiredate\":\"01/01/1995\",\n",
    "      \"job\":\"PRES\",\n",
    "      \"edlevel\":18,\n",
    "      \"sex\":\"F\",\n",
    "      \"birthdate\":\"08/24/1963\",\n",
    "      \"pay\" : {\n",
    "        \"salary\":152750.00,\n",
    "        \"bonus\":1000.00,\n",
    "        \"comm\":4220.00}\n",
    "      }'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding the -j option to the %sql (or %%sql) command will format the first column of a return set to better\n",
    "display the structure of the document. Note that if your answer set has additional columns associated with it, they will not be displayed in this format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%sql -j\n",
    "VALUES \n",
    "      '{\n",
    "      \"empno\":\"000010\",\n",
    "      \"firstnme\":\"CHRISTINE\",\n",
    "      \"midinit\":\"I\",\n",
    "      \"lastname\":\"HAAS\",\n",
    "      \"workdept\":\"A00\",\n",
    "      \"phoneno\":[3978],\n",
    "      \"hiredate\":\"01/01/1995\",\n",
    "      \"job\":\"PRES\",\n",
    "      \"edlevel\":18,\n",
    "      \"sex\":\"F\",\n",
    "      \"birthdate\":\"08/24/1963\",\n",
    "      \"pay\" : {\n",
    "        \"salary\":152750.00,\n",
    "        \"bonus\":1000.00,\n",
    "        \"comm\":4220.00}\n",
    "      }'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting\n",
    "Sometimes it would be useful to display a result set as either a bar, pie, or line chart. The first one or two\n",
    "columns of a result set need to contain the values need to plot the information.\n",
    "\n",
    "The three possible plot options are:\n",
    "    \n",
    "* -pb - bar chart (x,y)\n",
    "* -pp - pie chart (y)\n",
    "* -pl - line chart (x,y)\n",
    "\n",
    "The following data will be used to demonstrate the different charting options."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%sql values 1,2,3,4,5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the results only have one column, the pie, line, and bar charts will not have any labels associated with\n",
    "them. The first example is a bar chart."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "pixiedust": {
     "displayParams": {
      "handlerId": "dataframe"
     }
    }
   },
   "outputs": [],
   "source": [
    "%sql -pb values 1,2,3,4,5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same data as a pie chart."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%sql -pp values 1,2,3,4,5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And finally a line chart."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "pixiedust": {
     "displayParams": {
      "handlerId": "dataframe"
     }
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%sql -pl values 1,2,3,4,5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you retrieve two columns of information, the first column is used for the labels (X axis or pie slices) and \n",
    "the second column contains the data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%sql -pb values ('A',1),('B',2),('C',3),('D',4),('E',5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For a pie chart, the first column is used to label the slices, while the data comes from the second column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%sql -pp values ('A',1),('B',2),('C',3),('D',4),('E',5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, for a line chart, the x contains the labels and the y values are used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%sql -pl values ('A',1),('B',2),('C',3),('D',4),('E',5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following SQL will plot the number of employees per department."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%sql -pb\n",
    "SELECT WORKDEPT, COUNT(*) \n",
    "  FROM EMPLOYEE\n",
    "GROUP BY WORKDEPT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The final option for plotting data is to use interactive mode `-i`. This will display the data using an open-source project called Pixiedust. You can view the results in a table and then interactively create a plot by dragging and dropping column names into the appropriate slot. The next command will place you into interactive mode."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "pixiedust": {
     "displayParams": {
      "handlerId": "dataframe"
     }
    }
   },
   "outputs": [],
   "source": [
    "%sql -i select * from employee"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sample Data\n",
    "Many of the Db2 notebooks depend on two of the tables that are found in the SAMPLE database. Rather than\n",
    "having to create the entire SAMPLE database, this option will create and populate the EMPLOYEE and \n",
    "DEPARTMENT tables in your database. Note that if you already have these tables defined, they will not be dropped."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%sql -sampledata"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Result Sets \n",
    "By default, any `%sql` block will return the contents of a result set as a table that is displayed in the notebook. The results are displayed using a feature of pandas dataframes. The following select statement demonstrates a simple result set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%sql select * from employee fetch first 3 rows only"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can assign the result set directly to a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = %sql select * from employee fetch first 3 rows only"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The variable x contains the dataframe that was produced by the `%sql` statement so you access the result set by using this variable or display the contents by just referring to it in a command line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is an additional way of capturing the data through the use of the `-r` flag.\n",
    "<pre>\n",
    "var = %sql -r select * from employee\n",
    "</pre>\n",
    "Rather than returning a dataframe result set, this option will produce a list of rows. Each row is a list itself. The rows and columns all start at zero (0), so to access the first column of the first row, you would use var[0][0] to access it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "rows = %sql -r select * from employee fetch first 3 rows only\n",
    "print(rows[0][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The number of rows in the result set can be determined by using the length function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(len(rows))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to iterate over all of the rows and columns, you could use the following Python syntax instead of\n",
    "creating a for loop that goes from 0 to 41."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for row in rows:\n",
    "    line = \"\"\n",
    "    for col in row:\n",
    "        line = line + str(col) + \",\"\n",
    "    print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the data may be returned in different formats (like integers), you should use the str() function\n",
    "to convert the values to strings. Otherwise, the concatenation function used in the above example will fail. For\n",
    "instance, the 6th field is a birthdate field. If you retrieve it as an individual value and try and concatenate a string to it, you get the following error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(\"Birth Date=\"+rows[0][6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can fix this problem by adding the str function to convert the date."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(\"Birth Date=\"+str(rows[0][6]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Db2 CONNECT Statement\n",
    "As mentioned at the beginning of this notebook, connecting to Db2 is automatically done when you issue your first\n",
    "`%sql` statement. Usually the program will prompt you with what options you want when connecting to a database. The other option is to use the CONNECT statement directly. The CONNECT statement is similar to the native Db2\n",
    "CONNECT command, but includes some options that allow you to connect to databases that has not been\n",
    "catalogued locally.\n",
    "\n",
    "The CONNECT command has the following format:\n",
    "<pre>\n",
    "%sql CONNECT TO &lt;database&gt; USER &lt;userid&gt; USING &lt;password | ?&gt; HOST &lt;ip address&gt; PORT &lt;port number&gt;\n",
    "</pre>\n",
    "If you use a \"?\" for the password field, the system will prompt you for a password. This avoids typing the \n",
    "password as clear text on the screen. If a connection is not successful, the system will print the error\n",
    "message associated with the connect request.\n",
    "\n",
    "If the connection is successful, the parameters are saved on your system and will be used the next time you\n",
    "run a SQL statement, or when you issue the %sql CONNECT command with no parameters.\n",
    "\n",
    "If you want to force the program to connect to a different database (with prompting), use the CONNECT RESET command. The next time you run a SQL statement, the program will prompt you for the  the connection\n",
    "and will force the program to reconnect the next time a SQL statement is executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%sql CONNECT RESET"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%sql CONNECT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Credits: IBM 2018, George Baklarz [baklarz@ca.ibm.com]"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}