teradataml 20.0.0.8__py3-none-any.whl

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

@@ -0,0 +1,2911 @@
+{
+ "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 shall cover examples for following Regular Expression Functions:\n",
+    "# SQL Documentation: https://docs.teradata.com/reader/756LNiPSFdY~4JcCCcR5Cw/c2fX4dzxCcDJFKqXbyQtTA\n",
+    "\n",
+    "# TD Supported Window Aggregate fucntions:\n",
+    "# 1. avg\n",
+    "# 2. count\n",
+    "# 3. corr\n",
+    "# 4. max\n",
+    "# 5. min\n",
+    "# 6. stddev_pop\n",
+    "# 7. stddev_samp\n",
+    "# 8. sum\n",
+    "# 9. var_pop\n",
+    "# 10. var_samp\n",
+    "# 11. REGR_AVGX\n",
+    "# 12. REGR_AVGY\n",
+    "# 13. REGR_INTERCEPT\n",
+    "# 14. REGR_R2\n",
+    "# 15. REGR_SLOPE\n",
+    "# 16. REGR_SXX\n",
+    "# 17. REGR_SXY\n",
+    "# 18. REGR_SYY\n",
+    "# 19. cume_dist\n",
+    "# 20. dense_rank\n",
+    "# 21. first_value\n",
+    "# 22. last_value\n",
+    "# 23. lag (Without Ignore NULLs)\n",
+    "# 24. lead (Without Ignore NULLs)\n",
+    "# 25. mdiff \n",
+    "# 26. CSUM\n",
+    "# 27. MAVG\n",
+    "# 28. median --> with drop_columns=True\n",
+    "# 29. mlinreg\n",
+    "# 30. MSUM\n",
+    "# 31. percent_rank\n",
+    "# 32. percentile_cont --> with drop_columns=True\n",
+    "# 33. percentile_disc --> with drop_columns=True\n",
+    "# 34. Quantile\n",
+    "# 35. RANK --> Without \"with ties\" and \"RESET WHEN\"\n",
+    "# 36. RANK(Teradata)\n",
+    "# 37. row_number() --> Without \"RESET WHEN\"\n",
+    "# 38. covar_samp\n",
+    "# 39. covar_pop"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hostname: ········\n",
+      "Username: ········\n",
+      "Passowrd: ········\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",
+    "import getpass\n",
+    "from teradataml import *\n",
+    "td_context = create_context(host=getpass.getpass(\"Hostname: \"), username=getpass.getpass(\"Username: \"), password=getpass.getpass(\"Passowrd: \"))\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",
+       "5       no  3.44    Novice      Novice         0\n",
+       "34     yes  3.85  Advanced    Beginner         0\n",
+       "13      no  4.00  Advanced      Novice         1\n",
+       "40     yes  3.95    Novice    Beginner         0\n",
+       "22     yes  3.46    Novice    Beginner         0\n",
+       "19     yes  1.98  Advanced    Advanced         0\n",
+       "36      no  3.00  Advanced      Novice         0\n",
+       "15     yes  4.00  Advanced    Advanced         1\n",
+       "7      yes  2.33    Novice      Novice         1\n",
+       "17      no  3.83  Advanced    Advanced         1"
+      ]
+     },
+     "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=None):\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 columns is not None:\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 SQLAlchemy ClasueElements for WindowAggregates in teradataml DataFrame.assign()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "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 within_group expression"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### percentile_disc and percentile_cont function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns an interpolated value that falls within its value_expression with respect to its sort specification.\n",
+    "# SQL Syntax:\n",
+    "#        function_name(value_expression) WITHIN GROUP(ORDER BY order_by_expression)\n",
+    "#        where,\n",
+    "#                value_expression - a column expression\n",
+    "#                order_by_expression - a numeric column expression for sorting\n",
+    "#                                      ordering can be done in Ascending or Descending order with Nulls First or Nulls Last\n",
+    "#\n",
+    "# SQLAlchmey Syntax:\n",
+    "#        func.function_name(value_expression).within_group(order_by_expression)\n",
+    "#        where,\n",
+    "#                value_expression - a SQLAlchemy column expression\n",
+    "#                order_by_expression - a SQLAlchemy column expression of numeric type for sorting\n",
+    "#                                      ordering can be done in Ascending or Descending order with Nulls First or Nulls Last"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import required modules\n",
+    "from sqlalchemy import func"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.WithinGroup"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Execute percentile_cont function using WITHIN GROUP with desceniding odering done on gpa column \n",
+    "pc = func.percentile_cont(0.5).within_group(\n",
+    "        admissions_train.gpa.expression.desc()\n",
+    "    )\n",
+    "type(pc)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select percentile_cont(0.5) WITHIN GROUP (ORDER BY gpa DESC) AS interpolated_value from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   interpolated_value\n",
+      "0                3.69\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "interpolated_value    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'interpolated_value' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "pc_df = admissions_train.assign(True, interpolated_value=pc)\n",
+    "print_variables(pc_df, \"interpolated_value\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select percentile_cont(1) WITHIN GROUP (ORDER BY gpa ASC NULLS FIRST) AS interpolated_value from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   interpolated_value\n",
+      "0                 4.0\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "interpolated_value    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'interpolated_value' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Execute percentile_cont function using WITHIN GROUP with ascending odering done on gpa column and with NULL FIRST\n",
+    "df = admissions_train.assign(True, interpolated_value=func.percentile_cont(1).within_group(\n",
+    "    admissions_train.gpa.expression.asc().nullsfirst()))\n",
+    "print_variables(df, \"interpolated_value\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select percentile_disc(1) WITHIN GROUP (ORDER BY gpa NULLS LAST) AS interpolated_value from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   interpolated_value\n",
+      "0                 4.0\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "interpolated_value    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'interpolated_value' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Execute percentile_disc function using WITHIN GROUP with odering done on gpa column and with NULLS LAST\n",
+    "df = admissions_train.assign(True, interpolated_value=func.percentile_disc(1).within_group(\n",
+    "    admissions_train.gpa.expression.nullslast()))\n",
+    "print_variables(df, \"interpolated_value\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Windowed Aggreates using OVER "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Windowed aggregation offered by Vantage supportes various clauses and can be used \n",
+    "# in teradataml with the help of SQLAlchemy.\n",
+    "# Let's take a look at few examples on how can we perform windowed aggregation with \n",
+    "# the help of SQLAlchemy and teradataml's DataFrame.assign() API.\n",
+    "\n",
+    "\n",
+    "# Column ordering in SQLAlchemy:\n",
+    "# To specify ascending or descending ordering, one can use asc() or desc() methods on SQLAlchemy column.\n",
+    "# One can specify nulls first or nulls last as well for odering. \n",
+    "# Here is how you do it:\n",
+    "#        Descending oder: admissions_train.id.expression.desc() \n",
+    "#        Ascending oder: admissions_train.id.expression.asc() \n",
+    "#        With NULLS FIRST - df.column_name.expression.nullsfirst()\n",
+    "#        With NULLS LAST - df.column_name.expression.nullslast()\n",
+    "#        Ascending Order with NULLS LAST - df.column_name.expression.asc().nullslast()\n",
+    "\n",
+    "\n",
+    "# SQLAlchemy offers a method over(...), that can be operated on a  SQLAlchemy column.\n",
+    "# Syntax:\n",
+    "#        over(partition_by = partition_expression, order_by = order_expression, rows = (p, f))\n",
+    "#        where,\n",
+    "#                partition_expression - column expression to partition the data on. \n",
+    "#                                       For example,\n",
+    "#                                               df.column_name.expression\n",
+    "#                order_expression - column expression to sort the data. \n",
+    "#                                   Sorting can be done either in Ascending or Descending order with NULLS FIRST or NULLS LAST.\n",
+    "#                                   For example,\n",
+    "#                                           Default sorting - df.column_name.expression\n",
+    "#                                           Ascending Order - df.column_name.expression.asc()\n",
+    "#                                           Descending Order - df.column_name.expression.desc()\n",
+    "#                                           With NULLS FIRST - df.column_name.expression.nullsfirst()\n",
+    "#                                           With NULLS LAST - df.column_name.expression.nullslast()\n",
+    "#                                           Ascending Order with NULLS LAST - df.column_name.expression.asc().nullslast()\n",
+    "#                rows - Generates the syntax for 'ROWS BETWEEN'\n",
+    "#                        To perform windowed aggregate function over a window using ROWS and ROWS BETWEEN one must use \n",
+    "#                        argument \"rows\" in over which accepts a tuple (p, f).\n",
+    "#                        Where,\n",
+    "#                                p and f can accept Negative Integer Value, Positive Integer Value, 0 or None.\n",
+    "#                                Each value passed to p and f have different meaning or results in different syntax.\n",
+    "#                                SQL syntax will be generated based on these values:\n",
+    "#                                        1. Negative Value --> Indicates a preceding value\n",
+    "#                                        2. Positive Value --> Indiacates a following value\n",
+    "#                                        3. 0 --> For Current row\n",
+    "#                                        4. None --> Unbounded value.\n",
+    "#"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### CSUM Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns the cumulative (or running) sum of a value expression for each row in a partition, \n",
+    "# assuming the rows in the partition are sorted by the sort_expression list.\n",
+    "# Syntax:\n",
+    "#        CSUM(value_expression, sort_expression ASC/DESC)\n",
+    "#        where,\n",
+    "#                value_expression - a SQLAlchemy column expression\n",
+    "#                order_by_expression - a SQLAlchemy column expression for sorting\n",
+    "#                                      ordering can be done in Ascending or Descending order\n",
+    "\n",
+    "# To specify ascending or descending ordering, one can use asc() or desc() methods on SQLAlchemy column.\n",
+    "# For example,\n",
+    "#        Descending oder: admissions_train.id.expression.desc() \n",
+    "#        Ascending oder: admissions_train.id.expression.asc() "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Calculate running total of gpa.\n",
+    "csum_ = func.csum(admissions_train.gpa.expression, admissions_train.id.expression.desc())\n",
+    "type(csum_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, csum(gpa, id DESC) AS csum_gpa_ from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  csum_gpa_\n",
+      "id                                                         \n",
+      "38     yes  2.65  Advanced    Beginner         1      10.35\n",
+      "36      no  3.00  Advanced      Novice         0      16.87\n",
+      "35      no  3.68    Novice    Beginner         1      20.55\n",
+      "34     yes  3.85  Advanced    Beginner         0      24.40\n",
+      "32     yes  3.46  Advanced    Beginner         0      31.41\n",
+      "31     yes  3.50  Advanced    Beginner         1      34.91\n",
+      "33      no  3.55    Novice      Novice         1      27.95\n",
+      "37      no  3.52    Novice      Novice         1      13.87\n",
+      "39     yes  3.75  Advanced    Beginner         0       7.70\n",
+      "40     yes  3.95    Novice    Beginner         0       3.95\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id               int\n",
+      "masters          str\n",
+      "gpa            float\n",
+      "stats            str\n",
+      "programming      str\n",
+      "admitted         int\n",
+      "csum_gpa_      float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'csum_gpa_' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "csum_gpa_df = admissions_train.assign(csum_gpa_=csum_)\n",
+    "print_variables(csum_gpa_df, \"csum_gpa_\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### CUME_DIST function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Calculates the cumulative distribution of a value in a group of values.\n",
+    "# SQL Syntax:\n",
+    "#        CUME_DIST() OVER (partition_by_expression, sort_expression)\n",
+    "# SQLAlchemy Syntax:\n",
+    "#        func.CUME_DIST().over(partition_by = partition_by_expression, order_by = sort_expression)\n",
+    "#        where,\n",
+    "#                partition_by_expression - a SQLAlchemy column expression\n",
+    "#                order_by_expression - a SQLAlchemy column expression for sorting\n",
+    "#                                      ordering can be done in Ascending or Descending order with NULLS FIRST or NULLS LAST"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.Over"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Calculate cumulative distribution by stats.\n",
+    "cum_dist_ = func.Cume_dist().over(order_by=admissions_train.stats.expression.desc())\n",
+    "type(cum_dist_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, cume_dist() OVER (ORDER BY stats DESC) AS cum_dist_by_stats from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa   stats programming  admitted  cum_dist_by_stats\n",
+      "id                                                               \n",
+      "29     yes  4.00  Novice    Beginner         0              0.275\n",
+      "35      no  3.68  Novice    Beginner         1              0.275\n",
+      "37      no  3.52  Novice      Novice         1              0.275\n",
+      "40     yes  3.95  Novice    Beginner         0              0.275\n",
+      "12      no  3.65  Novice      Novice         1              0.275\n",
+      "22     yes  3.46  Novice    Beginner         0              0.275\n",
+      "7      yes  2.33  Novice      Novice         1              0.275\n",
+      "3       no  3.70  Novice    Beginner         1              0.275\n",
+      "33      no  3.55  Novice      Novice         1              0.275\n",
+      "5       no  3.44  Novice      Novice         0              0.275\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                     int\n",
+      "masters                str\n",
+      "gpa                  float\n",
+      "stats                  str\n",
+      "programming            str\n",
+      "admitted               int\n",
+      "cum_dist_by_stats    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'cum_dist_by_stats' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "cum_dist_by_stats_df = admissions_train.assign(cum_dist_by_stats=cum_dist_)\n",
+    "print_variables(cum_dist_by_stats_df, \"cum_dist_by_stats\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.Over"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Calculate cumulative distribution by id, partitioned over stats\n",
+    "cum_dist_ = func.Cume_dist().over(partition_by=admissions_train.stats.expression, order_by=admissions_train.id.expression.desc())\n",
+    "type(cum_dist_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, cume_dist() OVER (PARTITION BY stats ORDER BY id DESC) AS cum_dist_by_stats from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  cum_dist_by_stats\n",
+      "id                                                                 \n",
+      "4      yes  3.50  Beginner      Novice         1           0.600000\n",
+      "1      yes  3.95  Beginner    Beginner         0           1.000000\n",
+      "39     yes  3.75  Advanced    Beginner         0           0.041667\n",
+      "38     yes  2.65  Advanced    Beginner         1           0.083333\n",
+      "34     yes  3.85  Advanced    Beginner         0           0.166667\n",
+      "32     yes  3.46  Advanced    Beginner         0           0.208333\n",
+      "31     yes  3.50  Advanced    Beginner         1           0.250000\n",
+      "30     yes  3.79  Advanced      Novice         0           0.291667\n",
+      "28      no  3.93  Advanced    Advanced         1           0.333333\n",
+      "27     yes  3.96  Advanced    Advanced         0           0.375000\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                     int\n",
+      "masters                str\n",
+      "gpa                  float\n",
+      "stats                  str\n",
+      "programming            str\n",
+      "admitted               int\n",
+      "cum_dist_by_stats    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'cum_dist_by_stats' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "cum_dist_by_stats_df = admissions_train.assign(cum_dist_by_stats=cum_dist_)\n",
+    "print_variables(cum_dist_by_stats_df, \"cum_dist_by_stats\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### DENSE_RANK fucntion"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns an ordered ranking of rows based on the value_expression in the ORDER BY clause.\n",
+    "# SQL Syntax:\n",
+    "#        DENSE_RANK() OVER (PARTITION BY partition_by_expression, ORDER BY sort_expression)\n",
+    "#\n",
+    "# SQLAlchemy Syntax:\n",
+    "#        func.DENSE_RANK().over(partition_by = partition_by_expression, order_by = sort_expression)\n",
+    "#        where,\n",
+    "#                partition_by_expression - a SQLAlchemy column expression\n",
+    "#                order_by_expression - a SQLAlchemy column expression for sorting\n",
+    "#                                      ordering can be done in Ascending or Descending order with NULLS FIRST or NULLS LAST"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.Over"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Get the ordered ranking based on stats.\n",
+    "dense_rank_ = func.DENSE_RANK().over(order_by=admissions_train.stats.expression.desc())\n",
+    "type(dense_rank_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, dense_rank() OVER (ORDER BY stats DESC) AS dense_rank_by_stats from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa   stats programming  admitted  dense_rank_by_stats\n",
+      "id                                                                 \n",
+      "33      no  3.55  Novice      Novice         1                    1\n",
+      "12      no  3.65  Novice      Novice         1                    1\n",
+      "5       no  3.44  Novice      Novice         0                    1\n",
+      "40     yes  3.95  Novice    Beginner         0                    1\n",
+      "3       no  3.70  Novice    Beginner         1                    1\n",
+      "21      no  3.87  Novice    Beginner         1                    1\n",
+      "29     yes  4.00  Novice    Beginner         0                    1\n",
+      "22     yes  3.46  Novice    Beginner         0                    1\n",
+      "35      no  3.68  Novice    Beginner         1                    1\n",
+      "7      yes  2.33  Novice      Novice         1                    1\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                       int\n",
+      "masters                  str\n",
+      "gpa                    float\n",
+      "stats                    str\n",
+      "programming              str\n",
+      "admitted                 int\n",
+      "dense_rank_by_stats      int\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'dense_rank_by_stats' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "dense_rank_by_stats_df = admissions_train.assign(dense_rank_by_stats=dense_rank_)\n",
+    "print_variables(dense_rank_by_stats_df, \"dense_rank_by_stats\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.Over"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Calculate cumulative distribution by id, partitioned over stats\n",
+    "dense_rank_ = func.dense_rank().over(partition_by=admissions_train.stats.expression, order_by=admissions_train.id.expression.desc())\n",
+    "type(dense_rank_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, dense_rank() OVER (PARTITION BY stats ORDER BY id DESC) AS dense_rank_by_stats from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  dense_rank_by_stats\n",
+      "id                                                                   \n",
+      "4      yes  3.50  Beginner      Novice         1                    3\n",
+      "1      yes  3.95  Beginner    Beginner         0                    5\n",
+      "39     yes  3.75  Advanced    Beginner         0                    1\n",
+      "38     yes  2.65  Advanced    Beginner         1                    2\n",
+      "34     yes  3.85  Advanced    Beginner         0                    4\n",
+      "32     yes  3.46  Advanced    Beginner         0                    5\n",
+      "31     yes  3.50  Advanced    Beginner         1                    6\n",
+      "30     yes  3.79  Advanced      Novice         0                    7\n",
+      "28      no  3.93  Advanced    Advanced         1                    8\n",
+      "27     yes  3.96  Advanced    Advanced         0                    9\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                       int\n",
+      "masters                  str\n",
+      "gpa                    float\n",
+      "stats                    str\n",
+      "programming              str\n",
+      "admitted                 int\n",
+      "dense_rank_by_stats      int\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'dense_rank_by_stats' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "dense_rank_by_stats_df = admissions_train.assign(dense_rank_by_stats=dense_rank_)\n",
+    "print_variables(dense_rank_by_stats_df, \"dense_rank_by_stats\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### First Value Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns the first value in an ordered set of values.\n",
+    "# SQL Syntax:\n",
+    "#        FIRST_VALUE(value_expression) OVER (PARTITION BY partition_by_expression, ORDER BY sort_expression, ROWS BETWEEN ... )\n",
+    "#\n",
+    "# SQLAlchemy Syntax:\n",
+    "#        func.FIRST_VALUE(value_expression).over(partition_by = partition_by_expression, order_by = sort_expression, rows=(p, f))\n",
+    "#        where,\n",
+    "#                value_expression - a SQLAlchemy column expression on which function to be executed.\n",
+    "#                partition_by_expression - a SQLAlchemy column expression\n",
+    "#                order_by_expression - a SQLAlchemy column expression for sorting\n",
+    "#                                      ordering can be done in Ascending or Descending order with NULLS FIRST or NULLS LAST\n",
+    "#                rows_ = Define a window"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.Over"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Example returns by id first gpa in the moving average group.\n",
+    "FIRST_VALUE_ = func.FIRST_VALUE(admissions_train.gpa.expression).over(order_by=admissions_train.id.expression, rows=(-3, 1))\n",
+    "type(FIRST_VALUE_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, FIRST_VALUE(gpa) OVER (ORDER BY id ROWS BETWEEN 3 PRECEDING AND 1 FOLLOWING) AS \"FIRST_VALUE_gpa\" from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  FIRST_VALUE_gpa\n",
+      "id                                                               \n",
+      "3       no  3.70    Novice    Beginner         1             3.95\n",
+      "5       no  3.44    Novice      Novice         0             3.76\n",
+      "6      yes  3.50  Beginner    Advanced         1             3.70\n",
+      "7      yes  2.33    Novice      Novice         1             3.50\n",
+      "9       no  3.82  Advanced    Advanced         1             3.50\n",
+      "10      no  3.71  Advanced    Advanced         1             2.33\n",
+      "8       no  3.60  Beginner    Advanced         1             3.44\n",
+      "4      yes  3.50  Beginner      Novice         1             3.95\n",
+      "2      yes  3.76  Beginner    Beginner         0             3.95\n",
+      "1      yes  3.95  Beginner    Beginner         0             3.95\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                   int\n",
+      "masters              str\n",
+      "gpa                float\n",
+      "stats                str\n",
+      "programming          str\n",
+      "admitted             int\n",
+      "FIRST_VALUE_gpa    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'FIRST_VALUE_gpa' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "fv_gpa_df = admissions_train.assign(FIRST_VALUE_gpa=FIRST_VALUE_)\n",
+    "print_variables(fv_gpa_df, \"FIRST_VALUE_gpa\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Last Value Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns the last value in an ordered set of values.\n",
+    "# SQL Syntax:\n",
+    "#        LAST_VALUE(value_expression) OVER (PARTITION BY partition_by_expression, ORDER BY sort_expression, ROWS BETWEEN ... )\n",
+    "#\n",
+    "# SQLAlchemy Syntax:\n",
+    "#        func.LAST_VALUE(value_expression).over(partition_by = partition_by_expression, order_by = sort_expression, rows=(p, f))\n",
+    "#        where,\n",
+    "#                value_expression - a SQLAlchemy column expression on which function to be executed.\n",
+    "#                partition_by_expression - a SQLAlchemy column expression\n",
+    "#                order_by_expression - a SQLAlchemy column expression for sorting\n",
+    "#                                      ordering can be done in Ascending or Descending order with NULLS FIRST or NULLS LAST\n",
+    "#                rows_ = Define a window"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.Over"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Example returns by id last gpa in the moving average group.\n",
+    "last_value_ = func.last_value(admissions_train.gpa.expression).over(order_by=admissions_train.id.expression, rows=(-3, 1))\n",
+    "type(last_value_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, last_value(gpa) OVER (ORDER BY id ROWS BETWEEN 3 PRECEDING AND 1 FOLLOWING) AS last_value_gpa from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  last_value_gpa\n",
+      "id                                                              \n",
+      "3       no  3.70    Novice    Beginner         1            3.50\n",
+      "5       no  3.44    Novice      Novice         0            3.50\n",
+      "6      yes  3.50  Beginner    Advanced         1            2.33\n",
+      "7      yes  2.33    Novice      Novice         1            3.60\n",
+      "9       no  3.82  Advanced    Advanced         1            3.71\n",
+      "10      no  3.71  Advanced    Advanced         1            3.13\n",
+      "8       no  3.60  Beginner    Advanced         1            3.82\n",
+      "4      yes  3.50  Beginner      Novice         1            3.44\n",
+      "2      yes  3.76  Beginner    Beginner         0            3.70\n",
+      "1      yes  3.95  Beginner    Beginner         0            3.76\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                  int\n",
+      "masters             str\n",
+      "gpa               float\n",
+      "stats               str\n",
+      "programming         str\n",
+      "admitted            int\n",
+      "last_value_gpa    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'last_value_gpa' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "lv_gpa_df = admissions_train.assign(last_value_gpa=last_value_)\n",
+    "print_variables(lv_gpa_df, \"last_value_gpa\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### LEAD function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.Over"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Example returns by id last gpa in the moving average group.\n",
+    "lead_value_ = func.lead(admissions_train.gpa.expression, 3, \n",
+    "                        admissions_train.admitted.expression).over(order_by=admissions_train.id.expression)\n",
+    "type(lead_value_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, lead(gpa, 3, admitted) OVER (ORDER BY id) AS lead_value_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  lead_value_col\n",
+      "id                                                              \n",
+      "3       no  3.70    Novice    Beginner         1            3.50\n",
+      "5       no  3.44    Novice      Novice         0            3.60\n",
+      "6      yes  3.50  Beginner    Advanced         1            3.82\n",
+      "7      yes  2.33    Novice      Novice         1            3.71\n",
+      "9       no  3.82  Advanced    Advanced         1            3.65\n",
+      "10      no  3.71  Advanced    Advanced         1            4.00\n",
+      "8       no  3.60  Beginner    Advanced         1            3.13\n",
+      "4      yes  3.50  Beginner      Novice         1            2.33\n",
+      "2      yes  3.76  Beginner    Beginner         0            3.44\n",
+      "1      yes  3.95  Beginner    Beginner         0            3.50\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                  int\n",
+      "masters             str\n",
+      "gpa               float\n",
+      "stats               str\n",
+      "programming         str\n",
+      "admitted            int\n",
+      "lead_value_col    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'lead_value_col' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "lead_gpa_df = admissions_train.assign(lead_value_col=lead_value_)\n",
+    "print_variables(lead_gpa_df, \"lead_value_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### LAG function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.Over"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Example returns by id last gpa in the moving average group.\n",
+    "lag_value_ = func.LAG(admissions_train.gpa.expression, 3, \n",
+    "                        admissions_train.admitted.expression).over(order_by=admissions_train.id.expression)\n",
+    "type(lag_value_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, LAG(gpa, 3, admitted) OVER (ORDER BY id) AS lag_value_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  lag_value_col\n",
+      "id                                                             \n",
+      "3       no  3.70    Novice    Beginner         1           1.00\n",
+      "5       no  3.44    Novice      Novice         0           3.76\n",
+      "6      yes  3.50  Beginner    Advanced         1           3.70\n",
+      "7      yes  2.33    Novice      Novice         1           3.50\n",
+      "9       no  3.82  Advanced    Advanced         1           3.50\n",
+      "10      no  3.71  Advanced    Advanced         1           2.33\n",
+      "8       no  3.60  Beginner    Advanced         1           3.44\n",
+      "4      yes  3.50  Beginner      Novice         1           3.95\n",
+      "2      yes  3.76  Beginner    Beginner         0           0.00\n",
+      "1      yes  3.95  Beginner    Beginner         0           0.00\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                 int\n",
+      "masters            str\n",
+      "gpa              float\n",
+      "stats              str\n",
+      "programming        str\n",
+      "admitted           int\n",
+      "lag_value_col    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'lag_value_col' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "lag_gpa_df = admissions_train.assign(lag_value_col=lag_value_)\n",
+    "print_variables(lag_gpa_df, \"lag_value_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### MAVG Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Computes the moving average of a value expression for each row in a partition using the specified value expression \n",
+    "# for the current row and the preceding width-1 rows."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mavg_ = func.mavg(admissions_train.gpa.expression, 3, admissions_train.id.expression)\n",
+    "type(mavg_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, mavg(gpa, 3, id) AS mavg_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  mavg_col\n",
+      "id                                                        \n",
+      "3       no  3.70    Novice    Beginner         1  3.803333\n",
+      "5       no  3.44    Novice      Novice         0  3.546667\n",
+      "6      yes  3.50  Beginner    Advanced         1  3.480000\n",
+      "7      yes  2.33    Novice      Novice         1  3.090000\n",
+      "9       no  3.82  Advanced    Advanced         1  3.250000\n",
+      "10      no  3.71  Advanced    Advanced         1  3.710000\n",
+      "8       no  3.60  Beginner    Advanced         1  3.143333\n",
+      "4      yes  3.50  Beginner      Novice         1  3.653333\n",
+      "2      yes  3.76  Beginner    Beginner         0  3.855000\n",
+      "1      yes  3.95  Beginner    Beginner         0  3.950000\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id               int\n",
+      "masters          str\n",
+      "gpa            float\n",
+      "stats            str\n",
+      "programming      str\n",
+      "admitted         int\n",
+      "mavg_col       float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'mavg_col' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "mavg_df = admissions_train.assign(mavg_col=mavg_)\n",
+    "print_variables(mavg_df, \"mavg_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### MDIFF Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns the moving difference between the specified value expression for the current row and the preceding width rows \n",
+    "# for each row in the partition."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mdiff_ = func.mdiff(admissions_train.gpa.expression, 3, admissions_train.id.expression)\n",
+    "type(mdiff_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, mdiff(gpa, 3, id) AS mdiff_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  mdiff_col\n",
+      "id                                                         \n",
+      "3       no  3.70    Novice    Beginner         1        NaN\n",
+      "5       no  3.44    Novice      Novice         0      -0.32\n",
+      "6      yes  3.50  Beginner    Advanced         1      -0.20\n",
+      "7      yes  2.33    Novice      Novice         1      -1.17\n",
+      "9       no  3.82  Advanced    Advanced         1       0.32\n",
+      "10      no  3.71  Advanced    Advanced         1       1.38\n",
+      "8       no  3.60  Beginner    Advanced         1       0.16\n",
+      "4      yes  3.50  Beginner      Novice         1      -0.45\n",
+      "2      yes  3.76  Beginner    Beginner         0        NaN\n",
+      "1      yes  3.95  Beginner    Beginner         0        NaN\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id               int\n",
+      "masters          str\n",
+      "gpa            float\n",
+      "stats            str\n",
+      "programming      str\n",
+      "admitted         int\n",
+      "mdiff_col      float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'mdiff_col' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "mdiff_df = admissions_train.assign(mdiff_col=mdiff_)\n",
+    "print_variables(mdiff_df, \"mdiff_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Median function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 42,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "median_ = func.median(admissions_train.gpa.expression)\n",
+    "type(median_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select median(gpa) AS median_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   median_col\n",
+      "0        3.69\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "median_col    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'median_col' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "median_df = admissions_train.assign(True, median_col=median_)\n",
+    "print_variables(median_df, \"median_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### MLINREG function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns a predicted value for an expression based on a least squares moving linear regression of the previous \n",
+    "# width -1 (based on sort_expression) column values."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "MLINREG_ = func.MLINREG(admissions_train.gpa.expression, 3, admissions_train.id.expression)\n",
+    "type(MLINREG_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, MLINREG(gpa, 3, id) AS \"MLINREG_col\" from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  MLINREG_col\n",
+      "id                                                           \n",
+      "3       no  3.70    Novice    Beginner         1         3.57\n",
+      "5       no  3.44    Novice      Novice         0         3.30\n",
+      "6      yes  3.50  Beginner    Advanced         1         3.38\n",
+      "7      yes  2.33    Novice      Novice         1         3.56\n",
+      "9       no  3.82  Advanced    Advanced         1         4.87\n",
+      "10      no  3.71  Advanced    Advanced         1         4.04\n",
+      "8       no  3.60  Beginner    Advanced         1         1.16\n",
+      "4      yes  3.50  Beginner      Novice         1         3.64\n",
+      "2      yes  3.76  Beginner    Beginner         0          NaN\n",
+      "1      yes  3.95  Beginner    Beginner         0          NaN\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id               int\n",
+      "masters          str\n",
+      "gpa            float\n",
+      "stats            str\n",
+      "programming      str\n",
+      "admitted         int\n",
+      "MLINREG_col    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'MLINREG_col' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "MLINREG_df = admissions_train.assign(MLINREG_col=MLINREG_)\n",
+    "print_variables(MLINREG_df, \"MLINREG_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### MSUM function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Computes the moving sum specified by a value expression for the current row and the preceding n-1 rows. \n",
+    "# This function is very similar to the MAVG function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 48,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "msum_ = func.msum(admissions_train.gpa.expression, 3, admissions_train.id.expression)\n",
+    "type(msum_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, msum(gpa, 3, id) AS msum_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  msum_col\n",
+      "id                                                        \n",
+      "3       no  3.70    Novice    Beginner         1     11.41\n",
+      "5       no  3.44    Novice      Novice         0     10.64\n",
+      "6      yes  3.50  Beginner    Advanced         1     10.44\n",
+      "7      yes  2.33    Novice      Novice         1      9.27\n",
+      "9       no  3.82  Advanced    Advanced         1      9.75\n",
+      "10      no  3.71  Advanced    Advanced         1     11.13\n",
+      "8       no  3.60  Beginner    Advanced         1      9.43\n",
+      "4      yes  3.50  Beginner      Novice         1     10.96\n",
+      "2      yes  3.76  Beginner    Beginner         0      7.71\n",
+      "1      yes  3.95  Beginner    Beginner         0      3.95\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id               int\n",
+      "masters          str\n",
+      "gpa            float\n",
+      "stats            str\n",
+      "programming      str\n",
+      "admitted         int\n",
+      "msum_col       float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'msum_col' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "msum_df = admissions_train.assign(msum_col=msum_)\n",
+    "print_variables(msum_df, \"msum_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### PERCENT_RANK function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns the relative rank of rows for a value_expression."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.Over"
+      ]
+     },
+     "execution_count": 51,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Get the ordered ranking based on stats.\n",
+    "percent_rank_ = func.percent_rank().over(order_by=admissions_train.id.expression.desc())\n",
+    "type(percent_rank_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, percent_rank() OVER (ORDER BY id DESC) AS percent_rank_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  percent_rank_col\n",
+      "id                                                                \n",
+      "38     yes  2.65  Advanced    Beginner         1          0.051282\n",
+      "36      no  3.00  Advanced      Novice         0          0.102564\n",
+      "35      no  3.68    Novice    Beginner         1          0.128205\n",
+      "34     yes  3.85  Advanced    Beginner         0          0.153846\n",
+      "32     yes  3.46  Advanced    Beginner         0          0.205128\n",
+      "31     yes  3.50  Advanced    Beginner         1          0.230769\n",
+      "33      no  3.55    Novice      Novice         1          0.179487\n",
+      "37      no  3.52    Novice      Novice         1          0.076923\n",
+      "39     yes  3.75  Advanced    Beginner         0          0.025641\n",
+      "40     yes  3.95    Novice    Beginner         0          0.000000\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                    int\n",
+      "masters               str\n",
+      "gpa                 float\n",
+      "stats                 str\n",
+      "programming           str\n",
+      "admitted              int\n",
+      "percent_rank_col    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'percent_rank_col' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "percent_rank_df = admissions_train.assign(percent_rank_col=percent_rank_)\n",
+    "print_variables(percent_rank_df, \"percent_rank_col\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.Over"
+      ]
+     },
+     "execution_count": 53,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Calculate cumulative distribution by id, partitioned over stats\n",
+    "percent_rank_ = func.percent_rank().over(partition_by=admissions_train.stats.expression, order_by=admissions_train.id.expression.desc())\n",
+    "type(percent_rank_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, percent_rank() OVER (PARTITION BY stats ORDER BY id DESC) AS percent_rank_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  percent_rank_col\n",
+      "id                                                                \n",
+      "4      yes  3.50  Beginner      Novice         1          0.500000\n",
+      "1      yes  3.95  Beginner    Beginner         0          1.000000\n",
+      "39     yes  3.75  Advanced    Beginner         0          0.000000\n",
+      "38     yes  2.65  Advanced    Beginner         1          0.043478\n",
+      "34     yes  3.85  Advanced    Beginner         0          0.130435\n",
+      "32     yes  3.46  Advanced    Beginner         0          0.173913\n",
+      "31     yes  3.50  Advanced    Beginner         1          0.217391\n",
+      "30     yes  3.79  Advanced      Novice         0          0.260870\n",
+      "28      no  3.93  Advanced    Advanced         1          0.304348\n",
+      "27     yes  3.96  Advanced    Advanced         0          0.347826\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                    int\n",
+      "masters               str\n",
+      "gpa                 float\n",
+      "stats                 str\n",
+      "programming           str\n",
+      "admitted              int\n",
+      "percent_rank_col    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'percent_rank_col' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "percent_rank_df = admissions_train.assign(percent_rank_col=percent_rank_)\n",
+    "print_variables(percent_rank_df, \"percent_rank_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Quantile Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 55,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "quantile_ = func.quantile(10, admissions_train.gpa.expression)\n",
+    "type(quantile_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, quantile(10, gpa) AS quantile_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  quantile_col\n",
+      "id                                                            \n",
+      "7      yes  2.33    Novice      Novice         1             0\n",
+      "36      no  3.00  Advanced      Novice         0             1\n",
+      "11      no  3.13  Advanced    Advanced         1             1\n",
+      "5       no  3.44    Novice      Novice         0             1\n",
+      "32     yes  3.46  Advanced    Beginner         0             2\n",
+      "22     yes  3.46    Novice    Beginner         0             2\n",
+      "14     yes  3.45  Advanced    Advanced         0             1\n",
+      "38     yes  2.65  Advanced    Beginner         1             0\n",
+      "19     yes  1.98  Advanced    Advanced         0             0\n",
+      "24      no  1.87  Advanced      Novice         1             0\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                int\n",
+      "masters           str\n",
+      "gpa             float\n",
+      "stats             str\n",
+      "programming       str\n",
+      "admitted          int\n",
+      "quantile_col      int\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'quantile_col' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "quantile_df = admissions_train.assign(quantile_col=quantile_)\n",
+    "print_variables(quantile_df, \"quantile_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### RANK function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.Over"
+      ]
+     },
+     "execution_count": 57,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Get the ordered ranking based on stats.\n",
+    "rank_ = func.rank().over(order_by=admissions_train.id.expression.desc())\n",
+    "type(rank_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, rank() OVER (ORDER BY id DESC) AS rank_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  rank_col\n",
+      "id                                                        \n",
+      "38     yes  2.65  Advanced    Beginner         1         3\n",
+      "36      no  3.00  Advanced      Novice         0         5\n",
+      "35      no  3.68    Novice    Beginner         1         6\n",
+      "34     yes  3.85  Advanced    Beginner         0         7\n",
+      "32     yes  3.46  Advanced    Beginner         0         9\n",
+      "31     yes  3.50  Advanced    Beginner         1        10\n",
+      "33      no  3.55    Novice      Novice         1         8\n",
+      "37      no  3.52    Novice      Novice         1         4\n",
+      "39     yes  3.75  Advanced    Beginner         0         2\n",
+      "40     yes  3.95    Novice    Beginner         0         1\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id               int\n",
+      "masters          str\n",
+      "gpa            float\n",
+      "stats            str\n",
+      "programming      str\n",
+      "admitted         int\n",
+      "rank_col         int\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'rank_col' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "rank_df = admissions_train.assign(rank_col=rank_)\n",
+    "print_variables(rank_df, \"rank_col\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.Over"
+      ]
+     },
+     "execution_count": 59,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Calculate cumulative distribution by id, partitioned over stats\n",
+    "rank_ = func.rank().over(partition_by=admissions_train.stats.expression, order_by=admissions_train.id.expression.desc())\n",
+    "type(rank_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, rank() OVER (PARTITION BY stats ORDER BY id DESC) AS rank_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  rank_col\n",
+      "id                                                        \n",
+      "36      no  3.00  Advanced      Novice         0         3\n",
+      "32     yes  3.46  Advanced    Beginner         0         5\n",
+      "31     yes  3.50  Advanced    Beginner         1         6\n",
+      "30     yes  3.79  Advanced      Novice         0         7\n",
+      "27     yes  3.96  Advanced    Advanced         0         9\n",
+      "26     yes  3.57  Advanced    Advanced         1        10\n",
+      "8       no  3.60  Beginner    Advanced         1         1\n",
+      "6      yes  3.50  Beginner    Advanced         1         2\n",
+      "4      yes  3.50  Beginner      Novice         1         3\n",
+      "2      yes  3.76  Beginner    Beginner         0         4\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id               int\n",
+      "masters          str\n",
+      "gpa            float\n",
+      "stats            str\n",
+      "programming      str\n",
+      "admitted         int\n",
+      "rank_col         int\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'rank_col' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "rank_df = admissions_train.assign(rank_col=rank_)\n",
+    "print_variables(rank_df, \"rank_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ROW_NUMBER function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.Over"
+      ]
+     },
+     "execution_count": 61,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Get the ordered ranking based on stats.\n",
+    "row_num_ = func.row_number().over(order_by=admissions_train.id.expression.desc())\n",
+    "type(row_num_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, row_number() OVER (ORDER BY id DESC) AS row_num_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  row_num_col\n",
+      "id                                                           \n",
+      "38     yes  2.65  Advanced    Beginner         1            3\n",
+      "36      no  3.00  Advanced      Novice         0            5\n",
+      "35      no  3.68    Novice    Beginner         1            6\n",
+      "34     yes  3.85  Advanced    Beginner         0            7\n",
+      "32     yes  3.46  Advanced    Beginner         0            9\n",
+      "31     yes  3.50  Advanced    Beginner         1           10\n",
+      "33      no  3.55    Novice      Novice         1            8\n",
+      "37      no  3.52    Novice      Novice         1            4\n",
+      "39     yes  3.75  Advanced    Beginner         0            2\n",
+      "40     yes  3.95    Novice    Beginner         0            1\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id               int\n",
+      "masters          str\n",
+      "gpa            float\n",
+      "stats            str\n",
+      "programming      str\n",
+      "admitted         int\n",
+      "row_num_col      int\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'row_num_col' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "row_num_df = admissions_train.assign(row_num_col=row_num_)\n",
+    "print_variables(row_num_df, \"row_num_col\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.Over"
+      ]
+     },
+     "execution_count": 63,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Calculate cumulative distribution by id, partitioned over stats\n",
+    "row_num_ = func.row_number().over(partition_by=admissions_train.stats.expression, order_by=admissions_train.id.expression.desc())\n",
+    "type(row_num_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, row_number() OVER (PARTITION BY stats ORDER BY id DESC) AS row_num_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  row_num_col\n",
+      "id                                                           \n",
+      "36      no  3.00  Advanced      Novice         0            3\n",
+      "32     yes  3.46  Advanced    Beginner         0            5\n",
+      "31     yes  3.50  Advanced    Beginner         1            6\n",
+      "30     yes  3.79  Advanced      Novice         0            7\n",
+      "27     yes  3.96  Advanced    Advanced         0            9\n",
+      "26     yes  3.57  Advanced    Advanced         1           10\n",
+      "8       no  3.60  Beginner    Advanced         1            1\n",
+      "6      yes  3.50  Beginner    Advanced         1            2\n",
+      "4      yes  3.50  Beginner      Novice         1            3\n",
+      "2      yes  3.76  Beginner    Beginner         0            4\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id               int\n",
+      "masters          str\n",
+      "gpa            float\n",
+      "stats            str\n",
+      "programming      str\n",
+      "admitted         int\n",
+      "row_num_col      int\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'row_num_col' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "row_num_df = admissions_train.assign(row_num_col=row_num_)\n",
+    "print_variables(row_num_df, \"row_num_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### AVG function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.elements.Over"
+      ]
+     },
+     "execution_count": 65,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "### Let's get the mean gpa withing the window partitioned over stats and odered by id.\n",
+    "### SQL Clause Equivalent: \"AVG(gpa) OVER(PARTION BY stats ORDER BY id)\"\n",
+    "avggpa_part_ord = func.avg(admissions_train.gpa.expression).over(partition_by=admissions_train.stats.expression, \n",
+    "                                                                 order_by=admissions_train.id.expression)\n",
+    "type(avggpa_part_ord)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, avg(gpa) OVER (PARTITION BY stats ORDER BY id) AS win_avg_gpa from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  win_avg_gpa\n",
+      "id                                                           \n",
+      "11      no  3.13  Advanced    Advanced         1      3.50875\n",
+      "14     yes  3.45  Advanced    Advanced         0      3.50875\n",
+      "15     yes  4.00  Advanced    Advanced         1      3.50875\n",
+      "16      no  3.70  Advanced    Advanced         1      3.50875\n",
+      "18     yes  3.81  Advanced    Advanced         1      3.50875\n",
+      "19     yes  1.98  Advanced    Advanced         0      3.50875\n",
+      "1      yes  3.95  Beginner    Beginner         0      3.66200\n",
+      "2      yes  3.76  Beginner    Beginner         0      3.66200\n",
+      "4      yes  3.50  Beginner      Novice         1      3.66200\n",
+      "6      yes  3.50  Beginner    Advanced         1      3.66200\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id               int\n",
+      "masters          str\n",
+      "gpa            float\n",
+      "stats            str\n",
+      "programming      str\n",
+      "admitted         int\n",
+      "win_avg_gpa    float\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'win_avg_gpa' Column Type: FLOAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "avg_df = admissions_train.assign(win_avg_gpa=avggpa_part_ord)\n",
+    "print_variables(avg_df, \"win_avg_gpa\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Use cases for creating a window using ROWS BETWEEN syntax "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Teradata offers various types of computations on windowed aggregate fucntions. Each computation \n",
+    "#     1. Cumulative\n",
+    "#     2. Group\n",
+    "#     3. Moving\n",
+    "#     4. Remaining\n",
+    "# Each computation above can be performed using ROWS or ROWS BETWEEN syntax. Let's take a look at \n",
+    "# examples of each type of computation.\n",
+    "\n",
+    "# To perform windowed aggregate function over a window using ROWS and ROWS BETWEEN one must use \n",
+    "# argument \"rows\" in over which accepts a tuple (p, f).\n",
+    "# Where,\n",
+    "#    p and f can accept Negative Integer Value, Positive Integer Value, 0 or None.\n",
+    "#    Each value passed to p and f have different meaning or results in different syntax.\n",
+    "#    In general, this what these values mean, i.e., SQL syntax will be generated based on these values.\n",
+    "#        1. Negative Value --> Indicates a preceding value\n",
+    "#        2. Positive Value --> Indiacates a following value\n",
+    "#        3. 0 --> For Current row\n",
+    "#        4. None --> Unbounded value.\n",
+    "#"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Windowed aggregation using 'Cumulative' Computation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## To perform \"Cumulative\" computation for a windowed aggregate fucntion, \n",
+    "## one should use following SQL Syntax for such cases is:\n",
+    "\n",
+    "#    1. ROWS UNBOUNDED PRECEDING ------------> No support available for this in SQLAlchemy. Needs more investigation.\n",
+    "#    2. ROWS BETWEEN UNBOUNDED PRECEDING AND value PRECEDING ---> rows=(None, negative value)\n",
+    "#    3. ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW ---> rows=(None, 0)\n",
+    "#    4. ROWS BETWEEN UNBOUNDED PRECEDING AND value FOLLOWING ---> rows=(None, positive value)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, sum(gpa) OVER (ORDER BY stats ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING) AS cumsum_gpa from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  cumsum_gpa\n",
+      "id                                                          \n",
+      "15     yes  4.00  Advanced    Advanced         1        6.48\n",
+      "24      no  1.87  Advanced      Novice         1       14.38\n",
+      "25      no  3.96  Advanced    Advanced         1       16.25\n",
+      "16      no  3.70  Advanced    Advanced         1       20.21\n",
+      "34     yes  3.85  Advanced    Beginner         0       25.89\n",
+      "14     yes  3.45  Advanced    Advanced         0       29.74\n",
+      "19     yes  1.98  Advanced    Advanced         0       23.91\n",
+      "20     yes  3.90  Advanced    Advanced         1       10.48\n",
+      "38     yes  2.65  Advanced    Beginner         1        3.83\n",
+      "17      no  3.83  Advanced    Advanced         1         NaN\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id               int\n",
+      "masters          str\n",
+      "gpa            float\n",
+      "stats            str\n",
+      "programming      str\n",
+      "admitted         int\n",
+      "cumsum_gpa     float\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Example to return Cumulative sum of gpa over a window of ROWS BETWEEN UNBOUNDED PRECEDING AND value PRECEDING\n",
+    "# ROWS BETWEEN UNBOUNDED PRECEDING AND value PRECEDING ---> rows=(None, negative value)\n",
+    "sum_gpa_rbupavp = func.sum(admissions_train.gpa.expression).over(order_by=admissions_train.stats.expression, rows=(None, -1))\n",
+    "df = admissions_train.assign(cumsum_gpa=sum_gpa_rbupavp)\n",
+    "print_variables(df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, sum(gpa) OVER (ORDER BY stats ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS sqlalchemy_gpa from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  sqlalchemy_gpa\n",
+      "id                                                              \n",
+      "13      no  4.00  Advanced      Novice         1            9.98\n",
+      "23     yes  3.59  Advanced      Novice         1           17.02\n",
+      "38     yes  2.65  Advanced    Beginner         1           19.67\n",
+      "36      no  3.00  Advanced      Novice         0           22.67\n",
+      "30     yes  3.79  Advanced      Novice         0           30.29\n",
+      "18     yes  3.81  Advanced    Advanced         1           34.10\n",
+      "17      no  3.83  Advanced    Advanced         1           26.50\n",
+      "14     yes  3.45  Advanced    Advanced         0           13.43\n",
+      "19     yes  1.98  Advanced    Advanced         0            5.98\n",
+      "15     yes  4.00  Advanced    Advanced         1            4.00\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                  int\n",
+      "masters             str\n",
+      "gpa               float\n",
+      "stats               str\n",
+      "programming         str\n",
+      "admitted            int\n",
+      "sqlalchemy_gpa    float\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Example to return Cumulative sum of gpa over a window of Rows between ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n",
+    "# ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW ---> rows=(None, 0)\n",
+    "sum_gpa_rbupavp = func.sum(admissions_train.gpa.expression).over(order_by=admissions_train.stats.expression, rows=(None, 0))\n",
+    "df = admissions_train.assign(sqlalchemy_gpa=sum_gpa_rbupavp)\n",
+    "print_variables(df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, sum(gpa) OVER (ORDER BY stats ROWS BETWEEN UNBOUNDED PRECEDING AND 2 FOLLOWING) AS sqlalchemy_gpa from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  sqlalchemy_gpa\n",
+      "id                                                              \n",
+      "15     yes  4.00  Advanced    Advanced         1           16.25\n",
+      "24      no  1.87  Advanced      Novice         1           23.91\n",
+      "25      no  3.96  Advanced    Advanced         1           25.89\n",
+      "16      no  3.70  Advanced    Advanced         1           29.74\n",
+      "34     yes  3.85  Advanced    Beginner         0           36.65\n",
+      "14     yes  3.45  Advanced    Advanced         0           40.47\n",
+      "19     yes  1.98  Advanced    Advanced         0           33.19\n",
+      "20     yes  3.90  Advanced    Advanced         1           20.21\n",
+      "38     yes  2.65  Advanced    Beginner         1           14.38\n",
+      "17      no  3.83  Advanced    Advanced         1           10.48\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                  int\n",
+      "masters             str\n",
+      "gpa               float\n",
+      "stats               str\n",
+      "programming         str\n",
+      "admitted            int\n",
+      "sqlalchemy_gpa    float\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "### ROWS BETWEEN UNBOUNDED PRECEDING AND value FOLLOWING ---> rows=(None, positive value)\n",
+    "sum_gpa_rbupavf = func.sum(admissions_train.gpa.expression).over(order_by=admissions_train.stats.expression, rows=(None, 2))\n",
+    "df = admissions_train.assign(sqlalchemy_gpa=sum_gpa_rbupavf)\n",
+    "print_variables(df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Windowed aggregation using 'Group' Computation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Using \"GROUP\" computation.\n",
+    "## SQL Syntax for such cases is:\n",
+    "### ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING ---> rows=(None, None)\n",
+    "### OR using no \"rows\" argument at all."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, sum(gpa) OVER (ORDER BY stats ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) AS sqlalchemy_gpa from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  sqlalchemy_gpa\n",
+      "id                                                              \n",
+      "13      no  4.00  Advanced      Novice         1          141.67\n",
+      "23     yes  3.59  Advanced      Novice         1          141.67\n",
+      "38     yes  2.65  Advanced    Beginner         1          141.67\n",
+      "36      no  3.00  Advanced      Novice         0          141.67\n",
+      "30     yes  3.79  Advanced      Novice         0          141.67\n",
+      "18     yes  3.81  Advanced    Advanced         1          141.67\n",
+      "17      no  3.83  Advanced    Advanced         1          141.67\n",
+      "14     yes  3.45  Advanced    Advanced         0          141.67\n",
+      "19     yes  1.98  Advanced    Advanced         0          141.67\n",
+      "15     yes  4.00  Advanced    Advanced         1          141.67\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                  int\n",
+      "masters             str\n",
+      "gpa               float\n",
+      "stats               str\n",
+      "programming         str\n",
+      "admitted            int\n",
+      "sqlalchemy_gpa    float\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "### ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING ---> rows=(None, None)\n",
+    "sum_gpa_rbupauf = func.sum(admissions_train.gpa.expression).over(order_by=admissions_train.stats.expression, rows=(None, None))\n",
+    "df = admissions_train.assign(sqlalchemy_gpa=sum_gpa_rbupauf)\n",
+    "print_variables(df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Windowed aggregation using 'Moving' Computation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Using \"Moving\" computation.\n",
+    "## SQL Syntax for such cases is:\n",
+    "### ROWS value PRECEDING ------------> No support available for this in SQLAlchemy.\n",
+    "### ROWS CURRENT ROW     ------------> No support available for this in SQLAlchemy.\n",
+    "\n",
+    "#\n",
+    "# Values accepted by rows argument:\n",
+    "#      1. Negative Value --> Indicates a preceding value\n",
+    "#      2. Positive Value --> Indiacates a following value\n",
+    "#      3. 0 --> For Current row\n",
+    "#      4. None --> Unbounded value.\n",
+    "\n",
+    "\n",
+    "### ROWS BETWEEN value PRECEDING AND value PRECEDING ---> rows=(Negative Value, Negative Value)\n",
+    "### ROWS BETWEEN value PRECEDING AND CURRENT ROW ---> rows=(Negative Value, 0)\n",
+    "### ROWS BETWEEN value PRECEDING AND value FOLLOWING ---> rows=(Negative Value, Positive Value)\n",
+    "### ROWS BETWEEN CURRENT ROW AND CURRENT ROW ---> rows=(0, 0)\n",
+    "### ROWS BETWEEN CURRENT ROW AND value FOLLOWING ---> rows=(0, Positive Value)\n",
+    "### ROWS BETWEEN value FOLLOWING AND value FOLLOWING ---> rows=(Positive Value, Positive Value)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, sum(gpa) OVER (ORDER BY stats ROWS BETWEEN 3 PRECEDING AND 1 PRECEDING) AS sqlalchemy_gpa from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  sqlalchemy_gpa\n",
+      "id                                                              \n",
+      "15     yes  4.00  Advanced    Advanced         1            6.48\n",
+      "24      no  1.87  Advanced      Novice         1           10.55\n",
+      "25      no  3.96  Advanced    Advanced         1            9.77\n",
+      "16      no  3.70  Advanced    Advanced         1            9.73\n",
+      "34     yes  3.85  Advanced    Beginner         0            9.64\n",
+      "14     yes  3.45  Advanced    Advanced         0            9.53\n",
+      "19     yes  1.98  Advanced    Advanced         0            9.53\n",
+      "20     yes  3.90  Advanced    Advanced         1           10.48\n",
+      "38     yes  2.65  Advanced    Beginner         1            3.83\n",
+      "17      no  3.83  Advanced    Advanced         1             NaN\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                  int\n",
+      "masters             str\n",
+      "gpa               float\n",
+      "stats               str\n",
+      "programming         str\n",
+      "admitted            int\n",
+      "sqlalchemy_gpa    float\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "### ROWS BETWEEN value PRECEDING AND value PRECEDING ---> rows=(-3, -1)\n",
+    "sum_gpa_rbupauf = func.sum(admissions_train.gpa.expression).over(order_by=admissions_train.stats.expression, rows=(-3, -1))\n",
+    "df = admissions_train.assign(sqlalchemy_gpa=sum_gpa_rbupauf)\n",
+    "print_variables(df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, sum(gpa) OVER (ORDER BY stats ROWS BETWEEN CURRENT ROW AND CURRENT ROW) AS sqlalchemy_gpa from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  sqlalchemy_gpa\n",
+      "id                                                              \n",
+      "13      no  4.00  Advanced      Novice         1            4.00\n",
+      "23     yes  3.59  Advanced      Novice         1            3.59\n",
+      "38     yes  2.65  Advanced    Beginner         1            2.65\n",
+      "36      no  3.00  Advanced      Novice         0            3.00\n",
+      "30     yes  3.79  Advanced      Novice         0            3.79\n",
+      "18     yes  3.81  Advanced    Advanced         1            3.81\n",
+      "17      no  3.83  Advanced    Advanced         1            3.83\n",
+      "14     yes  3.45  Advanced    Advanced         0            3.45\n",
+      "19     yes  1.98  Advanced    Advanced         0            1.98\n",
+      "15     yes  4.00  Advanced    Advanced         1            4.00\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                  int\n",
+      "masters             str\n",
+      "gpa               float\n",
+      "stats               str\n",
+      "programming         str\n",
+      "admitted            int\n",
+      "sqlalchemy_gpa    float\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "### ROWS BETWEEN CURRENT ROW AND CURRENT ROW ---> rows=(0, 0)\n",
+    "sum_gpa_rbcr = func.sum(admissions_train.gpa.expression).over(order_by=admissions_train.stats.expression, rows=(0, 0))\n",
+    "df = admissions_train.assign(sqlalchemy_gpa=sum_gpa_rbcr)\n",
+    "print_variables(df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, sum(gpa) OVER (ORDER BY stats ROWS BETWEEN CURRENT ROW AND 3 FOLLOWING) AS sqlalchemy_gpa from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  sqlalchemy_gpa\n",
+      "id                                                              \n",
+      "15     yes  4.00  Advanced    Advanced         1           13.73\n",
+      "24      no  1.87  Advanced      Novice         1           11.51\n",
+      "25      no  3.96  Advanced    Advanced         1           13.49\n",
+      "16      no  3.70  Advanced    Advanced         1           12.98\n",
+      "34     yes  3.85  Advanced    Beginner         0           14.58\n",
+      "14     yes  3.45  Advanced    Advanced         0           14.23\n",
+      "19     yes  1.98  Advanced    Advanced         0           12.74\n",
+      "20     yes  3.90  Advanced    Advanced         1           13.43\n",
+      "38     yes  2.65  Advanced    Beginner         1           12.42\n",
+      "17      no  3.83  Advanced    Advanced         1           14.38\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                  int\n",
+      "masters             str\n",
+      "gpa               float\n",
+      "stats               str\n",
+      "programming         str\n",
+      "admitted            int\n",
+      "sqlalchemy_gpa    float\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "### ROWS BETWEEN CURRENT ROW AND 3 FOLLOWING ---> rows=(0, 3)\n",
+    "sum_gpa_rbcr3f = func.sum(admissions_train.gpa.expression).over(order_by=admissions_train.stats.expression, rows=(0, 3))\n",
+    "df = admissions_train.assign(sqlalchemy_gpa=sum_gpa_rbcr3f)\n",
+    "print_variables(df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Windowed aggregation using 'Remaining' Computation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Using \"REMAINING\" computation.\n",
+    "## SQL Syntax for such cases is:\n",
+    "\n",
+    "# Values accepted by rows argument:\n",
+    "#      1. Negative Value --> Indicates a preceding value\n",
+    "#      2. Positive Value --> Indiacates a following value\n",
+    "#      3. 0 --> For Current row\n",
+    "#      4. None --> Unbounded value.\n",
+    "\n",
+    "### ROWS BETWEEN value PRECEDING AND UNBOUNDED FOLLOWING ---> rows=(Negative Value, None)\n",
+    "### ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING ---> rows=(0, None)\n",
+    "### ROWS BETWEEN value FOLLOWING AND UNBOUNDED FOLLOWING ---> rows=(Positive Value, None)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 79,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, sum(gpa) OVER (ORDER BY stats ROWS BETWEEN 5 PRECEDING AND UNBOUNDED FOLLOWING) AS sqlalchemy_gpa from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa   stats programming  admitted  sqlalchemy_gpa\n",
+      "id                                                            \n",
+      "3       no  3.70  Novice    Beginner         1           27.68\n",
+      "21      no  3.87  Novice    Beginner         1           35.20\n",
+      "35      no  3.68  Novice    Beginner         1           39.15\n",
+      "33      no  3.55  Novice      Novice         1           43.10\n",
+      "37      no  3.52  Novice      Novice         1           50.46\n",
+      "29     yes  4.00  Novice    Beginner         0           53.96\n",
+      "22     yes  3.46  Novice    Beginner         0           46.70\n",
+      "12      no  3.65  Novice      Novice         1           31.20\n",
+      "7      yes  2.33  Novice      Novice         1           24.22\n",
+      "5       no  3.44  Novice      Novice         0           20.67\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                  int\n",
+      "masters             str\n",
+      "gpa               float\n",
+      "stats               str\n",
+      "programming         str\n",
+      "admitted            int\n",
+      "sqlalchemy_gpa    float\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "### ROWS BETWEEN 5 PRECEDING AND UNBOUNDED FOLLOWING ---> rows=(-5, None)\n",
+    "sum_gpa_rb5puf = func.sum(admissions_train.gpa.expression).over(order_by=admissions_train.stats.expression, rows=(-5, None))\n",
+    "df = admissions_train.assign(sqlalchemy_gpa=sum_gpa_rb5puf)\n",
+    "print_variables(df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 80,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, sum(gpa) OVER (ORDER BY stats ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) AS sqlalchemy_gpa from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa   stats programming  admitted  sqlalchemy_gpa\n",
+      "id                                                            \n",
+      "29     yes  4.00  Novice    Beginner         0           10.99\n",
+      "35      no  3.68  Novice    Beginner         1           18.37\n",
+      "37      no  3.52  Novice      Novice         1           21.89\n",
+      "40     yes  3.95  Novice    Beginner         0           25.84\n",
+      "12      no  3.65  Novice      Novice         1           31.82\n",
+      "22     yes  3.46  Novice    Beginner         0           35.28\n",
+      "7      yes  2.33  Novice      Novice         1           28.17\n",
+      "3       no  3.70  Novice    Beginner         1           14.69\n",
+      "33      no  3.55  Novice      Novice         1            6.99\n",
+      "5       no  3.44  Novice      Novice         0            3.44\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                  int\n",
+      "masters             str\n",
+      "gpa               float\n",
+      "stats               str\n",
+      "programming         str\n",
+      "admitted            int\n",
+      "sqlalchemy_gpa    float\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "### ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING ---> rows=(0, None)\n",
+    "sum_gpa_rbcruf = func.sum(admissions_train.gpa.expression).over(order_by=admissions_train.stats.expression, rows=(0, None))\n",
+    "df = admissions_train.assign(sqlalchemy_gpa=sum_gpa_rbcruf)\n",
+    "print_variables(df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 81,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select id AS id, masters AS masters, gpa AS gpa, stats AS stats, programming AS programming, admitted AS admitted, AVG(admitted) OVER (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) AS sqlalchemy_gpa from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  sqlalchemy_gpa\n",
+      "id                                                              \n",
+      "38     yes  2.65  Advanced    Beginner         1        0.333333\n",
+      "36      no  3.00  Advanced      Novice         0        0.400000\n",
+      "35      no  3.68    Novice    Beginner         1        0.500000\n",
+      "34     yes  3.85  Advanced    Beginner         0        0.428571\n",
+      "32     yes  3.46  Advanced    Beginner         0        0.444444\n",
+      "31     yes  3.50  Advanced    Beginner         1        0.500000\n",
+      "33      no  3.55    Novice      Novice         1        0.500000\n",
+      "37      no  3.52    Novice      Novice         1        0.500000\n",
+      "39     yes  3.75  Advanced    Beginner         0        0.000000\n",
+      "40     yes  3.95    Novice    Beginner         0        0.000000\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "id                  int\n",
+      "masters             str\n",
+      "gpa               float\n",
+      "stats               str\n",
+      "programming         str\n",
+      "admitted            int\n",
+      "sqlalchemy_gpa    float\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "### ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING ---> rows=(0, None)\n",
+    "sum_gpa_rbcruf = func.AVG(admissions_train.admitted.expression).over(order_by=admissions_train.id.expression, rows=(0, None))\n",
+    "df = admissions_train.assign(sqlalchemy_gpa=sum_gpa_rbcruf)\n",
+    "print_variables(df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 82,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Following Teradatda SQL syntaxes are not supported by SQLAlchemy.\n",
+    "# 1. RESET WHEN clause.\n",
+    "# 2. ROWS UNBOUNDED PRECEDING, ROWS value PRECEDING, ROWS CURRENT ROW\n",
+    "\n",
+    "### SQLAlchemy offers range over in Window aggregate, Teradata does not support the same. \n",
+    "# For example, \"RANGE BETWEEN 5 PRECEDING AND 10 FOLLOWING\" is not supported"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 83,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 83,
+     "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": []
+  },
+  {
+   "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
+}