teradataml 17.20.0.7__py3-none-any.whl → 20.0.0.0__py3-none-any.whl

teradataml/data/notebooks/sqlalchemy/teradataml filtering using SQLAlchemy ClauseElements.ipynb

@@ -1,784 +1,784 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Disclaimer\n",
-    "Please note, the Vantage Functions via SQLAlchemy feature is a preview/beta code release with limited functionality (the “Code”). As such, you acknowledge that the Code is experimental in nature and that the Code is provided “AS IS” and may not be functional on any machine or in any environment. TERADATA DISCLAIMS ALL WARRANTIES RELATING TO THE CODE, EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTIES AGAINST INFRINGEMENT OF THIRD-PARTY RIGHTS, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.\n",
-    "\n",
-    "TERADATA SHALL NOT BE RESPONSIBLE OR LIABLE WITH RESPECT TO ANY SUBJECT MATTER OF THE CODE UNDER ANY CONTRACT, NEGLIGENCE, STRICT LIABILITY OR OTHER THEORY \n",
-    "    (A) FOR LOSS OR INACCURACY OF DATA OR COST OF PROCUREMENT OF SUBSTITUTE GOODS, SERVICES OR TECHNOLOGY, OR \n",
-    "    (B) FOR ANY INDIRECT, INCIDENTAL OR CONSEQUENTIAL DAMAGES INCLUDING, BUT NOT LIMITED TO LOSS OF REVENUES AND LOSS OF PROFITS. TERADATA SHALL NOT BE RESPONSIBLE FOR ANY MATTER BEYOND ITS REASONABLE CONTROL.\n",
-    "\n",
-    "Notwithstanding anything to the contrary: \n",
-    "    (a) Teradata will have no obligation of any kind with respect to any Code-related comments, suggestions, design changes or improvements that you elect to provide to Teradata in either verbal or written form (collectively, “Feedback”), and \n",
-    "    (b) Teradata and its affiliates are hereby free to use any ideas, concepts, know-how or techniques, in whole or in part, contained in Feedback: \n",
-    "        (i) for any purpose whatsoever, including developing, manufacturing, and/or marketing products and/or services incorporating Feedback in whole or in part, and \n",
-    "        (ii) without any restrictions or limitations, including requiring the payment of any license fees, royalties, or other consideration. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Hostname: ········\n",
-      "Username: ········\n",
-      "Password: ········\n",
-      "WARNING: Skipped loading table admissions_train since it already exists in the database.\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Get the connection to the Vantage using create_context()\n",
-    "from teradataml import *\n",
-    "import getpass\n",
-    "td_context = create_context(host=getpass.getpass(\"Hostname: \"), username=getpass.getpass(\"Username: \"), password=getpass.getpass(\"Password: \"))\n",
-    "\n",
-    "# Load the example dataset.\n",
-    "load_example_data(\"GLM\", [\"admissions_train\"])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "   masters   gpa     stats programming  admitted\n",
-       "id                                              \n",
-       "15     yes  4.00  Advanced    Advanced         1\n",
-       "7      yes  2.33    Novice      Novice         1\n",
-       "22     yes  3.46    Novice    Beginner         0\n",
-       "17      no  3.83  Advanced    Advanced         1\n",
-       "13      no  4.00  Advanced      Novice         1\n",
-       "38     yes  2.65  Advanced    Beginner         1\n",
-       "26     yes  3.57  Advanced    Advanced         1\n",
-       "5       no  3.44    Novice      Novice         0\n",
-       "34     yes  3.85  Advanced    Beginner         0\n",
-       "40     yes  3.95    Novice    Beginner         0"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Create the DataFrame on 'admissions_train' table\n",
-    "admissions_train = DataFrame(\"admissions_train\")\n",
-    "admissions_train"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Helper function to print some details of dataframe.\n",
-    "def print_dataframe(df):\n",
-    "    print(\"Equivalent SQL: {}\".format(df.show_query()))\n",
-    "    print(\"\\n\")\n",
-    "    print(\" ************************* DataFrame ********************* \")\n",
-    "    print(df)\n",
-    "    print(\"\\n\\n\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Before we move on with examples, one should read below just to understand how teradataml DataFrame and \n",
-    "# it's columns are used to create a SQLAlchemy ClauseElement/Expression.\n",
-    "\n",
-    "# Often in below examples one would see something like this: 'admissions_train.admitted.expression'\n",
-    "# Here in the above expression,\n",
-    "#    'admissions_train' is 'teradataml DataFrame'\n",
-    "#    'admitted' is 'column name' in teradataml DataFrame 'admissions_train'\n",
-    "#    Thus, \n",
-    "#        'admissions_train.admitted' together forms a ColumnExpression.\n",
-    "#    expression allows us to use teradata ColumnExpression to be treated as SQLAlchemy Expression.\n",
-    "#    Thus,\n",
-    "#        'admissions_train.admitted.expression' gives us an expression that can be used with SQLAlchemy clauseElements."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Using SQLAlchemy 'case' to filter rows in teradataml"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "sqlalchemy.sql.elements.Case"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Using SQLAlchemy case expression. \n",
-    "# Form a CASE object that returns 1 for cases where masters value is \"yes\", otherwise return 0.\n",
-    "from sqlalchemy import case\n",
-    "\n",
-    "caseobj = case(\n",
-    "    \n",
-    "        (admissions_train.masters.expression == \"yes\", 1)\n",
-    "    ,\n",
-    "    else_=0\n",
-    ")\n",
-    "type(caseobj)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select * from \"admissions_train\" where admitted = CASE WHEN (masters = 'yes') THEN 1 ELSE 0 END\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   masters   gpa     stats programming  admitted\n",
-      "id                                              \n",
-      "31     yes  3.50  Advanced    Beginner         1\n",
-      "23     yes  3.59  Advanced      Novice         1\n",
-      "7      yes  2.33    Novice      Novice         1\n",
-      "4      yes  3.50  Beginner      Novice         1\n",
-      "26     yes  3.57  Advanced    Advanced         1\n",
-      "5       no  3.44    Novice      Novice         0\n",
-      "20     yes  3.90  Advanced    Advanced         1\n",
-      "18     yes  3.81  Advanced    Advanced         1\n",
-      "38     yes  2.65  Advanced    Beginner         1\n",
-      "6      yes  3.50  Beginner    Advanced         1\n",
-      "\n",
-      "\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Filter the results where admitted is 1 and masters is 'yes'. This is being done with the help of CASE object created above.\n",
-    "df = admissions_train[admissions_train.admitted == caseobj]\n",
-    "print_dataframe(df)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Using SQLAlchemy 'between' to filter rows in teradataml"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "sqlalchemy.sql.elements.BinaryExpression"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Example for using between, to filter the rows where GPA is between 3 and 4.\n",
-    "from sqlalchemy import between\n",
-    "between_expr = between(admissions_train.gpa.expression, 3, 4)\n",
-    "type(between_expr)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select * from \"admissions_train\" where gpa BETWEEN 3 AND 4\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   masters   gpa     stats programming  admitted\n",
-      "id                                              \n",
-      "39     yes  3.75  Advanced    Beginner         0\n",
-      "15     yes  4.00  Advanced    Advanced         1\n",
-      "30     yes  3.79  Advanced      Novice         0\n",
-      "26     yes  3.57  Advanced    Advanced         1\n",
-      "3       no  3.70    Novice    Beginner         1\n",
-      "17      no  3.83  Advanced    Advanced         1\n",
-      "34     yes  3.85  Advanced    Beginner         0\n",
-      "13      no  4.00  Advanced      Novice         1\n",
-      "5       no  3.44    Novice      Novice         0\n",
-      "36      no  3.00  Advanced      Novice         0\n",
-      "\n",
-      "\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Use SQLAlchemy BinaryExpression for 'between' created above to filter rows.\n",
-    "df = admissions_train[between_expr]\n",
-    "print_dataframe(df)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Using SQLAlchemy 'IN' and 'NOT IN' to filter rows in teradataml"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "sqlalchemy.sql.elements.BinaryExpression"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Filter row to get the results where stats are either 'Novice' or 'Beginner'\n",
-    "in_expr = admissions_train.stats.expression.in_([\"Novice\", \"Beginner\"])\n",
-    "type(in_expr)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select * from \"admissions_train\" where stats IN ('Novice', 'Beginner')\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   masters   gpa     stats programming  admitted\n",
-      "id                                              \n",
-      "21      no  3.87    Novice    Beginner         1\n",
-      "5       no  3.44    Novice      Novice         0\n",
-      "3       no  3.70    Novice    Beginner         1\n",
-      "1      yes  3.95  Beginner    Beginner         0\n",
-      "7      yes  2.33    Novice      Novice         1\n",
-      "22     yes  3.46    Novice    Beginner         0\n",
-      "40     yes  3.95    Novice    Beginner         0\n",
-      "33      no  3.55    Novice      Novice         1\n",
-      "6      yes  3.50  Beginner    Advanced         1\n",
-      "29     yes  4.00    Novice    Beginner         0\n",
-      "\n",
-      "\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Use SQLAlchemy BinaryExpression for 'IN' created above to filter rows.\n",
-    "df = admissions_train[in_expr]\n",
-    "print_dataframe(df)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "sqlalchemy.sql.elements.BinaryExpression"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Filter row to get the results where stats are neither 'Novice' nor 'Beginner'\n",
-    "notin_expr = admissions_train.stats.expression.notin_([\"Novice\", \"Beginner\"])\n",
-    "type(notin_expr)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select * from \"admissions_train\" where stats NOT IN ('Novice', 'Beginner')\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   masters   gpa     stats programming  admitted\n",
-      "id                                              \n",
-      "19     yes  1.98  Advanced    Advanced         0\n",
-      "15     yes  4.00  Advanced    Advanced         1\n",
-      "38     yes  2.65  Advanced    Beginner         1\n",
-      "26     yes  3.57  Advanced    Advanced         1\n",
-      "17      no  3.83  Advanced    Advanced         1\n",
-      "34     yes  3.85  Advanced    Beginner         0\n",
-      "13      no  4.00  Advanced      Novice         1\n",
-      "24      no  1.87  Advanced      Novice         1\n",
-      "36      no  3.00  Advanced      Novice         0\n",
-      "27     yes  3.96  Advanced    Advanced         0\n",
-      "\n",
-      "\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Use SQLAlchemy BinaryExpression for 'NOT IN' created above to filter rows.\n",
-    "df = admissions_train[notin_expr]\n",
-    "print_dataframe(df)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Filtering using LIKE "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "sqlalchemy.sql.elements.BinaryExpression"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Retrieve data where stats are like \"%gin%\"\n",
-    "like_expr = admissions_train.stats.expression.like(\"%gin%\")\n",
-    "type(like_expr)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select * from \"admissions_train\" where stats LIKE '%gin%'\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   masters   gpa     stats programming  admitted\n",
-      "id                                              \n",
-      "8       no  3.60  Beginner    Advanced         1\n",
-      "6      yes  3.50  Beginner    Advanced         1\n",
-      "2      yes  3.76  Beginner    Beginner         0\n",
-      "1      yes  3.95  Beginner    Beginner         0\n",
-      "4      yes  3.50  Beginner      Novice         1\n",
-      "\n",
-      "\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Use SQLAlchemy BinaryExpression for 'LIKE' created above to filter rows.\n",
-    "df = admissions_train[like_expr]\n",
-    "print_dataframe(df)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "sqlalchemy.sql.elements.BinaryExpression"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Example for using NOTLIKE, retrive rows which does not contain string 'ce'\n",
-    "nlike_expr = admissions_train.stats.expression.notlike(\"%ce%\")\n",
-    "type(nlike_expr)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select * from \"admissions_train\" where stats NOT LIKE '%ce%'\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   masters   gpa     stats programming  admitted\n",
-      "id                                              \n",
-      "8       no  3.60  Beginner    Advanced         1\n",
-      "6      yes  3.50  Beginner    Advanced         1\n",
-      "2      yes  3.76  Beginner    Beginner         0\n",
-      "1      yes  3.95  Beginner    Beginner         0\n",
-      "4      yes  3.50  Beginner      Novice         1\n",
-      "\n",
-      "\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Use SQLAlchemy BinaryExpression for 'NOT LIKE' created above to filter rows.\n",
-    "df = admissions_train[nlike_expr]\n",
-    "print_dataframe(df)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "sqlalchemy.sql.elements.BinaryExpression"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Example for using iLIKE - Case insensitive LIKE\n",
-    "ilike_expr = admissions_train.stats.expression.ilike(\"be%NN%r\")\n",
-    "type(ilike_expr)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select * from \"admissions_train\" where lower(stats) LIKE lower('be%NN%r')\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   masters   gpa     stats programming  admitted\n",
-      "id                                              \n",
-      "8       no  3.60  Beginner    Advanced         1\n",
-      "6      yes  3.50  Beginner    Advanced         1\n",
-      "2      yes  3.76  Beginner    Beginner         0\n",
-      "1      yes  3.95  Beginner    Beginner         0\n",
-      "4      yes  3.50  Beginner      Novice         1\n",
-      "\n",
-      "\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Use SQLAlchemy BinaryExpression for 'Case Insensitive LIKE' created above to filter rows.\n",
-    "df = admissions_train[ilike_expr]\n",
-    "print_dataframe(df)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "sqlalchemy.sql.elements.BinaryExpression"
-      ]
-     },
-     "execution_count": 19,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Filter rows starting with \"Beg\"\n",
-    "sw_expr = admissions_train.stats.expression.startswith(\"Beg\")\n",
-    "type(sw_expr)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select * from \"admissions_train\" where stats LIKE 'Beg' || '%'\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   masters   gpa     stats programming  admitted\n",
-      "id                                              \n",
-      "8       no  3.60  Beginner    Advanced         1\n",
-      "6      yes  3.50  Beginner    Advanced         1\n",
-      "2      yes  3.76  Beginner    Beginner         0\n",
-      "1      yes  3.95  Beginner    Beginner         0\n",
-      "4      yes  3.50  Beginner      Novice         1\n",
-      "\n",
-      "\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Use SQLAlchemy BinaryExpression for 'Starts With' created above to filter rows.\n",
-    "df = admissions_train[sw_expr]\n",
-    "print_dataframe(df)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Using IS NULL or IS NOT NULL"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "sqlalchemy.sql.elements.BinaryExpression"
-      ]
-     },
-     "execution_count": 21,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Example for using IS NULL\n",
-    "isnull_expr = admissions_train.stats.expression.is_(None)\n",
-    "type(isnull_expr)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select * from \"admissions_train\" where stats IS NULL\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "Empty DataFrame\n",
-      "Columns: [masters, gpa, stats, programming, admitted]\n",
-      "Index: []\n",
-      "\n",
-      "\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Use SQLAlchemy BinaryExpression for 'IS NULL' created above to filter rows.\n",
-    "df = admissions_train[isnull_expr]\n",
-    "print_dataframe(df)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "sqlalchemy.sql.elements.BinaryExpression"
-      ]
-     },
-     "execution_count": 23,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Example for using IS NOT NULL\n",
-    "isnotnull_expr = admissions_train.stats.expression.isnot(None)\n",
-    "type(isnotnull_expr)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select * from \"admissions_train\" where stats IS NOT NULL\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   masters   gpa     stats programming  admitted\n",
-      "id                                              \n",
-      "15     yes  4.00  Advanced    Advanced         1\n",
-      "7      yes  2.33    Novice      Novice         1\n",
-      "22     yes  3.46    Novice    Beginner         0\n",
-      "17      no  3.83  Advanced    Advanced         1\n",
-      "13      no  4.00  Advanced      Novice         1\n",
-      "38     yes  2.65  Advanced    Beginner         1\n",
-      "26     yes  3.57  Advanced    Advanced         1\n",
-      "5       no  3.44    Novice      Novice         0\n",
-      "34     yes  3.85  Advanced    Beginner         0\n",
-      "40     yes  3.95    Novice    Beginner         0\n",
-      "\n",
-      "\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Use SQLAlchemy BinaryExpression for 'IS NOT NULL' created above to filter rows.\n",
-    "df = admissions_train[isnotnull_expr]\n",
-    "print_dataframe(df)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True"
-      ]
-     },
-     "execution_count": 25,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# One must run remove_context() to close the connection and garbage collect internally generated objects.\n",
-    "remove_context()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.9.16"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Disclaimer\n",
+    "Please note, the Vantage Functions via SQLAlchemy feature is a preview/beta code release with limited functionality (the “Code”). As such, you acknowledge that the Code is experimental in nature and that the Code is provided “AS IS” and may not be functional on any machine or in any environment. TERADATA DISCLAIMS ALL WARRANTIES RELATING TO THE CODE, EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTIES AGAINST INFRINGEMENT OF THIRD-PARTY RIGHTS, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.\n",
+    "\n",
+    "TERADATA SHALL NOT BE RESPONSIBLE OR LIABLE WITH RESPECT TO ANY SUBJECT MATTER OF THE CODE UNDER ANY CONTRACT, NEGLIGENCE, STRICT LIABILITY OR OTHER THEORY \n",
+    "    (A) FOR LOSS OR INACCURACY OF DATA OR COST OF PROCUREMENT OF SUBSTITUTE GOODS, SERVICES OR TECHNOLOGY, OR \n",
+    "    (B) FOR ANY INDIRECT, INCIDENTAL OR CONSEQUENTIAL DAMAGES INCLUDING, BUT NOT LIMITED TO LOSS OF REVENUES AND LOSS OF PROFITS. TERADATA SHALL NOT BE RESPONSIBLE FOR ANY MATTER BEYOND ITS REASONABLE CONTROL.\n",
+    "\n",
+    "Notwithstanding anything to the contrary: \n",
+    "    (a) Teradata will have no obligation of any kind with respect to any Code-related comments, suggestions, design changes or improvements that you elect to provide to Teradata in either verbal or written form (collectively, “Feedback”), and \n",
+    "    (b) Teradata and its affiliates are hereby free to use any ideas, concepts, know-how or techniques, in whole or in part, contained in Feedback: \n",
+    "        (i) for any purpose whatsoever, including developing, manufacturing, and/or marketing products and/or services incorporating Feedback in whole or in part, and \n",
+    "        (ii) without any restrictions or limitations, including requiring the payment of any license fees, royalties, or other consideration. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hostname: ········\n",
+      "Username: ········\n",
+      "Password: ········\n",
+      "WARNING: Skipped loading table admissions_train since it already exists in the database.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Get the connection to the Vantage using create_context()\n",
+    "from teradataml import *\n",
+    "import getpass\n",
+    "td_context = create_context(host=getpass.getpass(\"Hostname: \"), username=getpass.getpass(\"Username: \"), password=getpass.getpass(\"Password: \"))\n",
+    "\n",
+    "# Load the example dataset.\n",
+    "load_example_data(\"GLM\", [\"admissions_train\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "   masters   gpa     stats programming  admitted\n",
+       "id                                              \n",
+       "15     yes  4.00  Advanced    Advanced         1\n",
+       "7      yes  2.33    Novice      Novice         1\n",
+       "22     yes  3.46    Novice    Beginner         0\n",
+       "17      no  3.83  Advanced    Advanced         1\n",
+       "13      no  4.00  Advanced      Novice         1\n",
+       "38     yes  2.65  Advanced    Beginner         1\n",
+       "26     yes  3.57  Advanced    Advanced         1\n",
+       "5       no  3.44    Novice      Novice         0\n",
+       "34     yes  3.85  Advanced    Beginner         0\n",
+       "40     yes  3.95    Novice    Beginner         0"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Create the DataFrame on 'admissions_train' table\n",
+    "admissions_train = DataFrame(\"admissions_train\")\n",
+    "admissions_train"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Helper function to print some details of dataframe.\n",
+    "def print_dataframe(df):\n",
+    "    print(\"Equivalent SQL: {}\".format(df.show_query()))\n",
+    "    print(\"\\n\")\n",
+    "    print(\" ************************* DataFrame ********************* \")\n",
+    "    print(df)\n",
+    "    print(\"\\n\\n\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Before we move on with examples, one should read below just to understand how teradataml DataFrame and \n",
+    "# it's columns are used to create a SQLAlchemy ClauseElement/Expression.\n",
+    "\n",
+    "# Often in below examples one would see something like this: 'admissions_train.admitted.expression'\n",
+    "# Here in the above expression,\n",
+    "#    'admissions_train' is 'teradataml DataFrame'\n",
+    "#    'admitted' is 'column name' in teradataml DataFrame 'admissions_train'\n",
+    "#    Thus, \n",
+    "#        'admissions_train.admitted' together forms a ColumnExpression.\n",
+    "#    expression allows us to use teradata ColumnExpression to be treated as SQLAlchemy Expression.\n",
+    "#    Thus,\n",
+    "#        'admissions_train.admitted.expression' gives us an expression that can be used with SQLAlchemy clauseElements."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Using SQLAlchemy 'case' to filter rows in teradataml"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.Case"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Using SQLAlchemy case expression. \n",
+    "# Form a CASE object that returns 1 for cases where masters value is \"yes\", otherwise return 0.\n",
+    "from sqlalchemy import case\n",
+    "\n",
+    "caseobj = case(\n",
+    "    \n",
+    "        (admissions_train.masters.expression == \"yes\", 1)\n",
+    "    ,\n",
+    "    else_=0\n",
+    ")\n",
+    "type(caseobj)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select * from \"admissions_train\" where admitted = CASE WHEN (masters = 'yes') THEN 1 ELSE 0 END\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted\n",
+      "id                                              \n",
+      "31     yes  3.50  Advanced    Beginner         1\n",
+      "23     yes  3.59  Advanced      Novice         1\n",
+      "7      yes  2.33    Novice      Novice         1\n",
+      "4      yes  3.50  Beginner      Novice         1\n",
+      "26     yes  3.57  Advanced    Advanced         1\n",
+      "5       no  3.44    Novice      Novice         0\n",
+      "20     yes  3.90  Advanced    Advanced         1\n",
+      "18     yes  3.81  Advanced    Advanced         1\n",
+      "38     yes  2.65  Advanced    Beginner         1\n",
+      "6      yes  3.50  Beginner    Advanced         1\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Filter the results where admitted is 1 and masters is 'yes'. This is being done with the help of CASE object created above.\n",
+    "df = admissions_train[admissions_train.admitted == caseobj]\n",
+    "print_dataframe(df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Using SQLAlchemy 'between' to filter rows in teradataml"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.BinaryExpression"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Example for using between, to filter the rows where GPA is between 3 and 4.\n",
+    "from sqlalchemy import between\n",
+    "between_expr = between(admissions_train.gpa.expression, 3, 4)\n",
+    "type(between_expr)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select * from \"admissions_train\" where gpa BETWEEN 3 AND 4\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted\n",
+      "id                                              \n",
+      "39     yes  3.75  Advanced    Beginner         0\n",
+      "15     yes  4.00  Advanced    Advanced         1\n",
+      "30     yes  3.79  Advanced      Novice         0\n",
+      "26     yes  3.57  Advanced    Advanced         1\n",
+      "3       no  3.70    Novice    Beginner         1\n",
+      "17      no  3.83  Advanced    Advanced         1\n",
+      "34     yes  3.85  Advanced    Beginner         0\n",
+      "13      no  4.00  Advanced      Novice         1\n",
+      "5       no  3.44    Novice      Novice         0\n",
+      "36      no  3.00  Advanced      Novice         0\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use SQLAlchemy BinaryExpression for 'between' created above to filter rows.\n",
+    "df = admissions_train[between_expr]\n",
+    "print_dataframe(df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Using SQLAlchemy 'IN' and 'NOT IN' to filter rows in teradataml"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.BinaryExpression"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Filter row to get the results where stats are either 'Novice' or 'Beginner'\n",
+    "in_expr = admissions_train.stats.expression.in_([\"Novice\", \"Beginner\"])\n",
+    "type(in_expr)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select * from \"admissions_train\" where stats IN ('Novice', 'Beginner')\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted\n",
+      "id                                              \n",
+      "21      no  3.87    Novice    Beginner         1\n",
+      "5       no  3.44    Novice      Novice         0\n",
+      "3       no  3.70    Novice    Beginner         1\n",
+      "1      yes  3.95  Beginner    Beginner         0\n",
+      "7      yes  2.33    Novice      Novice         1\n",
+      "22     yes  3.46    Novice    Beginner         0\n",
+      "40     yes  3.95    Novice    Beginner         0\n",
+      "33      no  3.55    Novice      Novice         1\n",
+      "6      yes  3.50  Beginner    Advanced         1\n",
+      "29     yes  4.00    Novice    Beginner         0\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use SQLAlchemy BinaryExpression for 'IN' created above to filter rows.\n",
+    "df = admissions_train[in_expr]\n",
+    "print_dataframe(df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.BinaryExpression"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Filter row to get the results where stats are neither 'Novice' nor 'Beginner'\n",
+    "notin_expr = admissions_train.stats.expression.notin_([\"Novice\", \"Beginner\"])\n",
+    "type(notin_expr)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select * from \"admissions_train\" where stats NOT IN ('Novice', 'Beginner')\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted\n",
+      "id                                              \n",
+      "19     yes  1.98  Advanced    Advanced         0\n",
+      "15     yes  4.00  Advanced    Advanced         1\n",
+      "38     yes  2.65  Advanced    Beginner         1\n",
+      "26     yes  3.57  Advanced    Advanced         1\n",
+      "17      no  3.83  Advanced    Advanced         1\n",
+      "34     yes  3.85  Advanced    Beginner         0\n",
+      "13      no  4.00  Advanced      Novice         1\n",
+      "24      no  1.87  Advanced      Novice         1\n",
+      "36      no  3.00  Advanced      Novice         0\n",
+      "27     yes  3.96  Advanced    Advanced         0\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use SQLAlchemy BinaryExpression for 'NOT IN' created above to filter rows.\n",
+    "df = admissions_train[notin_expr]\n",
+    "print_dataframe(df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Filtering using LIKE "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.BinaryExpression"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Retrieve data where stats are like \"%gin%\"\n",
+    "like_expr = admissions_train.stats.expression.like(\"%gin%\")\n",
+    "type(like_expr)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select * from \"admissions_train\" where stats LIKE '%gin%'\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted\n",
+      "id                                              \n",
+      "8       no  3.60  Beginner    Advanced         1\n",
+      "6      yes  3.50  Beginner    Advanced         1\n",
+      "2      yes  3.76  Beginner    Beginner         0\n",
+      "1      yes  3.95  Beginner    Beginner         0\n",
+      "4      yes  3.50  Beginner      Novice         1\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use SQLAlchemy BinaryExpression for 'LIKE' created above to filter rows.\n",
+    "df = admissions_train[like_expr]\n",
+    "print_dataframe(df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.BinaryExpression"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Example for using NOTLIKE, retrive rows which does not contain string 'ce'\n",
+    "nlike_expr = admissions_train.stats.expression.notlike(\"%ce%\")\n",
+    "type(nlike_expr)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select * from \"admissions_train\" where stats NOT LIKE '%ce%'\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted\n",
+      "id                                              \n",
+      "8       no  3.60  Beginner    Advanced         1\n",
+      "6      yes  3.50  Beginner    Advanced         1\n",
+      "2      yes  3.76  Beginner    Beginner         0\n",
+      "1      yes  3.95  Beginner    Beginner         0\n",
+      "4      yes  3.50  Beginner      Novice         1\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use SQLAlchemy BinaryExpression for 'NOT LIKE' created above to filter rows.\n",
+    "df = admissions_train[nlike_expr]\n",
+    "print_dataframe(df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.BinaryExpression"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Example for using iLIKE - Case insensitive LIKE\n",
+    "ilike_expr = admissions_train.stats.expression.ilike(\"be%NN%r\")\n",
+    "type(ilike_expr)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select * from \"admissions_train\" where lower(stats) LIKE lower('be%NN%r')\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted\n",
+      "id                                              \n",
+      "8       no  3.60  Beginner    Advanced         1\n",
+      "6      yes  3.50  Beginner    Advanced         1\n",
+      "2      yes  3.76  Beginner    Beginner         0\n",
+      "1      yes  3.95  Beginner    Beginner         0\n",
+      "4      yes  3.50  Beginner      Novice         1\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use SQLAlchemy BinaryExpression for 'Case Insensitive LIKE' created above to filter rows.\n",
+    "df = admissions_train[ilike_expr]\n",
+    "print_dataframe(df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.BinaryExpression"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Filter rows starting with \"Beg\"\n",
+    "sw_expr = admissions_train.stats.expression.startswith(\"Beg\")\n",
+    "type(sw_expr)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select * from \"admissions_train\" where stats LIKE 'Beg' || '%'\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted\n",
+      "id                                              \n",
+      "8       no  3.60  Beginner    Advanced         1\n",
+      "6      yes  3.50  Beginner    Advanced         1\n",
+      "2      yes  3.76  Beginner    Beginner         0\n",
+      "1      yes  3.95  Beginner    Beginner         0\n",
+      "4      yes  3.50  Beginner      Novice         1\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use SQLAlchemy BinaryExpression for 'Starts With' created above to filter rows.\n",
+    "df = admissions_train[sw_expr]\n",
+    "print_dataframe(df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Using IS NULL or IS NOT NULL"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.BinaryExpression"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Example for using IS NULL\n",
+    "isnull_expr = admissions_train.stats.expression.is_(None)\n",
+    "type(isnull_expr)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select * from \"admissions_train\" where stats IS NULL\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "Empty DataFrame\n",
+      "Columns: [masters, gpa, stats, programming, admitted]\n",
+      "Index: []\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use SQLAlchemy BinaryExpression for 'IS NULL' created above to filter rows.\n",
+    "df = admissions_train[isnull_expr]\n",
+    "print_dataframe(df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.BinaryExpression"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Example for using IS NOT NULL\n",
+    "isnotnull_expr = admissions_train.stats.expression.isnot(None)\n",
+    "type(isnotnull_expr)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select * from \"admissions_train\" where stats IS NOT NULL\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted\n",
+      "id                                              \n",
+      "15     yes  4.00  Advanced    Advanced         1\n",
+      "7      yes  2.33    Novice      Novice         1\n",
+      "22     yes  3.46    Novice    Beginner         0\n",
+      "17      no  3.83  Advanced    Advanced         1\n",
+      "13      no  4.00  Advanced      Novice         1\n",
+      "38     yes  2.65  Advanced    Beginner         1\n",
+      "26     yes  3.57  Advanced    Advanced         1\n",
+      "5       no  3.44    Novice      Novice         0\n",
+      "34     yes  3.85  Advanced    Beginner         0\n",
+      "40     yes  3.95    Novice    Beginner         0\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use SQLAlchemy BinaryExpression for 'IS NOT NULL' created above to filter rows.\n",
+    "df = admissions_train[isnotnull_expr]\n",
+    "print_dataframe(df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# One must run remove_context() to close the connection and garbage collect internally generated objects.\n",
+    "remove_context()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}