teradataml 20.0.0.8__py3-none-any.whl

teradataml/data/notebooks/sqlalchemy/Teradata Vantage Bit-Byte Manipulation Functions using SQLAlchemy.ipynb

@@ -0,0 +1,1492 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Disclaimer\n",
+    "Please note, the Vantage Functions via SQLAlchemy feature is a preview/beta code release with limited functionality (the “Code”). As such, you acknowledge that the Code is experimental in nature and that the Code is provided “AS IS” and may not be functional on any machine or in any environment. TERADATA DISCLAIMS ALL WARRANTIES RELATING TO THE CODE, EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTIES AGAINST INFRINGEMENT OF THIRD-PARTY RIGHTS, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.\n",
+    "\n",
+    "TERADATA SHALL NOT BE RESPONSIBLE OR LIABLE WITH RESPECT TO ANY SUBJECT MATTER OF THE CODE UNDER ANY CONTRACT, NEGLIGENCE, STRICT LIABILITY OR OTHER THEORY \n",
+    "    (A) FOR LOSS OR INACCURACY OF DATA OR COST OF PROCUREMENT OF SUBSTITUTE GOODS, SERVICES OR TECHNOLOGY, OR \n",
+    "    (B) FOR ANY INDIRECT, INCIDENTAL OR CONSEQUENTIAL DAMAGES INCLUDING, BUT NOT LIMITED TO LOSS OF REVENUES AND LOSS OF PROFITS. TERADATA SHALL NOT BE RESPONSIBLE FOR ANY MATTER BEYOND ITS REASONABLE CONTROL.\n",
+    "\n",
+    "Notwithstanding anything to the contrary: \n",
+    "    (a) Teradata will have no obligation of any kind with respect to any Code-related comments, suggestions, design changes or improvements that you elect to provide to Teradata in either verbal or written form (collectively, “Feedback”), and \n",
+    "    (b) Teradata and its affiliates are hereby free to use any ideas, concepts, know-how or techniques, in whole or in part, contained in Feedback: \n",
+    "        (i) for any purpose whatsoever, including developing, manufacturing, and/or marketing products and/or services incorporating Feedback in whole or in part, and \n",
+    "        (ii) without any restrictions or limitations, including requiring the payment of any license fees, royalties, or other consideration. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# In this notebook, we will be covering examples for following Regular Aggregate Functions\n",
+    "# SQL Documentation: https://docs.teradata.com/reader/756LNiPSFdY~4JcCCcR5Cw/ynL7ziGBufCzuUooZX8VQg\n",
+    "    # 1. BITAND\n",
+    "    # 2. BITNOT\n",
+    "    # 3. BITOR\n",
+    "    # 4. BITXOR\n",
+    "    # 5. COUNTSET\n",
+    "    # 6. GETBIT\n",
+    "    # 7. ROTATELEFT\n",
+    "    # 8. ROTATERIGHT\n",
+    "    # 9. SETBIT\n",
+    "    # 10. SHIFTLEFT\n",
+    "    # 11. SHIFTRIGHT\n",
+    "    # 12. SUBBITSTR\n",
+    "    # 13. TO_BYTE"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hostname: ········\n",
+      "Username: ········\n",
+      "Password: ········\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: \"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING: Skipped loading table bytes_table since it already exists in the database.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "       byte_col      varbyte_col             blob_col\n",
+       "id_col                                               \n",
+       "0         b'63'      b'627A7863'  b'3330363136323633'\n",
+       "2         b'61'  b'616263643132'  b'6162636431323233'\n",
+       "1         b'62'      b'62717765'  b'3331363136323633'"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Load the example dataset.\n",
+    "load_example_data(\"dataframe\", [\"bytes_table\"])\n",
+    "# Create the DataFrame on 'admissions_train' table\n",
+    "bytes_table = DataFrame(\"bytes_table\")\n",
+    "bytes_table"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def print_variables(df, columns):\n",
+    "    print(\"Equivalent SQL: {}\".format(df.show_query()))\n",
+    "    print(\"\\n\")\n",
+    "    print(\" ************************* DataFrame ********************* \")\n",
+    "    print(df)\n",
+    "    print(\"\\n\\n\")\n",
+    "    print(\" ************************* DataFrame.dtypes ********************* \")\n",
+    "    print(df.dtypes)\n",
+    "    print(\"\\n\\n\")\n",
+    "    if isinstance(columns, str):\n",
+    "        columns = [columns]\n",
+    "    for col in columns:\n",
+    "        coltype = df.__getattr__(col).type\n",
+    "        if isinstance(coltype, sqlalchemy.sql.sqltypes.NullType):\n",
+    "            coltype = \"NullType\"\n",
+    "        print(\" '{}' Column Type: {}\".format(col, coltype))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Using Bit-Byte Manipulation Functions from Teradata Vanatge with SQLAlchemy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import func from SQLAlchemy to use the same for executing bit/byte manipulation functions\n",
+    "from sqlalchemy import func"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Before we move on with examples, one should read below just to understand how teradataml DataFrame and \n",
+    "# it's columns are used to create a SQLAlchemy ClauseElement/Expression.\n",
+    "\n",
+    "# Often in below examples one would see something like this: 'admissions_train.admitted.expression'\n",
+    "# Here in the above expression,\n",
+    "#    'admissions_train' is 'teradataml DataFrame'\n",
+    "#    'admitted' is 'column name' in teradataml DataFrame 'admissions_train'\n",
+    "#    Thus, \n",
+    "#        'admissions_train.admitted' together forms a ColumnExpression.\n",
+    "#    'expression' allows us to use teradata ColumnExpression to be treated as SQLAlchemy Expression.\n",
+    "#    Thus,\n",
+    "#        'admissions_train.admitted.expression' gives us an expression that can be used with SQLAlchemy clauseElements."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## BITAND Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function performs the logical AND operation on the corresponding bits from the two input arguments.\n",
+    "# Syntax:\n",
+    "# =======\n",
+    "#         BITAND(target_arg, bit_mask_arg)\n",
+    "\n",
+    "# Argument Description:\n",
+    "# =====================\n",
+    "#     target_arg\n",
+    "#         A numeric or variable byte expression.\n",
+    "#         Supported types for 'target_arg' are as follows:\n",
+    "#             BYTEINT\n",
+    "#             SMALLINT\n",
+    "#             INTEGER\n",
+    "#             BIGINT\n",
+    "#             DECIMAL\n",
+    "#             NUMBER\n",
+    "#             VARBYTE(n)\n",
+    "#     bit_mask_arg\n",
+    "#         A fixed byte value, a variable byte value, or a numeric expression.\n",
+    "\n",
+    "# Function Description:\n",
+    "# =====================\n",
+    "#    This function takes two bit patterns of equal length and performs the logical AND operation on each pair \n",
+    "#    of corresponding bits as follows:\n",
+    "#        1. If the bits at the same position are both 1, then the result is 1; otherwise, \n",
+    "#    the result is 0. \n",
+    "#        2. If either input argument is NULL, the function returns NULL.\n",
+    "#\n",
+    "#    If the target_arg and bit_mask_arg arguments differ in length, the arguments are processed as follows:\n",
+    "#        1. The target_arg and bit_mask_arg arguments are aligned on their least significant byte/bit.\n",
+    "#        2. The smaller argument is padded with zeros to the left until it becomes the same size as the larger argument."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The data type of the bit_mask_arg parameter varies depending upon the data type of the target_arg parameter. \n",
+    "The following (target_arg, bit_mask_arg) input combinations are permitted:\n",
+    "\n",
+    "| target_arg type | bit_mask_arg type |\n",
+    "|------|------|\n",
+    "| BYTEINT\t| BYTE(1) |\n",
+    "| BYTEINT\t| BYTEINT |\n",
+    "| SMALLINT\t| BYTE(2) |\n",
+    "| SMALLINT\t| SMALLINT |\n",
+    "| INTEGER\t| BYTE(4) |\n",
+    "| INTEGER\t| INTEGER |\n",
+    "| BIGINT\t| BYTE(8) |\n",
+    "| BIGINT\t| BIGINT |\n",
+    "| NUMBER(38,0)\t| VARBYTE(16) |\n",
+    "| NUMBER(38,0)\t| NUMBER(38,0) |\n",
+    "| VARBYTE(n)\t| VARBYTE(n) |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bit_byte_func_ = func.BITAND(bytes_table.id_col.expression, bytes_table.byte_col.expression)\n",
+    "type(bit_byte_func_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select bitand(varbyte_col, byte_col) AS bitand_byte_, BITAND(id_col, byte_col) AS bitand_id_ from \"bytes_table\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "  bitand_byte_  bitand_id_\n",
+      "0        b'63'           0\n",
+      "1        b'20'           0\n",
+      "2        b'60'           0\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "bitand_byte_    bytes\n",
+      "bitand_id_        int\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'bitand_id_' Column Type: INTEGER\n",
+      " 'bitand_byte_' Column Type: VARBYTE\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Note: Function name case does not matter. We can use the function name in lower case, upper case or mixed case.\n",
+    "df = bytes_table.assign(True, bitand_id_=bit_byte_func_, \n",
+    "                        bitand_byte_=func.bitand(bytes_table.varbyte_col.expression, bytes_table.byte_col.expression)\n",
+    "                       )\n",
+    "print_variables(df, [\"bitand_id_\", \"bitand_byte_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## BITNOT Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function performs a bitwise complement on the binary representation of the input argument.\n",
+    "# Syntax:\n",
+    "# =======\n",
+    "#         BITNOT(target_arg)\n",
+    "\n",
+    "# Argument Description:\n",
+    "# =====================\n",
+    "#     target_arg\n",
+    "#         A numeric or variable byte expression.\n",
+    "#         Supported types for 'target_arg' are as follows:\n",
+    "#             BYTEINT\n",
+    "#             SMALLINT\n",
+    "#             INTEGER\n",
+    "#             BIGINT\n",
+    "#             VARBYTE(n)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bit_byte_func_ = func.BITNOT(bytes_table.varbyte_col.expression)\n",
+    "type(bit_byte_func_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select BITNOT(varbyte_col) AS bitnot_byte_ from \"bytes_table\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "       bitnot_byte_\n",
+      "0  b'-616263643133'\n",
+      "1      b'-62717766'\n",
+      "2      b'-627A7864'\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "bitnot_byte_    bytes\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'bitnot_byte_' Column Type: VARBYTE\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Note: Function name case does not matter. We can use the function name in lower case, upper case or mixed case.\n",
+    "df = bytes_table.assign(True, bitnot_byte_=bit_byte_func_)\n",
+    "print_variables(df, [\"bitnot_byte_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## BITOR Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function performs the logical OR operation on the corresponding bits from the two input arguments.\n",
+    "# Syntax:\n",
+    "# =======\n",
+    "#         BITOR(target_arg, bit_mask_arg)\n",
+    "\n",
+    "# Argument Description:\n",
+    "# =====================\n",
+    "#     target_arg\n",
+    "#         A numeric or variable byte expression.\n",
+    "#         Supported types for 'target_arg' are as follows:\n",
+    "#             BYTEINT\n",
+    "#             SMALLINT\n",
+    "#             INTEGER\n",
+    "#             BIGINT\n",
+    "#             VARBYTE(n)\n",
+    "#     bit_mask_arg\n",
+    "#         A fixed byte value, a variable byte value, or a numeric expression.\n",
+    "\n",
+    "# Function Description:\n",
+    "# =====================\n",
+    "#    This function takes two bit patterns of equal length and performs the logical OR operation on each pair \n",
+    "#    of corresponding bits as follows:\n",
+    "#        1. If either of the bits from the input arguments is 1, then the result is 1.\n",
+    "#        2. If both of the bits from the input arguments are 0, then the result is 0.\n",
+    "#        3. If any of the input arguments is NULL, then the result is NULL.\n",
+    "#\n",
+    "#    If the target_arg and bit_mask_arg arguments differ in length, the arguments are processed as follows:\n",
+    "#        1. The target_arg and bit_mask_arg arguments are aligned on their least significant byte/bit.\n",
+    "#        2. The smaller argument is padded with zeros to the left until it becomes the same size as the larger argument."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The data type of the bit_mask_arg parameter varies depending upon the data type of the target_arg parameter. \n",
+    "The following (target_arg, bit_mask_arg) input combinations are permitted:\n",
+    "\n",
+    "| target_arg type | bit_mask_arg type |\n",
+    "|------|------|\n",
+    "| BYTEINT\t| BYTE(1) |\n",
+    "| BYTEINT\t| BYTEINT |\n",
+    "| SMALLINT\t| BYTE(2) |\n",
+    "| SMALLINT\t| SMALLINT |\n",
+    "| INTEGER\t| BYTE(4) |\n",
+    "| INTEGER\t| INTEGER |\n",
+    "| BIGINT\t| BYTE(8) |\n",
+    "| BIGINT\t| BIGINT |\n",
+    "| VARBYTE(n)\t| VARBYTE(n) |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "sqlalchemy.sql.functions.Function"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bit_byte_func_ = func.Bitor(bytes_table.id_col.expression, bytes_table.byte_col.expression)\n",
+    "type(bit_byte_func_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select Bitor(id_col, byte_col) AS bitor_byte_ from \"bytes_table\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   bitor_byte_\n",
+      "0   1627389954\n",
+      "1   1644167169\n",
+      "2   1660944384\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "bitor_byte_    int\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'bitor_byte_' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Note: Function name case does not matter. We can use the function name in lower case, upper case or mixed case.\n",
+    "df = bytes_table.assign(True, bitor_byte_=bit_byte_func_)\n",
+    "print_variables(df, [\"bitor_byte_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## BITXOR Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function performs a bitwise XOR operation on the binary representation of the two input arguments.\n",
+    "# Syntax:\n",
+    "# =======\n",
+    "#         BITXOR(target_arg, bit_mask_arg)\n",
+    "\n",
+    "# Argument Description:\n",
+    "# =====================\n",
+    "#     target_arg\n",
+    "#         A numeric or variable byte expression.\n",
+    "#         Supported types for 'target_arg' are as follows:\n",
+    "#             BYTEINT\n",
+    "#             SMALLINT\n",
+    "#             INTEGER\n",
+    "#             BIGINT\n",
+    "#             VARBYTE(n)\n",
+    "#     bit_mask_arg\n",
+    "#         A fixed byte value, a variable byte value, or a numeric expression.\n",
+    "\n",
+    "# Function Description:\n",
+    "# =====================\n",
+    "#    This function takes two bit patterns of equal length and performs the logical OR operation on each pair \n",
+    "#    of corresponding bits as follows:\n",
+    "#        1. The result in each position is 1 if the two bits are different.\n",
+    "#        2. The result in each position is 0 if the two bits are same.\n",
+    "#        3. If any of the input arguments is NULL, then the result is NULL.\n",
+    "#\n",
+    "#    If the target_arg and bit_mask_arg arguments differ in length, the arguments are processed as follows:\n",
+    "#        1. The target_arg and bit_mask_arg arguments are aligned on their least significant byte/bit.\n",
+    "#        2. The smaller argument is padded with zeros to the left until it becomes the same size as the larger argument."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The data type of the bit_mask_arg parameter varies depending upon the data type of the target_arg parameter. \n",
+    "The following (target_arg, bit_mask_arg) input combinations are permitted:\n",
+    "\n",
+    "| target_arg type | bit_mask_arg type |\n",
+    "|------|------|\n",
+    "| BYTEINT| BYTE(1) |\n",
+    "| BYTEINT| BYTEINT |\n",
+    "| SMALLINT| BYTE(2) |\n",
+    "| SMALLINT| SMALLINT |\n",
+    "| INTEGER| BYTE(4) |\n",
+    "| INTEGER| INTEGER |\n",
+    "| BIGINT| BYTE(8) |\n",
+    "| BIGINT| BIGINT |\n",
+    "| VARBYTE(n)| VARBYTE(n) |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select BITXOR(id_col, byte_col) AS bitxor_int_byte_ from \"bytes_table\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   bitxor_int_byte_\n",
+      "0        1660944384\n",
+      "1        1627389954\n",
+      "2        1644167169\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "bitxor_int_byte_    int\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'bitxor_int_byte_' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Note: Function name case does not matter. We can use the function name in lower case, upper case or mixed case.\n",
+    "df = bytes_table.assign(True, bitxor_int_byte_= func.BITXOR(bytes_table.id_col.expression, bytes_table.byte_col.expression))\n",
+    "print_variables(df, [\"bitxor_int_byte_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## COUNTSET Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the count of the binary bits within the target_arg expression \n",
+    "# that are either set to 1 or set to 0 depending on the target_value_arg value.\n",
+    "# Syntax:\n",
+    "# =======\n",
+    "#         COUNTSET(target_arg, target_arg_value)\n",
+    "\n",
+    "# Argument Description:\n",
+    "# =====================\n",
+    "#     target_arg\n",
+    "#         A numeric or variable byte expression.\n",
+    "#     target_value_arg\n",
+    "#         An integer value. Only a value of 0 or 1 is allowed. If target_value_arg is not specified, the default is 1.\n",
+    "\n",
+    "# Function Description:\n",
+    "# =====================\n",
+    "#     COUNTSET takes the target_arg input expression and counts the number of bits within the expression \n",
+    "#     that are either set to 1 or set to 0, depending on the value of target_value_arg.\n",
+    "#\n",
+    "#     The target_value_arg parameter only accepts a value of 0 or 1. If a value for target_value_arg is \n",
+    "#     not specified, the default value of 1 is used, and COUNTSET counts the bit values that are set to 1.\n",
+    "#\n",
+    "#     If any of the input arguments is NULL, the function returns NULL."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It is defined with the following parameter data types for the following (target_arg [,target_value_arg]) input combinations:\n",
+    "\n",
+    "| target_arg type\t| target_value_arg type (optional) |\n",
+    "| ------- | ------ |\n",
+    "| BYTEINT |\tINTEGER |\n",
+    "| SMALLINT\t| INTEGER |\n",
+    "| INTEGER\t| INTEGER |\n",
+    "| BIGINT\t| INTEGER |\n",
+    "| VARBYTE(n) |\tINTEGER |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select COUNTSET(varbyte_col, 0) AS count_0s_varbyte_, COUNTSET(varbyte_col) AS count_1s_varbyte_ from \"bytes_table\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   count_0s_varbyte_  count_1s_varbyte_\n",
+      "0                 16                 16\n",
+      "1                 29                 19\n",
+      "2                 15                 17\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "count_0s_varbyte_    int\n",
+      "count_1s_varbyte_    int\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'count_1s_varbyte_' Column Type: INTEGER\n",
+      " 'count_0s_varbyte_' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Note: Function name case does not matter. We can use the function name in lower case, upper case or mixed case.\n",
+    "df = bytes_table.assign(True, \n",
+    "                        count_1s_varbyte_= func.COUNTSET(bytes_table.varbyte_col.expression),\n",
+    "                        count_0s_varbyte_= func.COUNTSET(bytes_table.varbyte_col.expression, 0)\n",
+    "                       )\n",
+    "print_variables(df, [\"count_1s_varbyte_\", \"count_0s_varbyte_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## GETBIT Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the value of the bit specified by target_bit_arg from the target_arg byte expression.\n",
+    "# Syntax:\n",
+    "# =======\n",
+    "#         GETBIT(target_arg, target_bit_arg)\n",
+    "\n",
+    "# Argument Description:\n",
+    "# =====================\n",
+    "#     target_arg\n",
+    "#         A numeric or variable byte expression.\n",
+    "#     target_bit_arg\n",
+    "#         An integer expression.\n",
+    "\n",
+    "# Function Description:\n",
+    "# =====================\n",
+    "#     GETBIT gets the bit specified by target_bit_arg from the target_arg byte expression \n",
+    "#     and returns either 0 or 1 to indicate the value of that bit.\n",
+    "#\n",
+    "#     The range of input values for target_bit_arg can vary from 0 (bit 0 is the least significant bit) \n",
+    "#     to the (sizeof(target_arg) - 1).\n",
+    "#\n",
+    "#     If target_bit_arg is negative or out-of-range (meaning that it exceeds the size of target_arg), \n",
+    "#     an error is returned.\n",
+    "#\n",
+    "#     If either input argument is NULL, the function returns NULL."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It is defined with the following parameter data types for the following (target_arg, target_bit_arg) input combinations:\n",
+    "\n",
+    "| target_arg type\t| target_bit_arg type (optional) |\n",
+    "| ------- | ------ |\n",
+    "| BYTEINT |\tINTEGER |\n",
+    "| SMALLINT\t| INTEGER |\n",
+    "| INTEGER\t| INTEGER |\n",
+    "| BIGINT\t| INTEGER |\n",
+    "| VARBYTE(n) |\tINTEGER |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select GETBIT(id_col, 1) AS getbit_int_, GETBIT(varbyte_col, 3) AS getbit_varbyte_ from \"bytes_table\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   getbit_int_  getbit_varbyte_\n",
+      "0            0                0\n",
+      "1            1                0\n",
+      "2            0                0\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "getbit_int_        int\n",
+      "getbit_varbyte_    int\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'getbit_varbyte_' Column Type: BYTEINT\n",
+      " 'getbit_int_' Column Type: BYTEINT\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Note: Function name case does not matter. We can use the function name in lower case, upper case or mixed case.\n",
+    "df = bytes_table.assign(True, \n",
+    "                        getbit_varbyte_= func.GETBIT(bytes_table.varbyte_col.expression, 3),\n",
+    "                        getbit_int_= func.GETBIT(bytes_table.id_col.expression, 1)\n",
+    "                       )\n",
+    "print_variables(df, [\"getbit_varbyte_\", \"getbit_int_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## ROTATELEFT Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns an expression rotated to the left by the number of bits you specify, \n",
+    "# with the most significant bits wrapping around to the right.\n",
+    "# Syntax:\n",
+    "# =======\n",
+    "#         ROTATELEFT(target_arg, num_bits_arg)\n",
+    "\n",
+    "# Argument Description:\n",
+    "# =====================\n",
+    "#     target_arg\n",
+    "#         A numeric or variable byte expression.\n",
+    "#     num_bits_arg\n",
+    "#         An integer expression indicating the number of bit positions to rotate.\n",
+    "\n",
+    "# Function Description:\n",
+    "# =====================\n",
+    "#     1. If num_bits_arg is equal to zero then the function returns target_arg unchanged.\n",
+    "#     2. If num_bits_arg is negative then the function rotates the bits to the right instead of the left.\n",
+    "#     3. If target_arg and/or num_bits_arg are NULL then the function returns NULL.\n",
+    "#     4. If num_bits_arg is larger than the size of target_arg then the function rotates \n",
+    "#        (num_bits_arg MOD sizeof(target_arg)) bits. The scope of the rotation operation is bounded by the size\n",
+    "#        of the target_arg expression.\n",
+    "#         NOTE:\n",
+    "#             When operating against an integer value (BYTEINT, SMALLINT, INTEGER, or BIGINT), rotating a bit into the \n",
+    "#             most significant position will result in the integer becoming negative. This is because all integers in \n",
+    "#             Teradata Database are signed integers."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It is defined with the following parameter data types for the following (target_arg, num_bits_arg) input combinations:\n",
+    "\n",
+    "| target_arg type\t| num_bits_arg type (optional) |\n",
+    "| ------- | ------ |\n",
+    "| BYTEINT |\tINTEGER |\n",
+    "| SMALLINT\t| INTEGER |\n",
+    "| INTEGER\t| INTEGER |\n",
+    "| BIGINT\t| INTEGER |\n",
+    "| VARBYTE(n) |\tINTEGER |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select ROTATELEFT(id_col, 5) AS rotateleft_int_, ROTATELEFT(varbyte_col, 1) AS rotateleft_varbyte_ from \"bytes_table\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   rotateleft_int_ rotateleft_varbyte_\n",
+      "0               64    b'-3D3B39379D9C'\n",
+      "1               32        b'-3B1D1136'\n",
+      "2                0        b'-3B0B0F3A'\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "rotateleft_int_          int\n",
+      "rotateleft_varbyte_    bytes\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'rotateleft_varbyte_' Column Type: VARBYTE\n",
+      " 'rotateleft_int_' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Note: Function name case does not matter. We can use the function name in lower case, upper case or mixed case.\n",
+    "df = bytes_table.assign(True, \n",
+    "                        rotateleft_varbyte_= func.ROTATELEFT(bytes_table.varbyte_col.expression, 1),\n",
+    "                        rotateleft_int_= func.ROTATELEFT(bytes_table.id_col.expression, 5)\n",
+    "                       )\n",
+    "print_variables(df, [\"rotateleft_varbyte_\", \"rotateleft_int_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## ROTATERIGHT Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns an expression rotated to the right by the number of bits you specify, \n",
+    "# with the least significant bits wrapping around to the left.\n",
+    "# Syntax:\n",
+    "# =======\n",
+    "#         ROTATERIGHT(target_arg, num_bits_arg)\n",
+    "\n",
+    "# Argument Description:\n",
+    "# =====================\n",
+    "#     target_arg\n",
+    "#         A numeric or variable byte expression.\n",
+    "#     num_bits_arg\n",
+    "#         An integer expression indicating the number of bit positions to rotate.\n",
+    "\n",
+    "# Function Description:\n",
+    "# =====================\n",
+    "#     1. If num_bits_arg is equal to zero then the function returns target_arg unchanged.\n",
+    "#     2. If num_bits_arg is negative then the function rotates the bits to the left instead of the right.\n",
+    "#     3. If target_arg and/or num_bits_arg are NULL then the function returns NULL.\n",
+    "#     4. If num_bits_arg is larger than the size of target_arg then the function rotates \n",
+    "#        (num_bits_arg MOD sizeof(target_arg)) bits. The scope of the rotation operation is bounded by the size\n",
+    "#        of the target_arg expression.\n",
+    "#         NOTE:\n",
+    "#             When operating against an integer value (BYTEINT, SMALLINT, INTEGER, or BIGINT), rotating a bit into the \n",
+    "#             most significant position will result in the integer becoming negative. This is because all integers in \n",
+    "#             Teradata Database are signed integers."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It is defined with the following parameter data types for the following (target_arg, num_bits_arg) input combinations:\n",
+    "\n",
+    "| target_arg type\t| num_bits_arg type (optional) |\n",
+    "| ------- | ------ |\n",
+    "| BYTEINT |\tINTEGER |\n",
+    "| SMALLINT\t| INTEGER |\n",
+    "| INTEGER\t| INTEGER |\n",
+    "| BIGINT\t| INTEGER |\n",
+    "| VARBYTE(n) |\tINTEGER |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select ROTATERIGHT(id_col, 2) AS rotateright_int_, rotateright(varbyte_col, 1) AS rotateright_varbyte_ from \"bytes_table\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   rotateright_int_ rotateright_varbyte_\n",
+      "0       -2147483648      b'30B131B21899'\n",
+      "1        1073741824         b'-4EC7444E'\n",
+      "2                 0         b'-4EC2C3CF'\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "rotateright_int_          int\n",
+      "rotateright_varbyte_    bytes\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'rotateright_varbyte_' Column Type: VARBYTE\n",
+      " 'rotateright_int_' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Note: Function name case does not matter. We can use the function name in lower case, upper case or mixed case.\n",
+    "df = bytes_table.assign(True, \n",
+    "                        rotateright_varbyte_= func.rotateright(bytes_table.varbyte_col.expression, 1),\n",
+    "                        rotateright_int_= func.ROTATERIGHT(bytes_table.id_col.expression, 2)\n",
+    "                       )\n",
+    "print_variables(df, [\"rotateright_varbyte_\", \"rotateright_int_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## SETBIT Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function sets the value of the bit specified by target_bit_arg to the value of target_value_arg\n",
+    "# in the target_arg byte expression.\n",
+    "# Syntax:\n",
+    "# =======\n",
+    "#         SETBIT(target_arg, target_bit_arg, target_value_arg)\n",
+    "\n",
+    "# Argument Description:\n",
+    "# =====================\n",
+    "#    target_arg\n",
+    "#        A numeric or variable byte expression.\n",
+    "#    target_bit_arg\n",
+    "#        An integer expression.\n",
+    "#    target_value_arg\n",
+    "#        An integer value. Only a value of 0 or 1 is allowed. If target_value_arg is not specified, the default is 1.\n",
+    "    \n",
+    "# Function Description:\n",
+    "# =====================\n",
+    "#    SETBIT takes the target_arg input and sets the bit specified by target_bit_arg to the value, 0 or 1, \n",
+    "#    as provided by the target_value_arg argument.\n",
+    "#\n",
+    "#    The target_value_arg parameter only accepts a value of 0 or 1. If a value for target_value_arg is not specified, \n",
+    "#    the default value of 1 is used.\n",
+    "#\n",
+    "#    The range of input values for target_bit_arg can vary from 0 (bit 0 is the least significant bit) \n",
+    "#    to the (sizeof(target_arg) - 1).\n",
+    "#\n",
+    "#    If target_bit_arg is negative or out-of-range (meaning that it exceeds the size of target_arg), an error is returned.\n",
+    "#\n",
+    "#    If any of the input arguments is NULL, the function returns NULL."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It is defined with the following parameter data types for the following (target_arg, target_bit_arg, target_value_arg) input combinations:\n",
+    "\n",
+    "| target_arg type\t| target_bit_arg type | target_value_arg type(optional) |\n",
+    "| ------- | ------ | ------ |\n",
+    "| BYTEINT |\tINTEGER |\tINTEGER |\n",
+    "| SMALLINT\t| INTEGER |\tINTEGER |\n",
+    "| INTEGER\t| INTEGER |\tINTEGER |\n",
+    "| BIGINT\t| INTEGER |\tINTEGER |\n",
+    "| VARBYTE(n) |\tINTEGER |\tINTEGER |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select setbit(id_col, 1) AS setbit_int_1_1, SETBIT(id_col, 2, 0) AS setbit_int_2_0 from \"bytes_table\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   setbit_int_1_1  setbit_int_2_0\n",
+      "0               2               0\n",
+      "1               2               2\n",
+      "2               3               1\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "setbit_int_1_1    int\n",
+      "setbit_int_2_0    int\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'setbit_int_1_1' Column Type: INTEGER\n",
+      " 'setbit_int_2_0' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Note: Function name case does not matter. We can use the function name in lower case, upper case or mixed case.\n",
+    "df = bytes_table.assign(True, \n",
+    "                        setbit_int_1_1= func.setbit(bytes_table.id_col.expression, 1),\n",
+    "                        setbit_int_2_0= func.SETBIT(bytes_table.id_col.expression, 2, 0)\n",
+    "                       )\n",
+    "print_variables(df, [\"setbit_int_1_1\", \"setbit_int_2_0\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## SHIFTLEFT Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the expression target_arg shifted by the specified number of bits (num_bits_arg) to the left. \n",
+    "# The bits in the most significant positions are lost, and the bits in the least significant positions are \n",
+    "# filled with zeros.\n",
+    "#\n",
+    "# Syntax:\n",
+    "# =======\n",
+    "#         SHIFTLEFT(target_arg, num_bits_arg)\n",
+    "\n",
+    "# Argument Description:\n",
+    "# =====================\n",
+    "#    target_arg\n",
+    "#        A numeric or variable byte expression.\n",
+    "#    num_bits_arg\n",
+    "#        An integer expression indicating the number of bit positions to shift.\n",
+    "\n",
+    "# Function Description:\n",
+    "# =====================\n",
+    "#     1. If num_bits_arg is equal to zero then the function returns target_arg unchanged.\n",
+    "#     2. If num_bits_arg is negative then the function shifts the bits to the right instead of the left.\n",
+    "#     3. If target_arg and/or num_bits_arg are NULL then the function returns NULL.\n",
+    "#     4. If num_bits_arg is larger than the size of target_arg then the function returns an error.\n",
+    "#        The scope of the shift operation is bounded by the size of the target_arg expression. \n",
+    "#        Specifying a shift that is outside the range of target_arg results in an SQL error.\n",
+    "#         NOTE:\n",
+    "#             When operating against an integer value (BYTEINT, SMALLINT, INTEGER, or BIGINT), shifting a bit \n",
+    "#             into the most significant position will result in the integer becoming negative. This is because \n",
+    "#             all integers in Teradata Database are signed integers."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It is defined with the following parameter data types for the following (target_arg, num_bits_arg) input combinations:\n",
+    "\n",
+    "| target_arg type\t| num_bits_arg type (optional) |\n",
+    "| ------- | ------ |\n",
+    "| BYTEINT |\tINTEGER |\n",
+    "| SMALLINT\t| INTEGER |\n",
+    "| INTEGER\t| INTEGER |\n",
+    "| BIGINT\t| INTEGER |\n",
+    "| VARBYTE(n) |\tINTEGER |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select ShiftLeft(id_col, 2) AS shiftleft_int_, shiftleft(varbyte_col, 1) AS shiftleft_varbyte_ from \"bytes_table\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   shiftleft_int_ shiftleft_varbyte_\n",
+      "0               8   b'-3D3B39379D9C'\n",
+      "1               4       b'-3B1D1136'\n",
+      "2               0       b'-3B0B0F3A'\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "shiftleft_int_          int\n",
+      "shiftleft_varbyte_    bytes\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'shiftleft_varbyte_' Column Type: VARBYTE\n",
+      " 'shiftleft_int_' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Note: Function name case does not matter. We can use the function name in lower case, upper case or mixed case.\n",
+    "df = bytes_table.assign(True, \n",
+    "                        shiftleft_varbyte_= func.shiftleft(bytes_table.varbyte_col.expression, 1),\n",
+    "                        shiftleft_int_= func.ShiftLeft(bytes_table.id_col.expression, 2)\n",
+    "                       )\n",
+    "print_variables(df, [\"shiftleft_varbyte_\", \"shiftleft_int_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## SHIFTRIGHT Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function returns the expression target_arg shifted by the specified number of bits (num_bits_arg) to the right. \n",
+    "# The bits in the least significant positions are lost, and the bits in the most significant positions are filled with zeros.\n",
+    "# Syntax:\n",
+    "# =======\n",
+    "#         SHIFTRIGHT(target_arg, num_bits_arg)\n",
+    "\n",
+    "# Argument Description:\n",
+    "# =====================\n",
+    "#    target_arg\n",
+    "#        A numeric or variable byte expression.\n",
+    "#    tnum_bits_arg\n",
+    "#        An integer expression indicating the number of bit positions to shift.\n",
+    "\n",
+    "# Function Description:\n",
+    "# =====================\n",
+    "#     1. If num_bits_arg is equal to zero then the function returns target_arg unchanged.\n",
+    "#     2. If num_bits_arg is negative then the function shifts the bits to the left instead of the right.\n",
+    "#     3. If target_arg and/or num_bits_arg are NULL then the function returns NULL.\n",
+    "#     4. If num_bits_arg is larger than the size of target_arg then the function returns an error.\n",
+    "#        The scope of the shift operation is bounded by the size of the target_arg expression. \n",
+    "#        Specifying a shift that is outside the range of target_arg results in an SQL error.\n",
+    "#         NOTE:\n",
+    "#             When operating against an integer value (BYTEINT, SMALLINT, INTEGER, or BIGINT), shifting a bit \n",
+    "#             into the most significant position will result in the integer becoming negative. This is because \n",
+    "#             all integers in Teradata Database are signed integers."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It is defined with the following parameter data types for the following (target_arg, num_bits_arg) input combinations:\n",
+    "\n",
+    "| target_arg type\t| num_bits_arg type (optional) |\n",
+    "| ------- | ------ |\n",
+    "| BYTEINT |\tINTEGER |\n",
+    "| SMALLINT\t| INTEGER |\n",
+    "| INTEGER\t| INTEGER |\n",
+    "| BIGINT\t| INTEGER |\n",
+    "| VARBYTE(n) |\tINTEGER |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select ShiftRight(id_col, 2) AS shiftright_int_, shiftright(varbyte_col, 1) AS shiftright_varbyte_ from \"bytes_table\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "   shiftright_int_ shiftright_varbyte_\n",
+      "0                0     b'30B131B21899'\n",
+      "1                0         b'3138BBB2'\n",
+      "2                0         b'313D3C31'\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "shiftright_int_          int\n",
+      "shiftright_varbyte_    bytes\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'shiftright_varbyte_' Column Type: VARBYTE\n",
+      " 'shiftright_int_' Column Type: INTEGER\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Note: Function name case does not matter. We can use the function name in lower case, upper case or mixed case.\n",
+    "df = bytes_table.assign(True, \n",
+    "                        shiftright_varbyte_= func.shiftright(bytes_table.varbyte_col.expression, 1),\n",
+    "                        shiftright_int_= func.ShiftRight(bytes_table.id_col.expression, 2)\n",
+    "                       )\n",
+    "print_variables(df, [\"shiftright_varbyte_\", \"shiftright_int_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## SUBBITSTR Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function extracts a bit substring from the target_arg input expression based on the specified bit position.\n",
+    "#\n",
+    "# Syntax:\n",
+    "# =======\n",
+    "#         SUBBITSTR(target_arg, position_arg, num_bits_arg)\n",
+    "\n",
+    "# Arguemnt Description:\n",
+    "# =====================\n",
+    "#    target_arg\n",
+    "#        A numeric or variable byte expression.\n",
+    "#    position_arg\n",
+    "#        An integer expression indicating the starting position of the bit substring to be extracted.\n",
+    "#    num_bits_arg\n",
+    "#        An integer expression indicating the length of the bit substring to be extracted. \n",
+    "#        This specifies the number of bits for the function to return.\n",
+    "\n",
+    "# Function Description:\n",
+    "# =====================\n",
+    "#    SUBBITSTR extracts a bit substring from the target_arg string expression starting at the bit position \n",
+    "#    specified by position_arg. For the range of bit positions for each data type, see Bit and Byte Numbering Model.\n",
+    "#\n",
+    "#    The num_bits_arg value specifies the length of the bit substring to be extracted and indicates the number\n",
+    "#    of bits that the function should return. Because the return value of the function is a VARBYTE string, \n",
+    "#    the number of bits returned is rounded to the byte boundary greater than the number of bits requested.\n",
+    "#\n",
+    "#    The bits returned is right-justified, and the excess bits (those exceeding the requested number of bits) \n",
+    "#    are filled with zeros.\n",
+    "#\n",
+    "#    If position_arg is negative or out-of-range (meaning that it exceeds the size of target_arg), an error is returned.\n",
+    "#\n",
+    "#    If num_bits_arg is negative, or is greater than the number of bits remaining after the starting \n",
+    "#    position_arg is taken into account, an error is returned.\n",
+    "#\n",
+    "#    If any of the input arguments is NULL, the function returns NULL."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It is defined with the following parameter data types for the following (target_arg, position_arg, num_bits_arg) input combinations:\n",
+    "\n",
+    "| target_arg type\t| position_arg type | num_bits_arg type |\n",
+    "| ------- | ------ | ------ |\n",
+    "| BYTEINT |\tINTEGER |\tINTEGER |\n",
+    "| SMALLINT\t| INTEGER |\tINTEGER |\n",
+    "| INTEGER\t| INTEGER |\tINTEGER |\n",
+    "| BIGINT\t| INTEGER |\tINTEGER |\n",
+    "| VARBYTE(n) |\tINTEGER |\tINTEGER |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select SUBBITSTR(varbyte_col, 3, 4) AS subbitstr_varbyte_ from \"bytes_table\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "  subbitstr_varbyte_\n",
+      "0               b'C'\n",
+      "1               b'6'\n",
+      "2               b'C'\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "subbitstr_varbyte_    bytes\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'subbitstr_varbyte_' Column Type: VARBYTE\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Note: Function name case does not matter. We can use the function name in lower case, upper case or mixed case.\n",
+    "df = bytes_table.assign(True, \n",
+    "                        subbitstr_varbyte_= func.SUBBITSTR(bytes_table.varbyte_col.expression, 3, 4)\n",
+    "                       )\n",
+    "print_variables(df, [\"subbitstr_varbyte_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## TO_BYTE Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function converts a numeric data type to the Teradata Database server byte representation (byte value) of the input value.\n",
+    "# Syntax:\n",
+    "# =======\n",
+    "#         TO_BYTE(target_arg)\n",
+    "\n",
+    "# Arguemnt Description:\n",
+    "# =====================\n",
+    "#    target_arg\n",
+    "#        A numeric or variable byte expression.\n",
+    "#        It is defined with the following parameter data types:\n",
+    "#           BYTEINT\n",
+    "#           SMALLINT\n",
+    "#           INTEGER\n",
+    "#           BIGINT\n",
+    "\n",
+    "# Function Description:\n",
+    "# =====================\n",
+    "#     The number of bytes returned by the function varies according to the data type of the target_arg value.\n",
+    "#\n",
+    "#     If target_arg is NULL, the function returns NULL."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Equivalent SQL: select to_byte(id_col) AS int_to_byte_ from \"bytes_table\"\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame ********************* \n",
+      "  int_to_byte_\n",
+      "0         b'2'\n",
+      "1         b'1'\n",
+      "2         b'0'\n",
+      "\n",
+      "\n",
+      "\n",
+      " ************************* DataFrame.dtypes ********************* \n",
+      "int_to_byte_    bytes\n",
+      "\n",
+      "\n",
+      "\n",
+      " 'int_to_byte_' Column Type: BYTE\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Note: Function name case does not matter. We can use the function name in lower case, upper case or mixed case.\n",
+    "df = bytes_table.assign(True, \n",
+    "                        int_to_byte_= func.to_byte(bytes_table.id_col.expression)\n",
+    "                       )\n",
+    "print_variables(df, [\"int_to_byte_\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## NOTE: If Incorrect type input is passed to any of these function, one may see following error:\n",
+    "        [Error 9881] Function 'to_byte' called with an invalid number or type of parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "remove_context()"
+   ]
+  },
+  {
+   "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
+}