teradataml 20.0.0.8__py3-none-any.whl

teradataml/data/notebooks/sqlalchemy/Teradata Vantage String Functions Using SQLAlchemy.ipynb

@@ -0,0 +1,2559 @@
+{
+ "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 String Functions:\n",
+    "# SQL Documentation: https://docs.teradata.com/reader/756LNiPSFdY~4JcCCcR5Cw/c2fX4dzxCcDJFKqXbyQtTA\n",
+    "    # 1. cahr2hexint\n",
+    "    # 2. ascii\n",
+    "    # 3. concat\n",
+    "    # 4. editdistance\n",
+    "    # 5. index\n",
+    "    # 6. instr\n",
+    "    # 7. length\n",
+    "    # 8. locate\n",
+    "    # 9. nvp\n",
+    "    # 10. otranslate\n",
+    "    # 11. reverse\n",
+    "    # 12. soundex\n",
+    "    # 13. string_cs\n",
+    "    # 14. REGR_R2\n",
+    "    # 15. REGR_SXX\n",
+    "    # 16. REGR_SXY\n",
+    "    # 17. REGR_SYY\n",
+    "    # 18. char\n",
+    "    # 19. initcap\n",
+    "    # 20. left\n",
+    "    # 21. lower\n",
+    "    # 22. upper\n",
+    "    # 23. lpad\n",
+    "    # 24. ltrim\n",
+    "    # 25. ngram\n",
+    "    # 26. oreplace\n",
+    "    # 27. position\n",
+    "    # 28. right\n",
+    "    # 29. rpad\n",
+    "    # 30. rtrim\n",
+    "    # 31. substring/substr\n",
+    "    # 32. trim"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hostname: ········\n",
+      "Username: ········\n",
+      "Password: ········\n",
+      "WARNING: Skipped loading table admissions_train since it already exists in the database.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Get the connection to the Vantage using create_context()\n",
+    "from teradataml import *\n",
+    "import getpass\n",
+    "td_context = create_context(host=getpass.getpass(\"Hostname: \"), username=getpass.getpass(\"Username: \"), password=getpass.getpass(\"Password: \"))\n",
+    "\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",
+       "13      no  4.00  Advanced      Novice         1\n",
+       "26     yes  3.57  Advanced    Advanced         1\n",
+       "5       no  3.44    Novice      Novice         0\n",
+       "19     yes  1.98  Advanced    Advanced         0\n",
+       "15     yes  4.00  Advanced    Advanced         1\n",
+       "40     yes  3.95    Novice    Beginner         0\n",
+       "7      yes  2.33    Novice      Novice         1\n",
+       "22     yes  3.46    Novice    Beginner         0\n",
+       "36      no  3.00  Advanced      Novice         0\n",
+       "38     yes  2.65  Advanced    Beginner         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):\n",
+    "    print(\"Equivalent SQL: {}\".format(df.show_query()))\n",
+    "    print(\"\\n\")\n",
+    "    print(\" ************************* DataFrame ********************* \")\n",
+    "    print(df)\n",
+    "    print(\"\\n\\n\")\n",
+    "    print(\" ************************* DataFrame.dtypes ********************* \")\n",
+    "    print(df.dtypes)\n",
+    "    print(\"\\n\\n\")\n",
+    "    if isinstance(columns, str):\n",
+    "        columns = [columns]\n",
+    "    for col in columns:\n",
+    "        coltype = df.__getattr__(col).type\n",
+    "        if isinstance(coltype, sqlalchemy.sql.sqltypes.NullType):\n",
+    "            coltype = \"NullType\"\n",
+    "        print(\" '{}' Column Type: {}\".format(col, coltype))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import func from SQLAlchemy to use the same for executing built-in functions in Teradata\n",
+    "from sqlalchemy import func"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Before we move on with examples, one should read below just to understand how teradataml DataFrame and \n",
+    "# it's columns are used to create a SQLAlchemy ClauseElement/Expression.\n",
+    "\n",
+    "# Often in below examples one would see something like this: 'admissions_train.admitted.expression'\n",
+    "# Here in the above expression,\n",
+    "#    'admissions_train' is 'teradataml DataFrame'\n",
+    "#    'admitted' is 'column name' in teradataml DataFrame 'admissions_train'\n",
+    "#    Thus, \n",
+    "#        'admissions_train.admitted' together forms a ColumnExpression.\n",
+    "#    expression allows us to use teradata ColumnExpression to be treated as SQLAlchemy Expression.\n",
+    "#    Thus,\n",
+    "#        'admissions_train.admitted.expression' gives us an expression that can be used with SQLAlchemy clauseElements."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## CHAR2HEXINT function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns the hexadecimal representation for a character string."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "char2hexint_ = func.CHAR2HEXINT(admissions_train.stats.expression)\n",
+    "type(char2hexint_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "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, CHAR2HEXINT(stats) AS char2hexint_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted                                                                                                           char2hexint_col\n",
+      "id                                                                                                                                                                        \n",
+      "13      no  4.00  Advanced      Novice         1  416476616E636564                                                                                                        \n",
+      "36      no  3.00  Advanced      Novice         0  416476616E636564                                                                                                        \n",
+      "15     yes  4.00  Advanced    Advanced         1  416476616E636564                                                                                                        \n",
+      "40     yes  3.95    Novice    Beginner         0  4E6F76696365                                                                                                            \n",
+      "22     yes  3.46    Novice    Beginner         0  4E6F76696365                                                                                                            \n",
+      "38     yes  2.65  Advanced    Beginner         1  416476616E636564                                                                                                        \n",
+      "26     yes  3.57  Advanced    Advanced         1  416476616E636564                                                                                                        \n",
+      "5       no  3.44    Novice      Novice         0  4E6F76696365                                                                                                            \n",
+      "7      yes  2.33    Novice      Novice         1  4E6F76696365                                                                                                            \n",
+      "19     yes  1.98  Advanced    Advanced         0  416476616E636564                                                                                                        \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",
+      "char2hexint_col      str\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'char2hexint_col' Column Type: CHAR\n"
+     ]
+    }
+   ],
+   "source": [
+    "char2hexint_df = admissions_train.assign(char2hexint_col=char2hexint_)\n",
+    "print_variables(char2hexint_df, \"char2hexint_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## ASCII function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns the decimal representation of the first character in string_expr as a NUMBER value. \n",
+    "# The decimal representation will reflect the character set of the input string."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ascii_ = func.ascii(admissions_train.stats.expression)\n",
+    "type(ascii_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "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, ascii(stats) AS ascii_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted ascii_col\n",
+      "id                                                        \n",
+      "13      no  4.00  Advanced      Novice         1        65\n",
+      "26     yes  3.57  Advanced    Advanced         1        65\n",
+      "5       no  3.44    Novice      Novice         0        78\n",
+      "19     yes  1.98  Advanced    Advanced         0        65\n",
+      "15     yes  4.00  Advanced    Advanced         1        65\n",
+      "40     yes  3.95    Novice    Beginner         0        78\n",
+      "7      yes  2.33    Novice      Novice         1        78\n",
+      "22     yes  3.46    Novice    Beginner         0        78\n",
+      "36      no  3.00  Advanced      Novice         0        65\n",
+      "38     yes  2.65  Advanced    Beginner         1        65\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",
+      "ascii_col      decimal.Decimal\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'ascii_col' Column Type: NUMBER\n"
+     ]
+    }
+   ],
+   "source": [
+    "ascii_df = admissions_train.assign(ascii_col=ascii_)\n",
+    "print_variables(ascii_df, \"ascii_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## CHAR function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns the Latin ASCII character given a numeric code value."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "char_ = func.char(admissions_train.stats.expression)\n",
+    "type(char_)"
+   ]
+  },
+  {
+   "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, char(stats) AS char_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted char_col\n",
+      "id                                                       \n",
+      "22     yes  3.46    Novice    Beginner         0        6\n",
+      "36      no  3.00  Advanced      Novice         0        8\n",
+      "15     yes  4.00  Advanced    Advanced         1        8\n",
+      "38     yes  2.65  Advanced    Beginner         1        8\n",
+      "5       no  3.44    Novice      Novice         0        6\n",
+      "17      no  3.83  Advanced    Advanced         1        8\n",
+      "34     yes  3.85  Advanced    Beginner         0        8\n",
+      "13      no  4.00  Advanced      Novice         1        8\n",
+      "26     yes  3.57  Advanced    Advanced         1        8\n",
+      "19     yes  1.98  Advanced    Advanced         0        8\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",
+      "char_col         str\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'char_col' Column Type: NullType\n"
+     ]
+    }
+   ],
+   "source": [
+    "char_df = admissions_train.assign(char_col=char_)\n",
+    "print_variables(char_df, \"char_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## CONCAT function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Concatenates string expressions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.concat"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "concat_ = func.CONCAT(admissions_train.stats.expression, \" \", admissions_train.masters.expression)\n",
+    "type(concat_)"
+   ]
+  },
+  {
+   "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, concat(stats, ' ', masters) AS concat_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted    concat_col\n",
+      "id                                                            \n",
+      "13      no  4.00  Advanced      Novice         1   Advanced no\n",
+      "26     yes  3.57  Advanced    Advanced         1  Advanced yes\n",
+      "5       no  3.44    Novice      Novice         0     Novice no\n",
+      "19     yes  1.98  Advanced    Advanced         0  Advanced yes\n",
+      "15     yes  4.00  Advanced    Advanced         1  Advanced yes\n",
+      "40     yes  3.95    Novice    Beginner         0    Novice yes\n",
+      "7      yes  2.33    Novice      Novice         1    Novice yes\n",
+      "22     yes  3.46    Novice    Beginner         0    Novice yes\n",
+      "36      no  3.00  Advanced      Novice         0   Advanced no\n",
+      "38     yes  2.65  Advanced    Beginner         1  Advanced yes\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",
+      "concat_col       str\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'concat_col' Column Type: VARCHAR\n"
+     ]
+    }
+   ],
+   "source": [
+    "concat_df = admissions_train.assign(concat_col=concat_)\n",
+    "print_variables(concat_df, \"concat_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## EDITDISTANCE Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns the minimum number of edit operations (insertions, deletions, substitutions and transpositions) required to \n",
+    "# transform string1 into string2."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ed_ = func.Editdistance(admissions_train.stats.expression, admissions_train.programming.expression)\n",
+    "type(ed_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "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, Editdistance(stats, programming) AS ed_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  ed_col\n",
+      "id                                                      \n",
+      "22     yes  3.46    Novice    Beginner         0       6\n",
+      "36      no  3.00  Advanced      Novice         0       5\n",
+      "15     yes  4.00  Advanced    Advanced         1       0\n",
+      "38     yes  2.65  Advanced    Beginner         1       6\n",
+      "5       no  3.44    Novice      Novice         0       0\n",
+      "17      no  3.83  Advanced    Advanced         1       0\n",
+      "34     yes  3.85  Advanced    Beginner         0       6\n",
+      "13      no  4.00  Advanced      Novice         1       5\n",
+      "26     yes  3.57  Advanced    Advanced         1       0\n",
+      "19     yes  1.98  Advanced    Advanced         0       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",
+      "ed_col           int\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'ed_col' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "ed_df = admissions_train.assign(ed_col=ed_)\n",
+    "print_variables(ed_df, \"ed_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## INDEX Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns the position in string_expression_1 where string_expression_2 starts."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "index_ = func.Index(admissions_train.stats.expression, \"e\")\n",
+    "type(index_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "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, Index(stats, 'e') AS index_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  index_col\n",
+      "id                                                         \n",
+      "22     yes  3.46    Novice    Beginner         0          6\n",
+      "36      no  3.00  Advanced      Novice         0          7\n",
+      "15     yes  4.00  Advanced    Advanced         1          7\n",
+      "38     yes  2.65  Advanced    Beginner         1          7\n",
+      "5       no  3.44    Novice      Novice         0          6\n",
+      "17      no  3.83  Advanced    Advanced         1          7\n",
+      "34     yes  3.85  Advanced    Beginner         0          7\n",
+      "13      no  4.00  Advanced      Novice         1          7\n",
+      "26     yes  3.57  Advanced    Advanced         1          7\n",
+      "19     yes  1.98  Advanced    Advanced         0          7\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",
+      "index_col        int\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'index_col' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "index_df = admissions_train.assign(index_col=index_)\n",
+    "print_variables(index_df, \"index_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## INITCAP Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Modifies a string argument and returns the string with the first character in each word in uppercase and all other \n",
+    "# characters in lowercase. Words are delimited by white space or characters that are not alphanumeric."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "initcap_ = func.Initcap(admissions_train.masters.expression)\n",
+    "type(initcap_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "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, Initcap(masters) AS initcap_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted initcap_col\n",
+      "id                                                          \n",
+      "5       no  3.44    Novice      Novice         0          No\n",
+      "34     yes  3.85  Advanced    Beginner         0         Yes\n",
+      "13      no  4.00  Advanced      Novice         1          No\n",
+      "40     yes  3.95    Novice    Beginner         0         Yes\n",
+      "22     yes  3.46    Novice    Beginner         0         Yes\n",
+      "19     yes  1.98  Advanced    Advanced         0         Yes\n",
+      "36      no  3.00  Advanced      Novice         0          No\n",
+      "15     yes  4.00  Advanced    Advanced         1         Yes\n",
+      "7      yes  2.33    Novice      Novice         1         Yes\n",
+      "17      no  3.83  Advanced    Advanced         1          No\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",
+      "initcap_col      str\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'initcap_col' Column Type: VARCHAR\n"
+     ]
+    }
+   ],
+   "source": [
+    "initcap_df = admissions_train.assign(initcap_col=initcap_)\n",
+    "print_variables(initcap_df, \"initcap_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## INSTR Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Searches the source_string argument for occurrences of search_string."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "instr_ = func.instr(admissions_train.stats.expression, \"ce\")\n",
+    "type(instr_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "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, instr(stats, 'ce') AS instr_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted instr_col\n",
+      "id                                                        \n",
+      "13      no  4.00  Advanced      Novice         1         6\n",
+      "26     yes  3.57  Advanced    Advanced         1         6\n",
+      "5       no  3.44    Novice      Novice         0         5\n",
+      "19     yes  1.98  Advanced    Advanced         0         6\n",
+      "15     yes  4.00  Advanced    Advanced         1         6\n",
+      "40     yes  3.95    Novice    Beginner         0         5\n",
+      "7      yes  2.33    Novice      Novice         1         5\n",
+      "22     yes  3.46    Novice    Beginner         0         5\n",
+      "36      no  3.00  Advanced      Novice         0         6\n",
+      "38     yes  2.65  Advanced    Beginner         1         6\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",
+      "instr_col      decimal.Decimal\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'instr_col' Column Type: NUMBER\n"
+     ]
+    }
+   ],
+   "source": [
+    "instr_df = admissions_train.assign(instr_col=instr_)\n",
+    "print_variables(instr_df, \"instr_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## LEFT Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Truncates in input string to a specified number of characters.\n",
+    "# The LEFT function can be called with the 'LEFT' or 'TD_LEFT' alias names."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "left_ = func.left(admissions_train.stats.expression, 4)\n",
+    "type(left_)"
+   ]
+  },
+  {
+   "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, left(stats, 4) AS left_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted left_col\n",
+      "id                                                       \n",
+      "13      no  4.00  Advanced      Novice         1     Adva\n",
+      "26     yes  3.57  Advanced    Advanced         1     Adva\n",
+      "5       no  3.44    Novice      Novice         0     Novi\n",
+      "19     yes  1.98  Advanced    Advanced         0     Adva\n",
+      "15     yes  4.00  Advanced    Advanced         1     Adva\n",
+      "40     yes  3.95    Novice    Beginner         0     Novi\n",
+      "7      yes  2.33    Novice      Novice         1     Novi\n",
+      "22     yes  3.46    Novice    Beginner         0     Novi\n",
+      "36      no  3.00  Advanced      Novice         0     Adva\n",
+      "38     yes  2.65  Advanced    Beginner         1     Adva\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",
+      "left_col         str\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'left_col' Column Type: VARCHAR\n"
+     ]
+    }
+   ],
+   "source": [
+    "left_df = admissions_train.assign(left_col=left_)\n",
+    "print_variables(left_df, \"left_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## LENGTH Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns the number of characters in the expression."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 35,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "length_ = func.length(admissions_train.stats.expression)\n",
+    "type(length_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "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, length(stats) AS length_df from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted length_df\n",
+      "id                                                        \n",
+      "22     yes  3.46    Novice    Beginner         0         6\n",
+      "36      no  3.00  Advanced      Novice         0         8\n",
+      "15     yes  4.00  Advanced    Advanced         1         8\n",
+      "38     yes  2.65  Advanced    Beginner         1         8\n",
+      "5       no  3.44    Novice      Novice         0         6\n",
+      "17      no  3.83  Advanced    Advanced         1         8\n",
+      "34     yes  3.85  Advanced    Beginner         0         8\n",
+      "13      no  4.00  Advanced      Novice         1         8\n",
+      "26     yes  3.57  Advanced    Advanced         1         8\n",
+      "19     yes  1.98  Advanced    Advanced         0         8\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",
+      "length_df      decimal.Decimal\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'length_df' Column Type: NUMBER\n"
+     ]
+    }
+   ],
+   "source": [
+    "length_df = admissions_train.assign(length_df=length_)\n",
+    "print_variables(length_df, \"length_df\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## LOCATE Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns the position of the first occurrence of string_expr1 within string_expr2. \n",
+    "# The search for the first occurrence of string_expr1 begins with the first character position in string_expr2 \n",
+    "# unless the optional argument, n1, is specified."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "str_func_ = func.locate(\"ce\", admissions_train.stats.expression)\n",
+    "type(str_func_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "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, locate('ce', stats) AS str_func_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  str_func_col\n",
+      "id                                                            \n",
+      "13      no  4.00  Advanced      Novice         1             6\n",
+      "36      no  3.00  Advanced      Novice         0             6\n",
+      "15     yes  4.00  Advanced    Advanced         1             6\n",
+      "40     yes  3.95    Novice    Beginner         0             5\n",
+      "22     yes  3.46    Novice    Beginner         0             5\n",
+      "38     yes  2.65  Advanced    Beginner         1             6\n",
+      "26     yes  3.57  Advanced    Advanced         1             6\n",
+      "5       no  3.44    Novice      Novice         0             5\n",
+      "7      yes  2.33    Novice      Novice         1             5\n",
+      "19     yes  1.98  Advanced    Advanced         0             6\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",
+      "str_func_col      int\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'str_func_col' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "str_func_df = admissions_train.assign(str_func_col=str_func_)\n",
+    "print_variables(str_func_df, \"str_func_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## LOWER Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns a character string identical to character_string_expression, except that all uppercase letters are replaced\n",
+    "# with their lowercase equivalents."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 41,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "str_func_ = func.lower(admissions_train.stats.expression)\n",
+    "type(str_func_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "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, lower(stats) AS str_func_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted str_func_col\n",
+      "id                                                           \n",
+      "13      no  4.00  Advanced      Novice         1     advanced\n",
+      "26     yes  3.57  Advanced    Advanced         1     advanced\n",
+      "5       no  3.44    Novice      Novice         0       novice\n",
+      "19     yes  1.98  Advanced    Advanced         0     advanced\n",
+      "15     yes  4.00  Advanced    Advanced         1     advanced\n",
+      "40     yes  3.95    Novice    Beginner         0       novice\n",
+      "7      yes  2.33    Novice      Novice         1       novice\n",
+      "22     yes  3.46    Novice    Beginner         0       novice\n",
+      "36      no  3.00  Advanced      Novice         0     advanced\n",
+      "38     yes  2.65  Advanced    Beginner         1     advanced\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",
+      "str_func_col      str\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'str_func_col' Column Type: VARCHAR\n"
+     ]
+    }
+   ],
+   "source": [
+    "str_func_df = admissions_train.assign(str_func_col=str_func_)\n",
+    "print_variables(str_func_df, \"str_func_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## LPAD Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns the source_string padded to the left with the characters in fill_string so that the resulting string is length \n",
+    "# characters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 44,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "str_func_ = func.lpad(admissions_train.stats.expression, 20, '0')\n",
+    "type(str_func_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "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, lpad(stats, 20, '0') AS str_func_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted          str_func_col\n",
+      "id                                                                    \n",
+      "13      no  4.00  Advanced      Novice         1  000000000000Advanced\n",
+      "26     yes  3.57  Advanced    Advanced         1  000000000000Advanced\n",
+      "5       no  3.44    Novice      Novice         0  00000000000000Novice\n",
+      "19     yes  1.98  Advanced    Advanced         0  000000000000Advanced\n",
+      "15     yes  4.00  Advanced    Advanced         1  000000000000Advanced\n",
+      "40     yes  3.95    Novice    Beginner         0  00000000000000Novice\n",
+      "7      yes  2.33    Novice      Novice         1  00000000000000Novice\n",
+      "22     yes  3.46    Novice    Beginner         0  00000000000000Novice\n",
+      "36      no  3.00  Advanced      Novice         0  000000000000Advanced\n",
+      "38     yes  2.65  Advanced    Beginner         1  000000000000Advanced\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",
+      "str_func_col      str\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'str_func_col' Column Type: VARCHAR\n"
+     ]
+    }
+   ],
+   "source": [
+    "str_func_df = admissions_train.assign(str_func_col=str_func_)\n",
+    "print_variables(str_func_df, \"str_func_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## LTRIM Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns the argument expr1, with its left-most characters removed up to the first character that is not in the argument expr2."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 47,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "str_func_ = func.ltrim(admissions_train.stats.expression, 'Adv')\n",
+    "type(str_func_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "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, ltrim(stats, 'Adv') AS str_func_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted str_func_col\n",
+      "id                                                           \n",
+      "13      no  4.00  Advanced      Novice         1        anced\n",
+      "26     yes  3.57  Advanced    Advanced         1        anced\n",
+      "5       no  3.44    Novice      Novice         0       Novice\n",
+      "19     yes  1.98  Advanced    Advanced         0        anced\n",
+      "15     yes  4.00  Advanced    Advanced         1        anced\n",
+      "40     yes  3.95    Novice    Beginner         0       Novice\n",
+      "7      yes  2.33    Novice      Novice         1       Novice\n",
+      "22     yes  3.46    Novice    Beginner         0       Novice\n",
+      "36      no  3.00  Advanced      Novice         0        anced\n",
+      "38     yes  2.65  Advanced    Beginner         1        anced\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",
+      "str_func_col      str\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'str_func_col' Column Type: VARCHAR\n"
+     ]
+    }
+   ],
+   "source": [
+    "str_func_df = admissions_train.assign(str_func_col=str_func_)\n",
+    "print_variables(str_func_df, \"str_func_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## NGRAM Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns the number of n-gram matches between string1 and string2.\n",
+    "# A high number of matching n-gram patterns implies a high similarity between the two strings."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 50,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "str_func_ = func.NGRAM(admissions_train.stats.expression, admissions_train.programming.expression, 3)\n",
+    "type(str_func_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "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, NGRAM(stats, programming, 3) AS str_func_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  str_func_col\n",
+      "id                                                            \n",
+      "13      no  4.00  Advanced      Novice         1             0\n",
+      "26     yes  3.57  Advanced    Advanced         1             6\n",
+      "5       no  3.44    Novice      Novice         0             4\n",
+      "19     yes  1.98  Advanced    Advanced         0             6\n",
+      "15     yes  4.00  Advanced    Advanced         1             6\n",
+      "40     yes  3.95    Novice    Beginner         0             0\n",
+      "7      yes  2.33    Novice      Novice         1             4\n",
+      "22     yes  3.46    Novice    Beginner         0             0\n",
+      "36      no  3.00  Advanced      Novice         0             0\n",
+      "38     yes  2.65  Advanced    Beginner         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",
+      "str_func_col      int\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'str_func_col' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "str_func_df = admissions_train.assign(str_func_col=str_func_)\n",
+    "print_variables(str_func_df, \"str_func_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## NVP Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Extracts the value of a name-value pair where the name in the pair matches the name and the number of the \n",
+    "# occurrence specified."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 53,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "str_func_ = func.NVP('entree:orange chicken#entree2:honey salmon', 'entree','#', ':', 1)\n",
+    "type(str_func_)"
+   ]
+  },
+  {
+   "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, NVP('entree:orange chicken#entree2:honey salmon', 'entree', '#', ':', 1) AS str_func_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted    str_func_col\n",
+      "id                                                              \n",
+      "22     yes  3.46    Novice    Beginner         0  orange chicken\n",
+      "36      no  3.00  Advanced      Novice         0  orange chicken\n",
+      "15     yes  4.00  Advanced    Advanced         1  orange chicken\n",
+      "38     yes  2.65  Advanced    Beginner         1  orange chicken\n",
+      "5       no  3.44    Novice      Novice         0  orange chicken\n",
+      "17      no  3.83  Advanced    Advanced         1  orange chicken\n",
+      "34     yes  3.85  Advanced    Beginner         0  orange chicken\n",
+      "13      no  4.00  Advanced      Novice         1  orange chicken\n",
+      "26     yes  3.57  Advanced    Advanced         1  orange chicken\n",
+      "19     yes  1.98  Advanced    Advanced         0  orange chicken\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",
+      "str_func_col      str\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'str_func_col' Column Type: VARCHAR\n"
+     ]
+    }
+   ],
+   "source": [
+    "str_func_df = admissions_train.assign(str_func_col=str_func_)\n",
+    "print_variables(str_func_df, \"str_func_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## OREPLACE Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Replaces every occurrence of search_string in the source_string with the replace_string. \n",
+    "# Use this function either to replace or remove portions of a string."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 56,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "str_func_ = func.oreplace(admissions_train.stats.expression, \"e\", \"@#\")\n",
+    "type(str_func_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "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, oreplace(stats, 'e', '@#') AS str_func_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted str_func_col\n",
+      "id                                                           \n",
+      "22     yes  3.46    Novice    Beginner         0      Novic@#\n",
+      "36      no  3.00  Advanced      Novice         0    Advanc@#d\n",
+      "15     yes  4.00  Advanced    Advanced         1    Advanc@#d\n",
+      "38     yes  2.65  Advanced    Beginner         1    Advanc@#d\n",
+      "5       no  3.44    Novice      Novice         0      Novic@#\n",
+      "17      no  3.83  Advanced    Advanced         1    Advanc@#d\n",
+      "34     yes  3.85  Advanced    Beginner         0    Advanc@#d\n",
+      "13      no  4.00  Advanced      Novice         1    Advanc@#d\n",
+      "26     yes  3.57  Advanced    Advanced         1    Advanc@#d\n",
+      "19     yes  1.98  Advanced    Advanced         0    Advanc@#d\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",
+      "str_func_col      str\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'str_func_col' Column Type: VARCHAR\n"
+     ]
+    }
+   ],
+   "source": [
+    "str_func_df = admissions_train.assign(str_func_col=str_func_)\n",
+    "print_variables(str_func_df, \"str_func_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## OTRANSLATE Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns source_string with every occurrence of each character in from_string replaced with the corresponding \n",
+    "# character in to_string."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 59,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "str_func_ = func.OTRANSLATE(admissions_train.stats.expression, \"vice\", \"UCMe\")\n",
+    "type(str_func_)"
+   ]
+  },
+  {
+   "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, OTRANSLATE(stats, 'vice', 'UCMe') AS str_func_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted str_func_col\n",
+      "id                                                           \n",
+      "5       no  3.44    Novice      Novice         0       NoUCMe\n",
+      "7      yes  2.33    Novice      Novice         1       NoUCMe\n",
+      "22     yes  3.46    Novice    Beginner         0       NoUCMe\n",
+      "19     yes  1.98  Advanced    Advanced         0     AdUanMed\n",
+      "15     yes  4.00  Advanced    Advanced         1     AdUanMed\n",
+      "17      no  3.83  Advanced    Advanced         1     AdUanMed\n",
+      "34     yes  3.85  Advanced    Beginner         0     AdUanMed\n",
+      "13      no  4.00  Advanced      Novice         1     AdUanMed\n",
+      "36      no  3.00  Advanced      Novice         0     AdUanMed\n",
+      "40     yes  3.95    Novice    Beginner         0       NoUCMe\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",
+      "str_func_col      str\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'str_func_col' Column Type: VARCHAR\n"
+     ]
+    }
+   ],
+   "source": [
+    "str_func_df = admissions_train.assign(str_func_col=str_func_)\n",
+    "print_variables(str_func_df, \"str_func_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## POSITION Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns the position in string_expression_2 where string_expression_1 starts."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 62,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "str_func_ = func.position(admissions_train.stats.expression.in_([\"n\"]))\n",
+    "type(str_func_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "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, position(stats IN ('n')) AS str_func_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  str_func_col\n",
+      "id                                                            \n",
+      "22     yes  3.46    Novice    Beginner         0             0\n",
+      "36      no  3.00  Advanced      Novice         0             0\n",
+      "15     yes  4.00  Advanced    Advanced         1             0\n",
+      "38     yes  2.65  Advanced    Beginner         1             0\n",
+      "5       no  3.44    Novice      Novice         0             0\n",
+      "17      no  3.83  Advanced    Advanced         1             0\n",
+      "34     yes  3.85  Advanced    Beginner         0             0\n",
+      "13      no  4.00  Advanced      Novice         1             0\n",
+      "26     yes  3.57  Advanced    Advanced         1             0\n",
+      "19     yes  1.98  Advanced    Advanced         0             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",
+      "str_func_col      int\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'str_func_col' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "str_func_df = admissions_train.assign(str_func_col=str_func_)\n",
+    "print_variables(str_func_df, \"str_func_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## REVERSE Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Reverses the input string."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 65,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "str_func_ = func.reverse(admissions_train.stats.expression)\n",
+    "type(str_func_)"
+   ]
+  },
+  {
+   "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, reverse(stats) AS str_func_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted str_func_col\n",
+      "id                                                           \n",
+      "22     yes  3.46    Novice    Beginner         0       ecivoN\n",
+      "36      no  3.00  Advanced      Novice         0     decnavdA\n",
+      "15     yes  4.00  Advanced    Advanced         1     decnavdA\n",
+      "38     yes  2.65  Advanced    Beginner         1     decnavdA\n",
+      "5       no  3.44    Novice      Novice         0       ecivoN\n",
+      "17      no  3.83  Advanced    Advanced         1     decnavdA\n",
+      "34     yes  3.85  Advanced    Beginner         0     decnavdA\n",
+      "13      no  4.00  Advanced      Novice         1     decnavdA\n",
+      "26     yes  3.57  Advanced    Advanced         1     decnavdA\n",
+      "19     yes  1.98  Advanced    Advanced         0     decnavdA\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",
+      "str_func_col      str\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'str_func_col' Column Type: VARCHAR\n"
+     ]
+    }
+   ],
+   "source": [
+    "str_func_df = admissions_train.assign(str_func_col=str_func_)\n",
+    "print_variables(str_func_df, \"str_func_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## RIGHT Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Starting from the end of the input string, a substring is created with the number of characters specified by the \n",
+    "# second parameter.\n",
+    "# The RIGHT function can be called with the 'RIGHT' or 'TD_RIGHT' alias names."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 68,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "str_func_ = func.right(admissions_train.stats.expression, 5)\n",
+    "type(str_func_)"
+   ]
+  },
+  {
+   "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, right(stats, 5) AS str_func_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted str_func_col\n",
+      "id                                                           \n",
+      "22     yes  3.46    Novice    Beginner         0        ovice\n",
+      "36      no  3.00  Advanced      Novice         0        anced\n",
+      "15     yes  4.00  Advanced    Advanced         1        anced\n",
+      "38     yes  2.65  Advanced    Beginner         1        anced\n",
+      "5       no  3.44    Novice      Novice         0        ovice\n",
+      "17      no  3.83  Advanced    Advanced         1        anced\n",
+      "34     yes  3.85  Advanced    Beginner         0        anced\n",
+      "13      no  4.00  Advanced      Novice         1        anced\n",
+      "26     yes  3.57  Advanced    Advanced         1        anced\n",
+      "19     yes  1.98  Advanced    Advanced         0        anced\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",
+      "str_func_col      str\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'str_func_col' Column Type: VARCHAR\n"
+     ]
+    }
+   ],
+   "source": [
+    "str_func_df = admissions_train.assign(str_func_col=str_func_)\n",
+    "print_variables(str_func_df, \"str_func_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## RPAD Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns the source_string padded to the right with the characters in fill_string so that the resulting string is \n",
+    "# length characters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 71,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "str_func_ = func.rpad(admissions_train.stats.expression, 20, \"-\")\n",
+    "type(str_func_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "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, rpad(stats, 20, '-') AS str_func_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted          str_func_col\n",
+      "id                                                                    \n",
+      "22     yes  3.46    Novice    Beginner         0  Novice--------------\n",
+      "36      no  3.00  Advanced      Novice         0  Advanced------------\n",
+      "15     yes  4.00  Advanced    Advanced         1  Advanced------------\n",
+      "38     yes  2.65  Advanced    Beginner         1  Advanced------------\n",
+      "5       no  3.44    Novice      Novice         0  Novice--------------\n",
+      "17      no  3.83  Advanced    Advanced         1  Advanced------------\n",
+      "34     yes  3.85  Advanced    Beginner         0  Advanced------------\n",
+      "13      no  4.00  Advanced      Novice         1  Advanced------------\n",
+      "26     yes  3.57  Advanced    Advanced         1  Advanced------------\n",
+      "19     yes  1.98  Advanced    Advanced         0  Advanced------------\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",
+      "str_func_col      str\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'str_func_col' Column Type: VARCHAR\n"
+     ]
+    }
+   ],
+   "source": [
+    "str_func_df = admissions_train.assign(str_func_col=str_func_)\n",
+    "print_variables(str_func_df, \"str_func_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## RTRIM Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns the argument expr1, with its right-most characters removed up to the first character that is not in the \n",
+    "# argument expr2."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 74,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "str_func_ = func.rtrim(admissions_train.stats.expression, 'e')\n",
+    "type(str_func_)"
+   ]
+  },
+  {
+   "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, rtrim(stats, 'e') AS str_func_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted str_func_col\n",
+      "id                                                           \n",
+      "22     yes  3.46    Novice    Beginner         0        Novic\n",
+      "36      no  3.00  Advanced      Novice         0     Advanced\n",
+      "15     yes  4.00  Advanced    Advanced         1     Advanced\n",
+      "38     yes  2.65  Advanced    Beginner         1     Advanced\n",
+      "5       no  3.44    Novice      Novice         0        Novic\n",
+      "17      no  3.83  Advanced    Advanced         1     Advanced\n",
+      "34     yes  3.85  Advanced    Beginner         0     Advanced\n",
+      "13      no  4.00  Advanced      Novice         1     Advanced\n",
+      "26     yes  3.57  Advanced    Advanced         1     Advanced\n",
+      "19     yes  1.98  Advanced    Advanced         0     Advanced\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",
+      "str_func_col      str\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'str_func_col' Column Type: VARCHAR\n"
+     ]
+    }
+   ],
+   "source": [
+    "str_func_df = admissions_train.assign(str_func_col=str_func_)\n",
+    "print_variables(str_func_df, \"str_func_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## SOUNDEX Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns a character string that represents the Soundex code for string_expression."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 77,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "str_func_ = func.soundex(admissions_train.stats.expression)\n",
+    "type(str_func_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "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, soundex(stats) AS str_func_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted str_func_col\n",
+      "id                                                           \n",
+      "5       no  3.44    Novice      Novice         0         N120\n",
+      "34     yes  3.85  Advanced    Beginner         0         A315\n",
+      "13      no  4.00  Advanced      Novice         1         A315\n",
+      "40     yes  3.95    Novice    Beginner         0         N120\n",
+      "22     yes  3.46    Novice    Beginner         0         N120\n",
+      "19     yes  1.98  Advanced    Advanced         0         A315\n",
+      "36      no  3.00  Advanced      Novice         0         A315\n",
+      "15     yes  4.00  Advanced    Advanced         1         A315\n",
+      "7      yes  2.33    Novice      Novice         1         N120\n",
+      "17      no  3.83  Advanced    Advanced         1         A315\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",
+      "str_func_col      str\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'str_func_col' Column Type: VARCHAR\n"
+     ]
+    }
+   ],
+   "source": [
+    "str_func_df = admissions_train.assign(str_func_col=str_func_)\n",
+    "print_variables(str_func_df, \"str_func_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## STRING_CS Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 79,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns a heuristically derived integer value that you can use to help determine which KANJI1-compatible client \n",
+    "# character set was used to encode string_expression."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 80,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 80,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "str_func_ = func.string_cs(admissions_train.stats.expression)\n",
+    "type(str_func_)"
+   ]
+  },
+  {
+   "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, string_cs(stats) AS str_func_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted  str_func_col\n",
+      "id                                                            \n",
+      "22     yes  3.46    Novice    Beginner         0             0\n",
+      "36      no  3.00  Advanced      Novice         0             0\n",
+      "15     yes  4.00  Advanced    Advanced         1             0\n",
+      "38     yes  2.65  Advanced    Beginner         1             0\n",
+      "5       no  3.44    Novice      Novice         0             0\n",
+      "17      no  3.83  Advanced    Advanced         1             0\n",
+      "34     yes  3.85  Advanced    Beginner         0             0\n",
+      "13      no  4.00  Advanced      Novice         1             0\n",
+      "26     yes  3.57  Advanced    Advanced         1             0\n",
+      "19     yes  1.98  Advanced    Advanced         0             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",
+      "str_func_col      int\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'str_func_col' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "str_func_df = admissions_train.assign(str_func_col=str_func_)\n",
+    "print_variables(str_func_df, \"str_func_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## TRIM Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 82,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Takes a character or byte string_expression argument, trims the specified pad characters or bytes, and returns the \n",
+    "# trimmed string."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 83,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 83,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "str_func_ = func.trim(admissions_train.stats.expression)\n",
+    "type(str_func_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 84,
+   "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, trim(stats) AS str_func_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted str_func_col\n",
+      "id                                                           \n",
+      "22     yes  3.46    Novice    Beginner         0       Novice\n",
+      "36      no  3.00  Advanced      Novice         0     Advanced\n",
+      "15     yes  4.00  Advanced    Advanced         1     Advanced\n",
+      "38     yes  2.65  Advanced    Beginner         1     Advanced\n",
+      "5       no  3.44    Novice      Novice         0       Novice\n",
+      "17      no  3.83  Advanced    Advanced         1     Advanced\n",
+      "34     yes  3.85  Advanced    Beginner         0     Advanced\n",
+      "13      no  4.00  Advanced      Novice         1     Advanced\n",
+      "26     yes  3.57  Advanced    Advanced         1     Advanced\n",
+      "19     yes  1.98  Advanced    Advanced         0     Advanced\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",
+      "str_func_col      str\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'str_func_col' Column Type: VARCHAR\n"
+     ]
+    }
+   ],
+   "source": [
+    "str_func_df = admissions_train.assign(str_func_col=str_func_)\n",
+    "print_variables(str_func_df, \"str_func_col\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## UPPER/UCASE Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 85,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Returns a character string identical to character_string_expression, except that all lowercase letters are replaced by \n",
+    "# their uppercase equivalents."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 86,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 86,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "str_func_ = func.ucase(admissions_train.stats.expression)\n",
+    "type(str_func_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 87,
+   "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, ucase(stats) AS str_func_col from \"admissions_train\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   masters   gpa     stats programming  admitted str_func_col\n",
+      "id                                                           \n",
+      "22     yes  3.46    Novice    Beginner         0       NOVICE\n",
+      "36      no  3.00  Advanced      Novice         0     ADVANCED\n",
+      "15     yes  4.00  Advanced    Advanced         1     ADVANCED\n",
+      "38     yes  2.65  Advanced    Beginner         1     ADVANCED\n",
+      "5       no  3.44    Novice      Novice         0       NOVICE\n",
+      "17      no  3.83  Advanced    Advanced         1     ADVANCED\n",
+      "34     yes  3.85  Advanced    Beginner         0     ADVANCED\n",
+      "13      no  4.00  Advanced      Novice         1     ADVANCED\n",
+      "26     yes  3.57  Advanced    Advanced         1     ADVANCED\n",
+      "19     yes  1.98  Advanced    Advanced         0     ADVANCED\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",
+      "str_func_col      str\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'str_func_col' Column Type: VARCHAR\n"
+     ]
+    }
+   ],
+   "source": [
+    "str_func_df = admissions_train.assign(str_func_col=str_func_)\n",
+    "print_variables(str_func_df, \"str_func_col\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 88,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 88,
+     "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": 89,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# CSV, CSVLD, POSITION, STROK, STRTOK_SPLIT_TO_TABLE, Translate, TRANSLATE_CHK - Needs investiation\n",
+    "# VARGRAPHIC Function - teradatasqlalchmy yet does not support VARGRAPHIC type. \n",
+    "#                       Once support is added, user can use Vargraphic function.\n",
+    "# substring - Need more investigation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}