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

teradataml/data/notebooks/sqlalchemy/Teradata Vantage Aggregate Functions using SQLAlchemy.ipynb

@@ -1,1455 +1,1455 @@
-{
- "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": [],
-   "source": [
-    "# In this notebook, we will be covering examples for following Regular Aggregate Functions\n",
-    "# SQL Documentation: https://docs.teradata.com/reader/756LNiPSFdY~4JcCCcR5Cw/c2fX4dzxCcDJFKqXbyQtTA\n",
-    "    # 1. avg/average/ave\n",
-    "    # 2. corr\n",
-    "    # 3. count\n",
-    "    # 4. covar_pop\n",
-    "    # 5. covar_samp\n",
-    "    # 6. var_pop\n",
-    "    # 7. var_samp\n",
-    "    # 8. kurtosis\n",
-    "    # 9. max\n",
-    "    # 10. REGR_AVGX\n",
-    "    # 11. REGR_AVGY\n",
-    "    # 12. REGR_Intercept\n",
-    "    # 13. REGR_SLOPE\n",
-    "    # 14. REGR_R2\n",
-    "    # 15. REGR_SXX\n",
-    "    # 16. REGR_SXY\n",
-    "    # 17. REGR_SYY\n",
-    "    # 18. min\n",
-    "    # 19. skew\n",
-    "    # 20. stddev_pop\n",
-    "    # 21. stddev_samp\n",
-    "    # 22. sum"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "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",
-    "# Load the example dataset.\n",
-    "load_example_data(\"GLM\", [\"admissions_train\"])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "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": 3,
-     "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": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def print_variables(df, columns):\n",
-    "    print(\"Equivalent SQL: {}\".format(df.show_query()))\n",
-    "    print(\"\\n\")\n",
-    "    print(\" ************************* DataFrame ********************* \")\n",
-    "    print(df)\n",
-    "    print(\"\\n\\n\")\n",
-    "    print(\" ************************* DataFrame.dtypes ********************* \")\n",
-    "    print(df.dtypes)\n",
-    "    print(\"\\n\\n\")\n",
-    "    if isinstance(columns, str):\n",
-    "        columns = [columns]\n",
-    "    for col in columns:\n",
-    "        coltype = df.__getattr__(col).type\n",
-    "        if isinstance(coltype, sqlalchemy.sql.sqltypes.NullType):\n",
-    "            coltype = \"NullType\"\n",
-    "        print(\" '{}' Column Type: {}\".format(col, coltype))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Using Aggregate Functions from Teradata Vanatge with SQLAlchemy"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Import func from SQLAlchemy to use the same for executing aggregate functions\n",
-    "from sqlalchemy import func"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "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": [
-    "## Avg/Average/Ave Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Function returns the arithmetic average of all values in value_expression.\n",
-    "# Syntax:\n",
-    "#         Avg(value_expression)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "sqlalchemy.sql.functions.Function"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "agg_func_ = func.avg(admissions_train.gpa.expression)\n",
-    "type(agg_func_)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select ave(admitted) AS ave_admitted_, average(admitted) AS average_admitted_, avg(gpa) AS avg_gpa_ from \"admissions_train\"\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   ave_admitted_  average_admitted_  avg_gpa_\n",
-      "0           0.65               0.65   3.54175\n",
-      "\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame.dtypes ********************* \n",
-      "ave_admitted_        float\n",
-      "average_admitted_    float\n",
-      "avg_gpa_             float\n",
-      "\n",
-      "\n",
-      "\n",
-      " 'avg_gpa_' Column Type: FLOAT\n",
-      " 'average_admitted_' Column Type: FLOAT\n",
-      " 'ave_admitted_' Column Type: FLOAT\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = admissions_train.assign(True, avg_gpa_=agg_func_, \n",
-    "                             average_admitted_=func.average(admissions_train.admitted.expression),\n",
-    "                             ave_admitted_=func.ave(admissions_train.admitted.expression))\n",
-    "print_variables(df, [\"avg_gpa_\", \"average_admitted_\", \"ave_admitted_\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## CORR Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Function returns the Sample Pearson product moment correlation coefficient of its arguments for all non-null data point pairs.\n",
-    "# Syntax:\n",
-    "#         Corr(value_expression1, value_expression2)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select corr(admitted, gpa) AS corr_numeric_ from \"admissions_train\"\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   corr_numeric_\n",
-      "0      -0.022265\n",
-      "\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame.dtypes ********************* \n",
-      "corr_numeric_    float\n",
-      "\n",
-      "\n",
-      "\n",
-      " 'corr_numeric_' Column Type: FLOAT\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = admissions_train.assign(True, \n",
-    "                             corr_numeric_=func.corr(admissions_train.admitted.expression, admissions_train.gpa.expression))\n",
-    "print_variables(df, [\"corr_numeric_\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Count Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Function returns a column value that is the total number of qualified rows in value_expression.\n",
-    "# Syntax:\n",
-    "#         Count(value_expression)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select count(admitted) AS assined_count_col_ from \"admissions_train\"\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   assined_count_col_\n",
-      "0                  40\n",
-      "\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame.dtypes ********************* \n",
-      "assined_count_col_    int\n",
-      "\n",
-      "\n",
-      "\n",
-      " 'assined_count_col_' Column Type: INTEGER\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = admissions_train.assign(True, assined_count_col_=func.count(admissions_train.admitted.expression))\n",
-    "print_variables(df, [\"assined_count_col_\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Covar_pop Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Function returns the population covariance of its arguments for all non-null data point pairs.\n",
-    "# Syntax:\n",
-    "#         Covar_pop(value_expression1, value_expression2)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select Covar_pop(admitted, gpa) AS \"assined_col_Covar_pop\" from \"admissions_train\"\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   assined_col_Covar_pop\n",
-      "0              -0.005387\n",
-      "\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame.dtypes ********************* \n",
-      "assined_col_Covar_pop    float\n",
-      "\n",
-      "\n",
-      "\n",
-      " 'assined_col_Covar_pop' Column Type: FLOAT\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = admissions_train.assign(True, \n",
-    "                             assined_col_Covar_pop=func.Covar_pop(admissions_train.admitted.expression, admissions_train.gpa.expression))\n",
-    "print_variables(df, [\"assined_col_Covar_pop\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Covar_samp Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Function returns the sample covariance of its arguments for all non-null data point pairs.\n",
-    "# Syntax:\n",
-    "#         Covar_samp(value_expression)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select Covar_samp(admitted, gpa) AS \"assined_col_Covar_samp\" from \"admissions_train\"\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   assined_col_Covar_samp\n",
-      "0               -0.005526\n",
-      "\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame.dtypes ********************* \n",
-      "assined_col_Covar_samp    float\n",
-      "\n",
-      "\n",
-      "\n",
-      " 'assined_col_Covar_samp' Column Type: FLOAT\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = admissions_train.assign(True, \n",
-    "                             assined_col_Covar_samp=func.Covar_samp(admissions_train.admitted.expression, admissions_train.gpa.expression))\n",
-    "print_variables(df, [\"assined_col_Covar_samp\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Kurtosis Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Function returns the kurtosis of the distribution of value_expression.\n",
-    "# Syntax:\n",
-    "#         Kurtosis(value_expression)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select Kurtosis(gpa) AS \"assined_col_Kurtosis_num\" from \"admissions_train\"\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   assined_col_Kurtosis_num\n",
-      "0                  4.052659\n",
-      "\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame.dtypes ********************* \n",
-      "assined_col_Kurtosis_num    float\n",
-      "\n",
-      "\n",
-      "\n",
-      " 'assined_col_Kurtosis_num' Column Type: FLOAT\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = admissions_train.assign(True, assined_col_Kurtosis_num=func.Kurtosis(admissions_train.gpa.expression))\n",
-    "print_variables(df, [\"assined_col_Kurtosis_num\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## max/maximum Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Function returns a column value that is the maximum value for value_expression.\n",
-    "# Syntax:\n",
-    "#         max(value_expression)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select max(gpa) AS assined_col_max, maximum(stats) AS assined_col_maximum from \"admissions_train\"\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   assined_col_max assined_col_maximum\n",
-      "0              4.0              Novice\n",
-      "\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame.dtypes ********************* \n",
-      "assined_col_max        float\n",
-      "assined_col_maximum      str\n",
-      "\n",
-      "\n",
-      "\n",
-      " 'assined_col_maximum' Column Type: VARCHAR\n",
-      " 'assined_col_max' Column Type: FLOAT\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = admissions_train.assign(True, \n",
-    "                             assined_col_max=func.max(admissions_train.gpa.expression),\n",
-    "                             assined_col_maximum=func.maximum(admissions_train.stats.expression))\n",
-    "print_variables(df, [\"assined_col_maximum\", \"assined_col_max\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## min/minimum Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Function returns a column value that is the minimum value for value_expression.\n",
-    "# Syntax:\n",
-    "#         min(value_expression)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select min(gpa) AS assined_col_min, minimum(stats) AS assined_col_minimum from \"admissions_train\"\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   assined_col_min assined_col_minimum\n",
-      "0             1.87            Advanced\n",
-      "\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame.dtypes ********************* \n",
-      "assined_col_min        float\n",
-      "assined_col_minimum      str\n",
-      "\n",
-      "\n",
-      "\n",
-      " 'assined_col_min' Column Type: FLOAT\n",
-      " 'assined_col_minimum' Column Type: VARCHAR\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = admissions_train.assign(True, \n",
-    "                             assined_col_min=func.min(admissions_train.gpa.expression),\n",
-    "                             assined_col_minimum=func.minimum(admissions_train.stats.expression))\n",
-    "print_variables(df, [\"assined_col_min\", \"assined_col_minimum\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## REGR_AVGX Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Function returns the mean of the independent_variable_expression for all non-null data pairs of the \n",
-    "# dependent and independent variable arguments.\n",
-    "# Syntax:\n",
-    "#         REGR_AVGX(dependent_value_expression, independent_value_expression)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select regr_avgx(admitted, gpa) AS assined_col_ from \"admissions_train\"\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   assined_col_\n",
-      "0       3.54175\n",
-      "\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame.dtypes ********************* \n",
-      "assined_col_    float\n",
-      "\n",
-      "\n",
-      "\n",
-      " 'assined_col_' Column Type: FLOAT\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = admissions_train.assign(True, \n",
-    "                             assined_col_=func.regr_avgx(admissions_train.admitted.expression, \n",
-    "                                                         admissions_train.gpa.expression))\n",
-    "print_variables(df, [\"assined_col_\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## REGR_AVGY Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Function returns the mean of the dependent_variable_expression for all non-null data pairs of the \n",
-    "# dependent and independent variable arguments.\n",
-    "# Syntax:\n",
-    "#         REGR_AVGY(dependent_value_expression, independent_value_expression)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select regr_avgy(admitted, gpa) AS assined_col_ from \"admissions_train\"\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   assined_col_\n",
-      "0          0.65\n",
-      "\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame.dtypes ********************* \n",
-      "assined_col_    float\n",
-      "\n",
-      "\n",
-      "\n",
-      " 'assined_col_' Column Type: FLOAT\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = admissions_train.assign(True, \n",
-    "                             assined_col_=func.regr_avgy(admissions_train.admitted.expression, \n",
-    "                                                         admissions_train.gpa.expression))\n",
-    "print_variables(df, [\"assined_col_\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## REGR_Count Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Function returns the count of all non-null data pairs of the dependent and independent variable arguments.\n",
-    "# Syntax:\n",
-    "#         REGR_count(dependent_value_expression, independent_value_expression)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select REGR_count(admitted, gpa) AS assined_col_ from \"admissions_train\"\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   assined_col_\n",
-      "0            40\n",
-      "\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame.dtypes ********************* \n",
-      "assined_col_    int\n",
-      "\n",
-      "\n",
-      "\n",
-      " 'assined_col_' Column Type: INTEGER\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = admissions_train.assign(True, \n",
-    "                             assined_col_=func.REGR_count(admissions_train.admitted.expression, \n",
-    "                                                         admissions_train.gpa.expression))\n",
-    "print_variables(df, [\"assined_col_\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## REGR_Intercept Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Function returns the intercept of the univariate linear regression line through all non-null data pairs of the \n",
-    "# dependent and independent variable arguments.\n",
-    "# Syntax:\n",
-    "#         REGR_Intercept(dependent_value_expression, independent_value_expression)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select REGR_Intercept(admitted, gpa) AS assined_col_ from \"admissions_train\"\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   assined_col_\n",
-      "0      0.724144\n",
-      "\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame.dtypes ********************* \n",
-      "assined_col_    float\n",
-      "\n",
-      "\n",
-      "\n",
-      " 'assined_col_' Column Type: FLOAT\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = admissions_train.assign(True, \n",
-    "                             assined_col_=func.REGR_Intercept(admissions_train.admitted.expression, \n",
-    "                                                         admissions_train.gpa.expression))\n",
-    "print_variables(df, [\"assined_col_\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## REGR_R2 Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Function returns the coefficient of determination for all non-null data pairs of the dependent and independent \n",
-    "# variable arguments.\n",
-    "# Syntax:\n",
-    "#         REGR_R2(dependent_value_expression, independent_value_expression)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select REGR_R2(admitted, gpa) AS assined_col_ from \"admissions_train\"\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   assined_col_\n",
-      "0      0.000496\n",
-      "\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame.dtypes ********************* \n",
-      "assined_col_    float\n",
-      "\n",
-      "\n",
-      "\n",
-      " 'assined_col_' Column Type: FLOAT\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = admissions_train.assign(True, \n",
-    "                             assined_col_=func.REGR_R2(admissions_train.admitted.expression, \n",
-    "                                                         admissions_train.gpa.expression))\n",
-    "print_variables(df, [\"assined_col_\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## REGR_SLOPE Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Function returns the slope of the univariate linear regression line through all non-null data pairs of the \n",
-    "# dependent and independent variable arguments.\n",
-    "# Syntax:\n",
-    "#         REGR_SLOPE(dependent_value_expression, independent_value_expression)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select REGR_SLOPE(admitted, gpa) AS assined_col_ from \"admissions_train\"\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   assined_col_\n",
-      "0     -0.020934\n",
-      "\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame.dtypes ********************* \n",
-      "assined_col_    float\n",
-      "\n",
-      "\n",
-      "\n",
-      " 'assined_col_' Column Type: FLOAT\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = admissions_train.assign(True, \n",
-    "                             assined_col_=func.REGR_SLOPE(admissions_train.admitted.expression, \n",
-    "                                                         admissions_train.gpa.expression))\n",
-    "print_variables(df, [\"assined_col_\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## REGR_SXX Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Function returns the sum of the squares of the independent_variable_expression for all non-null data pairs of the \n",
-    "# dependent and independent variable arguments.\n",
-    "# Syntax:\n",
-    "#         REGR_SXX(dependent_value_expression, independent_value_expression)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select REGR_SXX(admitted, gpa) AS assined_col_ from \"admissions_train\"\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   assined_col_\n",
-      "0     10.294177\n",
-      "\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame.dtypes ********************* \n",
-      "assined_col_    float\n",
-      "\n",
-      "\n",
-      "\n",
-      " 'assined_col_' Column Type: FLOAT\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = admissions_train.assign(True, \n",
-    "                             assined_col_=func.REGR_SXX(admissions_train.admitted.expression, \n",
-    "                                                         admissions_train.gpa.expression))\n",
-    "print_variables(df, [\"assined_col_\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## REGR_SXY Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Function returns the sum of the products of the independent_variable_expression and the dependent_variable_expression \n",
-    "# for all non-null data pairs of the dependent and independent variable arguments.\n",
-    "# Syntax:\n",
-    "#         REGR_SXY(dependent_value_expression, independent_value_expression)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 39,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select REGR_SXY(admitted, gpa) AS assined_col_ from \"admissions_train\"\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   assined_col_\n",
-      "0       -0.2155\n",
-      "\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame.dtypes ********************* \n",
-      "assined_col_    float\n",
-      "\n",
-      "\n",
-      "\n",
-      " 'assined_col_' Column Type: FLOAT\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = admissions_train.assign(True, \n",
-    "                             assined_col_=func.REGR_SXY(admissions_train.admitted.expression, \n",
-    "                                                         admissions_train.gpa.expression))\n",
-    "print_variables(df, [\"assined_col_\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## REGR_SYY Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 40,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Function returns the sum of the squares of the dependent_variable_expression for all non-null data pairs of the \n",
-    "# dependent and independent variable arguments.\n",
-    "# Syntax:\n",
-    "#         REGR_SYY(dependent_value_expression, independent_value_expression)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 41,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select REGR_SYY(admitted, gpa) AS assined_col_ from \"admissions_train\"\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   assined_col_\n",
-      "0           9.1\n",
-      "\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame.dtypes ********************* \n",
-      "assined_col_    float\n",
-      "\n",
-      "\n",
-      "\n",
-      " 'assined_col_' Column Type: FLOAT\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = admissions_train.assign(True, \n",
-    "                             assined_col_=func.REGR_SYY(admissions_train.admitted.expression, \n",
-    "                                                         admissions_train.gpa.expression))\n",
-    "print_variables(df, [\"assined_col_\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Skew Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Function returns the skewness of the distribution of value_expression.\n",
-    "# Syntax:\n",
-    "#         skew(value_expression)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 43,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select skew(gpa) AS assined_col_float, skew(admitted) AS assined_col_int from \"admissions_train\"\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   assined_col_float  assined_col_int\n",
-      "0          -2.058969        -0.653746\n",
-      "\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame.dtypes ********************* \n",
-      "assined_col_float    float\n",
-      "assined_col_int      float\n",
-      "\n",
-      "\n",
-      "\n",
-      " 'assined_col_int' Column Type: FLOAT\n",
-      " 'assined_col_float' Column Type: FLOAT\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = admissions_train.assign(True, assined_col_int=func.skew(admissions_train.admitted.expression),\n",
-    "                            assined_col_float=func.skew(admissions_train.gpa.expression))\n",
-    "print_variables(df, [\"assined_col_int\", \"assined_col_float\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## stddev_pop Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 44,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Function returns the population standard deviation for the non-null data points in value_expression.\n",
-    "# Syntax:\n",
-    "#         stddev_pop(value_expression)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 45,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select stddev_pop(gpa) AS assined_col_ from \"admissions_train\"\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   assined_col_\n",
-      "0      0.507301\n",
-      "\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame.dtypes ********************* \n",
-      "assined_col_    float\n",
-      "\n",
-      "\n",
-      "\n",
-      " 'assined_col_' Column Type: FLOAT\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = admissions_train.assign(True, assined_col_=func.stddev_pop(admissions_train.gpa.expression))\n",
-    "print_variables(df, [\"assined_col_\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## stddev_samp Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 46,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Function returns the sample standard deviation for the non-null data points in value_expression.\n",
-    "# Syntax:\n",
-    "#         stddev_samp(value_expression)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 47,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select stddev_samp(gpa) AS assined_col_ from \"admissions_train\"\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   assined_col_\n",
-      "0      0.513764\n",
-      "\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame.dtypes ********************* \n",
-      "assined_col_    float\n",
-      "\n",
-      "\n",
-      "\n",
-      " 'assined_col_' Column Type: FLOAT\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = admissions_train.assign(True, assined_col_=func.stddev_samp(admissions_train.gpa.expression))\n",
-    "print_variables(df, [\"assined_col_\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## sum Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 48,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Function returns a column value that is the arithmetic sum of value_expression.\n",
-    "# Syntax:\n",
-    "#         sum(value_expression)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 49,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select sum(gpa) AS assined_col_ from \"admissions_train\"\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   assined_col_\n",
-      "0        141.67\n",
-      "\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame.dtypes ********************* \n",
-      "assined_col_    float\n",
-      "\n",
-      "\n",
-      "\n",
-      " 'assined_col_' Column Type: FLOAT\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = admissions_train.assign(True, assined_col_=func.sum(admissions_train.gpa.expression))\n",
-    "print_variables(df, [\"assined_col_\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## var_pop Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 50,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Function returns the population variance for the data points in value_expression.\n",
-    "# Syntax:\n",
-    "#         var_pop(value_expression)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 51,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select var_pop(gpa) AS assined_col_ from \"admissions_train\"\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   assined_col_\n",
-      "0      0.257354\n",
-      "\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame.dtypes ********************* \n",
-      "assined_col_    float\n",
-      "\n",
-      "\n",
-      "\n",
-      " 'assined_col_' Column Type: FLOAT\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = admissions_train.assign(True, assined_col_=func.var_pop(admissions_train.gpa.expression))\n",
-    "print_variables(df, [\"assined_col_\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## var_samp Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 52,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Function returns the sample variance for the data points in value_expression.\n",
-    "# Syntax:\n",
-    "#         var_samp(value_expression)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 53,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Equivalent SQL: select var_samp(gpa) AS assined_col_ from \"admissions_train\"\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame ********************* \n",
-      "   assined_col_\n",
-      "0      0.263953\n",
-      "\n",
-      "\n",
-      "\n",
-      " ************************* DataFrame.dtypes ********************* \n",
-      "assined_col_    float\n",
-      "\n",
-      "\n",
-      "\n",
-      " 'assined_col_' Column Type: FLOAT\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = admissions_train.assign(True, assined_col_=func.var_samp(admissions_train.gpa.expression))\n",
-    "print_variables(df, [\"assined_col_\"])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 54,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True"
-      ]
-     },
-     "execution_count": 54,
-     "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": 55,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "## Grouping, pivot, unpivot - Not possible to use."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "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.7.1"
-  }
- },
- "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": [],
+   "source": [
+    "# In this notebook, we will be covering examples for following Regular Aggregate Functions\n",
+    "# SQL Documentation: https://docs.teradata.com/reader/756LNiPSFdY~4JcCCcR5Cw/c2fX4dzxCcDJFKqXbyQtTA\n",
+    "    # 1. avg/average/ave\n",
+    "    # 2. corr\n",
+    "    # 3. count\n",
+    "    # 4. covar_pop\n",
+    "    # 5. covar_samp\n",
+    "    # 6. var_pop\n",
+    "    # 7. var_samp\n",
+    "    # 8. kurtosis\n",
+    "    # 9. max\n",
+    "    # 10. REGR_AVGX\n",
+    "    # 11. REGR_AVGY\n",
+    "    # 12. REGR_Intercept\n",
+    "    # 13. REGR_SLOPE\n",
+    "    # 14. REGR_R2\n",
+    "    # 15. REGR_SXX\n",
+    "    # 16. REGR_SXY\n",
+    "    # 17. REGR_SYY\n",
+    "    # 18. min\n",
+    "    # 19. skew\n",
+    "    # 20. stddev_pop\n",
+    "    # 21. stddev_samp\n",
+    "    # 22. sum"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "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",
+    "# Load the example dataset.\n",
+    "load_example_data(\"GLM\", [\"admissions_train\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "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": 3,
+     "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": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def print_variables(df, columns):\n",
+    "    print(\"Equivalent SQL: {}\".format(df.show_query()))\n",
+    "    print(\"\\n\")\n",
+    "    print(\" ************************* DataFrame ********************* \")\n",
+    "    print(df)\n",
+    "    print(\"\\n\\n\")\n",
+    "    print(\" ************************* DataFrame.dtypes ********************* \")\n",
+    "    print(df.dtypes)\n",
+    "    print(\"\\n\\n\")\n",
+    "    if isinstance(columns, str):\n",
+    "        columns = [columns]\n",
+    "    for col in columns:\n",
+    "        coltype = df.__getattr__(col).type\n",
+    "        if isinstance(coltype, sqlalchemy.sql.sqltypes.NullType):\n",
+    "            coltype = \"NullType\"\n",
+    "        print(\" '{}' Column Type: {}\".format(col, coltype))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Using Aggregate Functions from Teradata Vanatge with SQLAlchemy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import func from SQLAlchemy to use the same for executing aggregate functions\n",
+    "from sqlalchemy import func"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "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": [
+    "## Avg/Average/Ave Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the arithmetic average of all values in value_expression.\n",
+    "# Syntax:\n",
+    "#         Avg(value_expression)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agg_func_ = func.avg(admissions_train.gpa.expression)\n",
+    "type(agg_func_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select ave(admitted) AS ave_admitted_, average(admitted) AS average_admitted_, avg(gpa) AS avg_gpa_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   ave_admitted_  average_admitted_  avg_gpa_\n",
+      "0           0.65               0.65   3.54175\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "ave_admitted_        float\n",
+      "average_admitted_    float\n",
+      "avg_gpa_             float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'avg_gpa_' Column Type: FLOAT\n",
+      " 'average_admitted_' Column Type: FLOAT\n",
+      " 'ave_admitted_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(True, avg_gpa_=agg_func_, \n",
+    "                             average_admitted_=func.average(admissions_train.admitted.expression),\n",
+    "                             ave_admitted_=func.ave(admissions_train.admitted.expression))\n",
+    "print_variables(df, [\"avg_gpa_\", \"average_admitted_\", \"ave_admitted_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## CORR Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the Sample Pearson product moment correlation coefficient of its arguments for all non-null data point pairs.\n",
+    "# Syntax:\n",
+    "#         Corr(value_expression1, value_expression2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select corr(admitted, gpa) AS corr_numeric_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   corr_numeric_\n",
+      "0      -0.022265\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "corr_numeric_    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'corr_numeric_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(True, \n",
+    "                             corr_numeric_=func.corr(admissions_train.admitted.expression, admissions_train.gpa.expression))\n",
+    "print_variables(df, [\"corr_numeric_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Count Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns a column value that is the total number of qualified rows in value_expression.\n",
+    "# Syntax:\n",
+    "#         Count(value_expression)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select count(admitted) AS assined_count_col_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   assined_count_col_\n",
+      "0                  40\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "assined_count_col_    int\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'assined_count_col_' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(True, assined_count_col_=func.count(admissions_train.admitted.expression))\n",
+    "print_variables(df, [\"assined_count_col_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Covar_pop Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the population covariance of its arguments for all non-null data point pairs.\n",
+    "# Syntax:\n",
+    "#         Covar_pop(value_expression1, value_expression2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select Covar_pop(admitted, gpa) AS \"assined_col_Covar_pop\" from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   assined_col_Covar_pop\n",
+      "0              -0.005387\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "assined_col_Covar_pop    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'assined_col_Covar_pop' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(True, \n",
+    "                             assined_col_Covar_pop=func.Covar_pop(admissions_train.admitted.expression, admissions_train.gpa.expression))\n",
+    "print_variables(df, [\"assined_col_Covar_pop\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Covar_samp Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the sample covariance of its arguments for all non-null data point pairs.\n",
+    "# Syntax:\n",
+    "#         Covar_samp(value_expression)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select Covar_samp(admitted, gpa) AS \"assined_col_Covar_samp\" from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   assined_col_Covar_samp\n",
+      "0               -0.005526\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "assined_col_Covar_samp    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'assined_col_Covar_samp' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(True, \n",
+    "                             assined_col_Covar_samp=func.Covar_samp(admissions_train.admitted.expression, admissions_train.gpa.expression))\n",
+    "print_variables(df, [\"assined_col_Covar_samp\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Kurtosis Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the kurtosis of the distribution of value_expression.\n",
+    "# Syntax:\n",
+    "#         Kurtosis(value_expression)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select Kurtosis(gpa) AS \"assined_col_Kurtosis_num\" from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   assined_col_Kurtosis_num\n",
+      "0                  4.052659\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "assined_col_Kurtosis_num    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'assined_col_Kurtosis_num' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(True, assined_col_Kurtosis_num=func.Kurtosis(admissions_train.gpa.expression))\n",
+    "print_variables(df, [\"assined_col_Kurtosis_num\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## max/maximum Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns a column value that is the maximum value for value_expression.\n",
+    "# Syntax:\n",
+    "#         max(value_expression)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select max(gpa) AS assined_col_max, maximum(stats) AS assined_col_maximum from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   assined_col_max assined_col_maximum\n",
+      "0              4.0              Novice\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "assined_col_max        float\n",
+      "assined_col_maximum      str\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'assined_col_maximum' Column Type: VARCHAR\n",
+      " 'assined_col_max' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(True, \n",
+    "                             assined_col_max=func.max(admissions_train.gpa.expression),\n",
+    "                             assined_col_maximum=func.maximum(admissions_train.stats.expression))\n",
+    "print_variables(df, [\"assined_col_maximum\", \"assined_col_max\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## min/minimum Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns a column value that is the minimum value for value_expression.\n",
+    "# Syntax:\n",
+    "#         min(value_expression)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select min(gpa) AS assined_col_min, minimum(stats) AS assined_col_minimum from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   assined_col_min assined_col_minimum\n",
+      "0             1.87            Advanced\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "assined_col_min        float\n",
+      "assined_col_minimum      str\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'assined_col_min' Column Type: FLOAT\n",
+      " 'assined_col_minimum' Column Type: VARCHAR\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(True, \n",
+    "                             assined_col_min=func.min(admissions_train.gpa.expression),\n",
+    "                             assined_col_minimum=func.minimum(admissions_train.stats.expression))\n",
+    "print_variables(df, [\"assined_col_min\", \"assined_col_minimum\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## REGR_AVGX Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the mean of the independent_variable_expression for all non-null data pairs of the \n",
+    "# dependent and independent variable arguments.\n",
+    "# Syntax:\n",
+    "#         REGR_AVGX(dependent_value_expression, independent_value_expression)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select regr_avgx(admitted, gpa) AS assined_col_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   assined_col_\n",
+      "0       3.54175\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "assined_col_    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'assined_col_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(True, \n",
+    "                             assined_col_=func.regr_avgx(admissions_train.admitted.expression, \n",
+    "                                                         admissions_train.gpa.expression))\n",
+    "print_variables(df, [\"assined_col_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## REGR_AVGY Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the mean of the dependent_variable_expression for all non-null data pairs of the \n",
+    "# dependent and independent variable arguments.\n",
+    "# Syntax:\n",
+    "#         REGR_AVGY(dependent_value_expression, independent_value_expression)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select regr_avgy(admitted, gpa) AS assined_col_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   assined_col_\n",
+      "0          0.65\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "assined_col_    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'assined_col_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(True, \n",
+    "                             assined_col_=func.regr_avgy(admissions_train.admitted.expression, \n",
+    "                                                         admissions_train.gpa.expression))\n",
+    "print_variables(df, [\"assined_col_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## REGR_Count Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the count of all non-null data pairs of the dependent and independent variable arguments.\n",
+    "# Syntax:\n",
+    "#         REGR_count(dependent_value_expression, independent_value_expression)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select REGR_count(admitted, gpa) AS assined_col_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   assined_col_\n",
+      "0            40\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "assined_col_    int\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'assined_col_' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(True, \n",
+    "                             assined_col_=func.REGR_count(admissions_train.admitted.expression, \n",
+    "                                                         admissions_train.gpa.expression))\n",
+    "print_variables(df, [\"assined_col_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## REGR_Intercept Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the intercept of the univariate linear regression line through all non-null data pairs of the \n",
+    "# dependent and independent variable arguments.\n",
+    "# Syntax:\n",
+    "#         REGR_Intercept(dependent_value_expression, independent_value_expression)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select REGR_Intercept(admitted, gpa) AS assined_col_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   assined_col_\n",
+      "0      0.724144\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "assined_col_    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'assined_col_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(True, \n",
+    "                             assined_col_=func.REGR_Intercept(admissions_train.admitted.expression, \n",
+    "                                                         admissions_train.gpa.expression))\n",
+    "print_variables(df, [\"assined_col_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## REGR_R2 Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the coefficient of determination for all non-null data pairs of the dependent and independent \n",
+    "# variable arguments.\n",
+    "# Syntax:\n",
+    "#         REGR_R2(dependent_value_expression, independent_value_expression)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select REGR_R2(admitted, gpa) AS assined_col_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   assined_col_\n",
+      "0      0.000496\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "assined_col_    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'assined_col_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(True, \n",
+    "                             assined_col_=func.REGR_R2(admissions_train.admitted.expression, \n",
+    "                                                         admissions_train.gpa.expression))\n",
+    "print_variables(df, [\"assined_col_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## REGR_SLOPE Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the slope of the univariate linear regression line through all non-null data pairs of the \n",
+    "# dependent and independent variable arguments.\n",
+    "# Syntax:\n",
+    "#         REGR_SLOPE(dependent_value_expression, independent_value_expression)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select REGR_SLOPE(admitted, gpa) AS assined_col_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   assined_col_\n",
+      "0     -0.020934\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "assined_col_    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'assined_col_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(True, \n",
+    "                             assined_col_=func.REGR_SLOPE(admissions_train.admitted.expression, \n",
+    "                                                         admissions_train.gpa.expression))\n",
+    "print_variables(df, [\"assined_col_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## REGR_SXX Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the sum of the squares of the independent_variable_expression for all non-null data pairs of the \n",
+    "# dependent and independent variable arguments.\n",
+    "# Syntax:\n",
+    "#         REGR_SXX(dependent_value_expression, independent_value_expression)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select REGR_SXX(admitted, gpa) AS assined_col_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   assined_col_\n",
+      "0     10.294177\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "assined_col_    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'assined_col_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(True, \n",
+    "                             assined_col_=func.REGR_SXX(admissions_train.admitted.expression, \n",
+    "                                                         admissions_train.gpa.expression))\n",
+    "print_variables(df, [\"assined_col_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## REGR_SXY Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the sum of the products of the independent_variable_expression and the dependent_variable_expression \n",
+    "# for all non-null data pairs of the dependent and independent variable arguments.\n",
+    "# Syntax:\n",
+    "#         REGR_SXY(dependent_value_expression, independent_value_expression)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select REGR_SXY(admitted, gpa) AS assined_col_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   assined_col_\n",
+      "0       -0.2155\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "assined_col_    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'assined_col_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(True, \n",
+    "                             assined_col_=func.REGR_SXY(admissions_train.admitted.expression, \n",
+    "                                                         admissions_train.gpa.expression))\n",
+    "print_variables(df, [\"assined_col_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## REGR_SYY Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the sum of the squares of the dependent_variable_expression for all non-null data pairs of the \n",
+    "# dependent and independent variable arguments.\n",
+    "# Syntax:\n",
+    "#         REGR_SYY(dependent_value_expression, independent_value_expression)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select REGR_SYY(admitted, gpa) AS assined_col_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   assined_col_\n",
+      "0           9.1\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "assined_col_    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'assined_col_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(True, \n",
+    "                             assined_col_=func.REGR_SYY(admissions_train.admitted.expression, \n",
+    "                                                         admissions_train.gpa.expression))\n",
+    "print_variables(df, [\"assined_col_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Skew Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the skewness of the distribution of value_expression.\n",
+    "# Syntax:\n",
+    "#         skew(value_expression)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select skew(gpa) AS assined_col_float, skew(admitted) AS assined_col_int from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   assined_col_float  assined_col_int\n",
+      "0          -2.058969        -0.653746\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "assined_col_float    float\n",
+      "assined_col_int      float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'assined_col_int' Column Type: FLOAT\n",
+      " 'assined_col_float' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(True, assined_col_int=func.skew(admissions_train.admitted.expression),\n",
+    "                            assined_col_float=func.skew(admissions_train.gpa.expression))\n",
+    "print_variables(df, [\"assined_col_int\", \"assined_col_float\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## stddev_pop Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the population standard deviation for the non-null data points in value_expression.\n",
+    "# Syntax:\n",
+    "#         stddev_pop(value_expression)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select stddev_pop(gpa) AS assined_col_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   assined_col_\n",
+      "0      0.507301\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "assined_col_    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'assined_col_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(True, assined_col_=func.stddev_pop(admissions_train.gpa.expression))\n",
+    "print_variables(df, [\"assined_col_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## stddev_samp Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the sample standard deviation for the non-null data points in value_expression.\n",
+    "# Syntax:\n",
+    "#         stddev_samp(value_expression)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select stddev_samp(gpa) AS assined_col_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   assined_col_\n",
+      "0      0.513764\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "assined_col_    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'assined_col_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(True, assined_col_=func.stddev_samp(admissions_train.gpa.expression))\n",
+    "print_variables(df, [\"assined_col_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## sum Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns a column value that is the arithmetic sum of value_expression.\n",
+    "# Syntax:\n",
+    "#         sum(value_expression)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select sum(gpa) AS assined_col_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   assined_col_\n",
+      "0        141.67\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "assined_col_    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'assined_col_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(True, assined_col_=func.sum(admissions_train.gpa.expression))\n",
+    "print_variables(df, [\"assined_col_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## var_pop Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the population variance for the data points in value_expression.\n",
+    "# Syntax:\n",
+    "#         var_pop(value_expression)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select var_pop(gpa) AS assined_col_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   assined_col_\n",
+      "0      0.257354\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "assined_col_    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'assined_col_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(True, assined_col_=func.var_pop(admissions_train.gpa.expression))\n",
+    "print_variables(df, [\"assined_col_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## var_samp Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the sample variance for the data points in value_expression.\n",
+    "# Syntax:\n",
+    "#         var_samp(value_expression)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select var_samp(gpa) AS assined_col_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   assined_col_\n",
+      "0      0.263953\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "assined_col_    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'assined_col_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "df = admissions_train.assign(True, assined_col_=func.var_samp(admissions_train.gpa.expression))\n",
+    "print_variables(df, [\"assined_col_\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 54,
+     "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": 55,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Grouping, pivot, unpivot - Not possible to use."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "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.7.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}