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

teradataml/dataframe/dataframe.py

@@ -29,12 +29,12 @@ from teradataml.dataframe.sql_interfaces import ColumnExpression
 from teradataml.dataframe.sql_functions import case
 from teradataml.series.series import Series
 from teradatasqlalchemy.types import _TDType, BIGINT, INTEGER, PERIOD_TIMESTAMP, SMALLINT, BYTEINT, FLOAT, DECIMAL
-from teradataml.common.utils import UtilFuncs, argument_deprecation
+from teradataml.common.utils import UtilFuncs
 from teradataml.common.exceptions import TeradataMlException
 from teradataml.common.messages import Messages
 from teradataml.common.messagecodes import MessageCodes
 from teradataml.common.constants import AEDConstants
-from teradataml.common.constants import SourceType, PythonTypes, TeradataConstants,\
+from teradataml.common.constants import SourceType, PythonTypes, TeradataConstants, \
     TeradataTypes, PTITableConstants, TableOperatorConstants, SQLFunctionConstants
 from teradataml.dataframe.dataframe_utils import DataFrameUtils as df_utils, DataFrameUtils
 from teradataml.dataframe.indexer import _LocationIndexer
@@ -52,9 +52,10 @@ from teradatasql import OperationalError
 from teradataml.dataframe.window import Window
 from teradataml.dataframe.data_transfer import _DataTransferUtils
 from teradataml.common.bulk_exposed_utils import _validate_unimplemented_function
+from teradatasqlalchemy.telemetry.queryband import collect_queryband
 
-#TODO use logger when available on master branch
-#logger = teradatapylog.getLogger()
+# TODO use logger when available on master branch
+# logger = teradatapylog.getLogger()
 in_schema = UtilFuncs._in_schema
 
 
@@ -215,7 +216,7 @@ class DataFrame():
                         raise ValueError(Messages.get_message(
                             MessageCodes.FROM_QUERY_SELECT_SUPPORTED).format("Check the syntax."))
                     raise ValueError(Messages.get_message(
-                            MessageCodes.FROM_QUERY_SELECT_SUPPORTED))
+                        MessageCodes.FROM_QUERY_SELECT_SUPPORTED))
 
                 self._nodeid = self._aed_utils._aed_query(self._query, temp_table_name)
             else:
@@ -229,6 +230,8 @@ class DataFrame():
 
             self._loc = _LocationIndexer(self)
             self._iloc = _LocationIndexer(self, integer_indexing=True)
+            self.__data = None
+            self.__data_columns = None
 
         except TeradataMlException:
             raise
@@ -239,6 +242,7 @@ class DataFrame():
                                       MessageCodes.TDMLDF_CREATE_FAIL) from err
 
     @classmethod
+    @collect_queryband(queryband="DF_fromTable")
     def from_table(cls, table_name, index=True, index_label=None):
         """
         Class method for creating a DataFrame from a table or a view.
@@ -295,6 +299,7 @@ class DataFrame():
         return cls(table_name, index, index_label)
 
     @classmethod
+    @collect_queryband(queryband="DF_fromQuery")
     def from_query(cls, query, index=True, index_label=None, materialize=False):
         """
         Class method for creating a DataFrame from a query.
@@ -407,12 +412,170 @@ class DataFrame():
         if undropped_index is not None and all(elem in [col.name for col in metaexpr.c] for elem in undropped_index):
             df._undropped_index = undropped_index
         elif undropped_index is not None and all(UtilFuncs._teradata_quote_arg(elem, "\"", False)
-                                             in [col.name for col in metaexpr.c] for elem in undropped_index):
-             df._undropped_index = undropped_index
+                                                 in [col.name for col in metaexpr.c] for elem in undropped_index):
+            df._undropped_index = undropped_index
 
         return df
 
-    def __execute_node_and_set_table_name(self, nodeid, metaexpr = None):
+    @collect_queryband(queryband="DF_fillna")
+    def fillna(self, value=None, columns=None, literal_value=False):
+        """
+        Method to replace the null values in a column with the value specified.
+
+        PARAMETERS:
+            value:
+                Required Argument.
+                Specifies the value(s) to replace the null values with. If value is a dict
+                then "columns" is ignored.
+                Note:
+                    * To use pre-defined strings to replace the null value set "literal_value" to True.
+                Permitted Values:
+                    * Pre-defined strings:
+                        * 'MEAN' - Replace null value with the average of the values in the column.
+                        * 'MODE' - Replace null value with the mode of the values in the column.
+                        * 'MEDIAN' - Replace null value with the median of the values in the column.
+                        * 'MIN' - Replace null value with the minimum of the values in the column.
+                        * 'MAX' - Replace null value with the maximum of the values in the column.
+                Types: int, float, str, dict containing column names and value, list
+
+            columns:
+                Optional Argument.
+                Specifies the column names to perform the null value replacement. If "columns"
+                is None, then all the columns having null value and data type similar to
+                the data type of the value specified are considered.
+                Default Value: None
+                Types: str, tuple or list of str
+
+            literal_value:
+                Optional Argument.
+                Specifies whether the pre-defined strings passed to "value" should be treated
+                as literal or not.
+                Default Value: False
+                Types: bool
+
+        RETURNS:
+            teradataml DataFrame
+
+        RAISES:
+            TeradataMlException
+
+        EXAMPLES:
+            >>> load_example_data("dataframe", "sales")
+            >>> df = DataFrame("sales")
+            >>> df
+                          Feb    Jan    Mar    Apr    datetime
+            accounts
+            Blue Inc     90.0   50.0   95.0  101.0  04/01/2017
+            Alpha Co    210.0  200.0  215.0  250.0  04/01/2017
+            Jones LLC   200.0  150.0  140.0  180.0  04/01/2017
+            Yellow Inc   90.0    NaN    NaN    NaN  04/01/2017
+            Orange Inc  210.0    NaN    NaN  250.0  04/01/2017
+            Red Inc     200.0  150.0  140.0    NaN  04/01/2017
+
+            # Example 1: Populate null value in column 'Jan' and 'Mar'
+            #            with the value specified as dictionary.
+            >>> df.fillna({"Jan": 123, "Mar":234})
+                     accounts    Feb  Jan  Mar    Apr  datetime
+                0    Blue Inc   90.0   50   95  101.0  17/01/04
+                1    Alpha Co  210.0  200  215  250.0  17/01/04
+                2   Jones LLC  200.0  150  140  180.0  17/01/04
+                3  Yellow Inc   90.0  123  234    NaN  17/01/04
+                4  Orange Inc  210.0  123  234  250.0  17/01/04
+                5     Red Inc  200.0  150  140    NaN  17/01/04
+
+            # Example 2: Populate the null value in 'Jan' column
+            #            with minimum value in that column.
+            >>> df.fillna("Min", "Jan")
+                     accounts    Feb  Jan    Mar    Apr  datetime
+                0  Yellow Inc   90.0   50    NaN    NaN  17/01/04
+                1   Jones LLC  200.0  150  140.0  180.0  17/01/04
+                2     Red Inc  200.0  150  140.0    NaN  17/01/04
+                3    Blue Inc   90.0   50   95.0  101.0  17/01/04
+                4    Alpha Co  210.0  200  215.0  250.0  17/01/04
+                5  Orange Inc  210.0   50    NaN  250.0  17/01/04
+        """
+        from teradataml import SimpleImputeFit, SimpleImputeTransform
+
+        arg_info_matrix = []
+        arg_info_matrix.append(["value", value, True, (int, float, str, dict, list)])
+        arg_info_matrix.append(["columns", columns, True, (list, str, tuple)])
+        arg_info_matrix.append(["literal_value", literal_value, True, (bool)])
+
+        # Validate argument types
+        _Validators._validate_function_arguments(arg_info_matrix)
+
+        if isinstance(columns, tuple):
+            columns = list(columns)
+
+        # If dict is passed separate the values of 'columns' and 'value'
+        if isinstance(value, dict):
+            columns, value = zip(*value.items())
+            columns = [str(col) for col in columns]
+            value = [str(val) for val in value]
+
+        is_stats = False
+
+        for val in UtilFuncs._as_list(value):
+            if isinstance(val, str) and val.lower() in ["mean", "median", "mode", "min", "max"]:
+                is_stats = True
+                break
+
+        # If "literal_value" is set to False
+        if not literal_value and is_stats:
+            stats = []
+            stats_columns = []
+            literals = []
+            literals_columns = []
+            # If value is a list, extract columns and values, if values match to any
+            # predefined string then assign it to stats and column name to stats_column
+            # else treat it as a literal value and literal column.
+            if isinstance(value, list):
+                for val, col in zip(value, columns):
+                    if isinstance(val, str) and val.lower() in ["mean", "median", "mode", "min", "max"]:
+                        stats.append(val)
+                        stats_columns.append(col)
+                    else:
+                        literals.append(str(val))
+                        literals_columns.append(col)
+            else:
+                # In case it is not a list then simply assign it to 'stats' and 'stats_columns'
+                stats = value
+                stats_columns = columns
+
+            # In case no literal value found in the list and literal list is empty assign it as 'None'
+            # instead of empty list.
+            literals = None if not literals else literals
+            literals_columns = None if not literals_columns else literals_columns
+
+        else:
+            # If it is a literal value then 'stats' and 'stats_column' is not required
+            stats = None
+            stats_columns = None
+
+            # In case column is not specified by the user, then all the columns in that dataframe
+            # should be considered else the specified columns should be considered for 'literal_columns'
+            literals_columns = self.columns if (columns is None and value is not None) else columns
+            literals_columns = UtilFuncs._as_list(literals_columns)
+            # In case value is a list of single element, then multiply it as many times as
+            # number of columns ['12'] -> ['12','12', upto number of columns]
+            # else convert it to str and append it
+            if isinstance(value, list):
+                literals = []
+                for val in value:
+                    literals.append(str(val))
+            else:
+                literals = UtilFuncs._as_list(str(value))
+            literals = literals * len(literals_columns) if len(literals) != len(literals_columns) else literals
+
+        fit_obj = SimpleImputeFit(data=self,
+                                  literals=literals,
+                                  literals_columns=literals_columns,
+                                  stats=stats,
+                                  stats_columns=stats_columns)
+
+        return fit_obj.transform(data=self).result
+
+    def __execute_node_and_set_table_name(self, nodeid, metaexpr=None):
         """
         Private method for executing node and setting _table_name,
         if not set already.
@@ -632,14 +795,14 @@ class DataFrame():
             # get the ColumnExpression from the _MetaExpression
             if isinstance(key, str):
                 return self.__getattr__(key)
-            
+
             if isinstance(key, list):
                 return self.select(key)
 
             if isinstance(key, ClauseElement):
                 from teradataml.dataframe.sql import _SQLColumnExpression
                 key = _SQLColumnExpression(key)
-                
+
             # apply the filter expression
             if isinstance(key, ColumnExpression):
 
@@ -662,7 +825,7 @@ class DataFrame():
             raise
 
         except ValueError:
-             raise
+            raise
 
         except Exception as err:
             errcode = MessageCodes.TDMLDF_INFO_ERROR
@@ -1073,6 +1236,7 @@ class DataFrame():
         td_metadata = [(column.name, repr(column.type)) for column in self._metaexpr.c]
         return MetaData(td_metadata)
 
+    @collect_queryband(queryband="DF_info")
     def info(self, verbose=True, buf=None, max_cols=None, null_counts=False):
         """
         DESCRIPTION:
@@ -1193,8 +1357,10 @@ class DataFrame():
         except TeradataMlException:
             raise
         except Exception as err:
-            raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INFO_ERROR), MessageCodes.TDMLDF_INFO_ERROR) from err
+            raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INFO_ERROR),
+                                      MessageCodes.TDMLDF_INFO_ERROR) from err
 
+    @collect_queryband(queryband="DF_head")
     def head(self, n=display.max_rows):
         """
         DESCRIPTION:
@@ -1291,8 +1457,10 @@ class DataFrame():
         except TeradataMlException:
             raise
         except Exception as err:
-            raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INFO_ERROR), MessageCodes.TDMLDF_INFO_ERROR) from err
+            raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INFO_ERROR),
+                                      MessageCodes.TDMLDF_INFO_ERROR) from err
 
+    @collect_queryband(queryband="DF_tail")
     def tail(self, n=display.max_rows):
         """
         DESCRIPTION:
@@ -1379,14 +1547,16 @@ class DataFrame():
 
         try:
             if self._metaexpr is None:
-                raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INFO_ERROR), MessageCodes.TDMLDF_INFO_ERROR)
+                raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INFO_ERROR),
+                                          MessageCodes.TDMLDF_INFO_ERROR)
 
             sort_col = self._get_sort_col()
             return df_utils._get_sorted_nrow(self, n, sort_col[0], asc=False)
         except TeradataMlException:
             raise
         except Exception as err:
-            raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INFO_ERROR), MessageCodes.TDMLDF_INFO_ERROR) from err
+            raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INFO_ERROR),
+                                      MessageCodes.TDMLDF_INFO_ERROR) from err
 
     def _get_axis(self, axis):
         """
@@ -1414,14 +1584,17 @@ class DataFrame():
             elif axis == "columns":
                 return 1
             else:
-                raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INVALID_DROP_AXIS), MessageCodes.TDMLDF_INVALID_DROP_AXIS)
+                raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INVALID_DROP_AXIS),
+                                          MessageCodes.TDMLDF_INVALID_DROP_AXIS)
         elif isinstance(axis, numbers.Integral):
             if axis in [0, 1]:
                 return axis
             else:
-                raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INVALID_DROP_AXIS), MessageCodes.TDMLDF_INVALID_DROP_AXIS)
+                raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INVALID_DROP_AXIS),
+                                          MessageCodes.TDMLDF_INVALID_DROP_AXIS)
         else:
-            raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INVALID_DROP_AXIS), MessageCodes.TDMLDF_INVALID_DROP_AXIS)
+            raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INVALID_DROP_AXIS),
+                                      MessageCodes.TDMLDF_INVALID_DROP_AXIS)
 
     def _get_sort_col(self):
         """
@@ -1446,7 +1619,7 @@ class DataFrame():
                 col_name = self._index_label[0]
             else:
                 col_name = self._index_label
-        else: #Use the first column from metadata
+        else:  # Use the first column from metadata
             col_name = self.columns[0]
 
         col_type = PythonTypes.PY_NULL_TYPE.value
@@ -1455,16 +1628,20 @@ class DataFrame():
                 col_type = py_type
 
         if col_type == PythonTypes.PY_NULL_TYPE.value:
-            raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INFO_ERROR), MessageCodes.TDMLDF_INFO_ERROR)
+            raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INFO_ERROR),
+                                      MessageCodes.TDMLDF_INFO_ERROR)
 
         sort_col_sqlalchemy_type = (self._metaexpr.t.c[col_name].type)
         # convert types to string from sqlalchemy type for the columns entered for sort
         sort_col_type = repr(sort_col_sqlalchemy_type).split("(")[0]
         if sort_col_type in unsupported_types:
-            raise TeradataMlException(Messages.get_message(MessageCodes.UNSUPPORTED_DATATYPE, sort_col_type, "ANY, except following {}".format(unsupported_types)), MessageCodes.UNSUPPORTED_DATATYPE)
+            raise TeradataMlException(Messages.get_message(MessageCodes.UNSUPPORTED_DATATYPE, sort_col_type,
+                                                           "ANY, except following {}".format(unsupported_types)),
+                                      MessageCodes.UNSUPPORTED_DATATYPE)
 
         return (col_name, col_type)
 
+    @collect_queryband(queryband="DF_drop")
     def drop(self, labels=None, axis=0, columns=None):
         """
         DESCRIPTION:
@@ -1585,7 +1762,7 @@ class DataFrame():
                     index_labels = labels
                 else:
                     column_labels = labels
-            else: # Columns is not None
+            else:  # Columns is not None
                 column_labels = columns
 
             if index_labels is not None:
@@ -1594,7 +1771,8 @@ class DataFrame():
 
                 if isinstance(index_labels, list):
                     if len(index_labels) == 0:
-                        raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_DROP_ARGS), MessageCodes.TDMLDF_DROP_ARGS)
+                        raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_DROP_ARGS),
+                                                  MessageCodes.TDMLDF_DROP_ARGS)
 
                     if sort_col[1] == PythonTypes.PY_STRING_TYPE.value:
                         index_labels = ["'{}'".format(x) for x in index_labels]
@@ -1606,25 +1784,29 @@ class DataFrame():
                         index_expr = index_labels
 
                 filter_expr = "{0} not in ({1})".format(sort_col[0], index_expr)
-                new_nodeid= self._aed_utils._aed_filter(self._nodeid, filter_expr)
+                new_nodeid = self._aed_utils._aed_filter(self._nodeid, filter_expr)
                 # Get the updated metaexpr
                 new_metaexpr = UtilFuncs._get_metaexpr_using_parent_metaexpr(new_nodeid, self._metaexpr)
                 return self._create_dataframe_from_node(new_nodeid, new_metaexpr, self._index_label)
-            else: # Column labels
+            else:  # Column labels
                 select_cols = []
                 cols = [x.name for x in self._metaexpr.columns]
                 if isinstance(column_labels, list):
                     if len(column_labels) == 0:
-                        raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_DROP_ARGS), MessageCodes.TDMLDF_DROP_ARGS)
+                        raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_DROP_ARGS),
+                                                  MessageCodes.TDMLDF_DROP_ARGS)
 
                     if not all(isinstance(n, str) for n in column_labels):
-                        raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_DROP_INVALID_COL_NAMES), MessageCodes.TDMLDF_DROP_INVALID_COL_NAMES)
+                        raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_DROP_INVALID_COL_NAMES),
+                                                  MessageCodes.TDMLDF_DROP_INVALID_COL_NAMES)
                     drop_cols = [x for x in column_labels]
                 elif isinstance(column_labels, (tuple, dict)):
-                    raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_DROP_ARGS), MessageCodes.TDMLDF_DROP_ARGS)
+                    raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_DROP_ARGS),
+                                              MessageCodes.TDMLDF_DROP_ARGS)
                 else:
                     if not isinstance(column_labels, str):
-                        raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_DROP_INVALID_COL_NAMES), MessageCodes.TDMLDF_DROP_INVALID_COL_NAMES)
+                        raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_DROP_INVALID_COL_NAMES),
+                                                  MessageCodes.TDMLDF_DROP_INVALID_COL_NAMES)
                     drop_cols = [column_labels]
 
                 for drop_name in drop_cols:
@@ -1637,14 +1819,17 @@ class DataFrame():
                         select_cols.append(colname)
                 if len(select_cols) > 0:
                     return self.select(select_cols)
-                else: # no columns selected
-                    raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_DROP_ALL_COLS), MessageCodes.TDMLDF_DROP_ALL_COLS)
+                else:  # no columns selected
+                    raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_DROP_ALL_COLS),
+                                              MessageCodes.TDMLDF_DROP_ALL_COLS)
 
         except TeradataMlException:
             raise
         except Exception as err:
-            raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INFO_ERROR), MessageCodes.TDMLDF_INFO_ERROR) from err
+            raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INFO_ERROR),
+                                      MessageCodes.TDMLDF_INFO_ERROR) from err
 
+    @collect_queryband(queryband="DF_dropna")
     def dropna(self, how='any', thresh=None, subset=None):
         """
         DESCRIPTION:
@@ -1755,10 +1940,10 @@ class DataFrame():
                 filter_expr = "{0} >= {1}".format(fmt_filter, thresh)
             elif how == 'any':
                 filter_expr = "{0} = {1}".format(fmt_filter, len(col_filters))
-            else: # how == 'all'
+            else:  # how == 'all'
                 filter_expr = "{0} > 0".format(fmt_filter)
 
-            new_nodeid= self._aed_utils._aed_filter(self._nodeid, filter_expr)
+            new_nodeid = self._aed_utils._aed_filter(self._nodeid, filter_expr)
 
             # Get the updated metaexpr
             new_metaexpr = UtilFuncs._get_metaexpr_using_parent_metaexpr(new_nodeid, self._metaexpr)
@@ -1766,8 +1951,10 @@ class DataFrame():
         except TeradataMlException:
             raise
         except Exception as err:
-            raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INFO_ERROR), MessageCodes.TDMLDF_INFO_ERROR) from err
+            raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INFO_ERROR),
+                                      MessageCodes.TDMLDF_INFO_ERROR) from err
 
+    @collect_queryband(queryband="DF_sort")
     def sort(self, columns, ascending=True):
         """
         DESCRIPTION:
@@ -1903,16 +2090,16 @@ class DataFrame():
         _Validators._validate_column_exists_in_dataframe(columns, self._metaexpr)
 
         try:
-            orderexpr=""
-            type_expr=[]
+            orderexpr = ""
+            type_expr = []
             invalid_types = []
             invalid_columns = []
             unsupported_types = ['BLOB', 'CLOB', 'ARRAY', 'VARRAY']
 
             if (isinstance(columns, str)):
-                columns=[columns]
+                columns = [columns]
             if isinstance(ascending, bool):
-                ascending=[ascending] * len(columns)
+                ascending = [ascending] * len(columns)
 
             # Validating lengths of passed arguments which are passed i.e. length of columns
             # must be same as ascending
@@ -1935,9 +2122,10 @@ class DataFrame():
                     invalid_columns.append(column_name)
                     invalid_types.append(col_type)
             if len(invalid_types) > 0:
-                raise TeradataMlException(Messages.get_message(MessageCodes.INVALID_COLUMN_DATATYPE, ", ".join(invalid_columns), 'columns',
-                                                               "Invalid", ", ".join(unsupported_types)),
-                                          MessageCodes.UNSUPPORTED_DATATYPE)
+                raise TeradataMlException(
+                    Messages.get_message(MessageCodes.INVALID_COLUMN_DATATYPE, ", ".join(invalid_columns), 'columns',
+                                         "Invalid", ", ".join(unsupported_types)),
+                    MessageCodes.UNSUPPORTED_DATATYPE)
 
             orderexpr = []
             get_column_order = lambda asc: 'ASC' if asc else 'DESC'
@@ -1974,7 +2162,8 @@ class DataFrame():
         except TeradataMlException:
             raise
 
-    def filter(self, items = None, like = None, regex = None, axis = 1, **kw):
+    @collect_queryband(queryband="DF_filter")
+    def filter(self, items=None, like=None, regex=None, axis=1, **kw):
         """
         DESCRIPTION:
             Filter rows or columns of dataframe according to labels in the specified index.
@@ -2239,12 +2428,12 @@ class DataFrame():
             op += 'regex'
             valid_value = type(regex) is str
 
-        if op not in('items', 'like', 'regex'):
+        if op not in ('items', 'like', 'regex'):
             raise ValueError('Must use exactly one of the parameters items, like, and regex.')
 
         if not valid_value:
-            msg = 'The "items" parameter must be list of strings or tuples of column labels/index values. ' +\
-                'The "regex" parameter and "like" parameter must be strings.'
+            msg = 'The "items" parameter must be list of strings or tuples of column labels/index values. ' + \
+                  'The "regex" parameter and "like" parameter must be strings.'
             raise TeradataMlException(msg, errcode)
 
         # validate multi index labels for items
@@ -2283,7 +2472,9 @@ class DataFrame():
             msg = Messages.get_message(errcode)
             raise TeradataMlException(msg, errcode)
 
-    def describe(self, percentiles=[.25, .5, .75], include=None, verbose=False, distinct=False, statistics=None):
+    @collect_queryband(queryband="DF_describe")
+    def describe(self, percentiles=[.25, .5, .75], include=None, verbose=False, distinct=False, statistics=None,
+                 columns=None):
         """
         DESCRIPTION:
             Generates statistics for numeric columns. This function can be used in two modes:
@@ -2355,6 +2546,13 @@ class DataFrame():
                 Default Values: None
                 Types: str or List of str
 
+            columns:
+                Optional Argument.
+                Specifies the name(s) of the columns we are collecting statistics for.
+                Default Values: None
+                Types: str or List of str
+
+
         RETURNS:
             teradataml DataFrame
 
@@ -2629,19 +2827,27 @@ class DataFrame():
 
         # Argument validations
         awu_matrix = []
+        awu_matrix.append(["columns", columns, True, (str, list), True])
         awu_matrix.append(["percentiles", percentiles, True, (float, list)])
         awu_matrix.append(["include", include, True, (str), True, [None, "all"]])
         awu_matrix.append(["verbose", verbose, True, (bool)])
         awu_matrix.append(["distinct", distinct, True, (bool)])
-        awu_matrix.append(["statistics", statistics, True, (str, list), True, ["count", "mean", "min", "max", "unique", "std", "describe", "percentile"]])
+        awu_matrix.append(["statistics", statistics, True, (str, list), True,
+                           ["count", "mean", "min", "max", "unique", "std", "describe", "percentile"]])
 
         # Validate argument types
         _Validators._validate_function_arguments(awu_matrix)
 
+        # Checking each element in passed columns to be valid column in dataframe
+        _Validators._validate_column_exists_in_dataframe(columns, self._metaexpr)
+
         # Validate argument values.
         if isinstance(percentiles, float):
             percentiles = [percentiles]
 
+        if columns:
+            columns = UtilFuncs._as_list(columns)
+
         # Converting the statistics list to lower case
         if statistics:
             statistics = [stats.lower() for stats in UtilFuncs._as_list(statistics)]
@@ -2655,7 +2861,7 @@ class DataFrame():
         # Percentiles must be a list of values between 0 and 1.
         if not isinstance(percentiles, list) or not all(p > 0 and p < 1 for p in percentiles):
             raise ValueError(Messages.get_message(MessageCodes.INVALID_ARG_VALUE, percentiles, "percentiles",
-                                                           "percentiles must be a list of values between 0 and 1"))
+                                                  "percentiles must be a list of values between 0 and 1"))
 
         # Argument 'include' with value 'all' is not allowed for DataFrameGroupByTime
         if include is not None and include.lower() == "all" and isinstance(self, DataFrameGroupByTime):
@@ -2679,11 +2885,16 @@ class DataFrame():
             groupby_column_list = None
             if isinstance(self, DataFrameGroupBy):
                 groupby_column_list = self.groupby_column_list
+                df_utils._invalid_describe_column(df=self, columns=columns, metaexpr=self._metaexpr,
+                                                  groupby_column_list=groupby_column_list)
 
             if isinstance(self, DataFrameGroupByTime):
                 groupby_column_list = self.groupby_column_list
+                df_utils._invalid_describe_column(df=self, columns=columns, metaexpr=self._metaexpr,
+                                                  groupby_column_list=groupby_column_list)
+
                 # Construct the aggregate query.
-                agg_query = df_utils._construct_describe_query(df=self, metaexpr=self._metaexpr,
+                agg_query = df_utils._construct_describe_query(df=self, columns=columns, metaexpr=self._metaexpr,
                                                                percentiles=percentiles, function_label=function_label,
                                                                groupby_column_list=groupby_column_list, include=include,
                                                                is_time_series_aggregate=True, verbose=verbose,
@@ -2695,7 +2906,7 @@ class DataFrame():
                                                                fill=self._fill)
             else:
                 # Construct the aggregate query.
-                agg_query = df_utils._construct_describe_query(df=self, metaexpr=self._metaexpr,
+                agg_query = df_utils._construct_describe_query(df=self, columns=columns, metaexpr=self._metaexpr,
                                                                percentiles=percentiles, function_label=function_label,
                                                                groupby_column_list=groupby_column_list, include=include,
                                                                is_time_series_aggregate=False, verbose=verbose,
@@ -2710,7 +2921,7 @@ class DataFrame():
                 describe_df = df2
             else:
                 describe_df = DataFrame.from_query(agg_query, index_label=function_label)
-            
+
             # Check if numeric overflow can occur for result DataFrame.
             if self._check_numeric_overflow(describe_df):
                 result_df = self._promote_dataframe_types()
@@ -2719,8 +2930,10 @@ class DataFrame():
         except TeradataMlException:
             raise
         except Exception as err:
-            raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INFO_ERROR), MessageCodes.TDMLDF_INFO_ERROR) from err
+            raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INFO_ERROR),
+                                      MessageCodes.TDMLDF_INFO_ERROR) from err
 
+    @collect_queryband(queryband="DF_kurtosis")
     def kurtosis(self, distinct=False):
         """
         DESCRIPTION:
@@ -2863,6 +3076,7 @@ class DataFrame():
 
         return self._get_dataframe_aggregate(operation='kurtosis', distinct=distinct)
 
+    @collect_queryband(queryband="DF_min")
     def min(self, distinct=False):
         """
         DESCRIPTION:
@@ -2993,6 +3207,7 @@ class DataFrame():
 
         return self._get_dataframe_aggregate(operation='min', distinct=distinct)
 
+    @collect_queryband(queryband="DF_max")
     def max(self, distinct=False):
         """
         DESCRIPTION:
@@ -3124,6 +3339,7 @@ class DataFrame():
 
         return self._get_dataframe_aggregate(operation='max', distinct=distinct)
 
+    @collect_queryband(queryband="DF_mean")
     def mean(self, distinct=False):
         """
         DESCRIPTION:
@@ -3247,8 +3463,9 @@ class DataFrame():
         # Validate argument types
         _Validators._validate_function_arguments(awu_matrix)
 
-        return self._get_dataframe_aggregate(operation='mean', distinct = distinct)
+        return self._get_dataframe_aggregate(operation='mean', distinct=distinct)
 
+    @collect_queryband(queryband="DF_skew")
     def skew(self, distinct=False):
         """
         DESCRIPTION:
@@ -3388,6 +3605,7 @@ class DataFrame():
 
         return self._get_dataframe_aggregate(operation='skew', distinct=distinct)
 
+    @collect_queryband(queryband="DF_sum")
     def sum(self, distinct=False):
         """
         DESCRIPTION:
@@ -3513,6 +3731,7 @@ class DataFrame():
 
         return self._get_dataframe_aggregate(operation='sum', distinct=distinct)
 
+    @collect_queryband(queryband="DF_count")
     def count(self, distinct=False):
         """
         DESCRIPTION:
@@ -3635,6 +3854,7 @@ class DataFrame():
         _Validators._validate_function_arguments(awu_matrix)
         return self._get_dataframe_aggregate(operation='count', distinct=distinct)
 
+    @collect_queryband(queryband="DF_csum")
     def csum(self, sort_columns, drop_columns=False):
         """
         DESCRIPTION:
@@ -3738,6 +3958,7 @@ class DataFrame():
         self._validate_window_aggregates_arguments(sort_columns)
         return self._get_dataframe_aggregate(operation='csum', sort_columns=sort_columns, drop_columns=drop_columns)
 
+    @collect_queryband(queryband="DF_msum")
     def msum(self, width, sort_columns, drop_columns=False):
         """
         DESCRIPTION:
@@ -3850,6 +4071,7 @@ class DataFrame():
         return self._get_dataframe_aggregate(
             operation='msum', width=width, sort_columns=sort_columns, drop_columns=drop_columns)
 
+    @collect_queryband(queryband="DF_mavg")
     def mavg(self, width, sort_columns, drop_columns=False):
         """
         DESCRIPTION:
@@ -3963,6 +4185,7 @@ class DataFrame():
         return self._get_dataframe_aggregate(
             operation='mavg', width=width, sort_columns=sort_columns, drop_columns=drop_columns)
 
+    @collect_queryband(queryband="DF_mdiff")
     def mdiff(self, width, sort_columns, drop_columns=False):
         """
         DESCRIPTION:
@@ -4076,6 +4299,7 @@ class DataFrame():
         return self._get_dataframe_aggregate(
             operation='mdiff', width=width, sort_columns=sort_columns, drop_columns=drop_columns)
 
+    @collect_queryband(queryband="DF_mlinreg")
     def mlinreg(self, width, sort_column, drop_columns=False):
         """
         DESCRIPTION:
@@ -4266,6 +4490,7 @@ class DataFrame():
         _Validators._validate_unexpected_column_type(
             self, sort_columns, sort_columns_arg_name, _Dtypes._get_sort_unsupported_data_types())
 
+    @collect_queryband(queryband="DF_std")
     def std(self, distinct=False, population=False):
         """
         DESCRIPTION:
@@ -4441,6 +4666,7 @@ class DataFrame():
         _Validators._validate_function_arguments(awu_matrix)
         return self._get_dataframe_aggregate(operation='std', distinct=distinct, population=population)
 
+    @collect_queryband(queryband="DF_median")
     def median(self, distinct=False):
         """
         DESCRIPTION:
@@ -4566,12 +4792,14 @@ class DataFrame():
         _Validators._validate_function_arguments(awu_matrix)
 
         if distinct and not isinstance(self, DataFrameGroupByTime):
-            raise ValueError(Messages.get_message(MessageCodes.ARG_VALUE_CLASS_DEPENDENCY).format('distinct', 'Aggregation',
-                                                                                         'True', 'median()',
-                                                                                         'DataFrameGroupByTime'))
+            raise ValueError(
+                Messages.get_message(MessageCodes.ARG_VALUE_CLASS_DEPENDENCY).format('distinct', 'Aggregation',
+                                                                                     'True', 'median()',
+                                                                                     'DataFrameGroupByTime'))
 
-        return self._get_dataframe_aggregate(operation = 'median', distinct = distinct)
+        return self._get_dataframe_aggregate(operation='median', distinct=distinct)
 
+    @collect_queryband(queryband="DF_var")
     def var(self, distinct=False, population=False):
         """
         DESCRIPTION:
@@ -4773,7 +5001,8 @@ class DataFrame():
 
         return self._get_dataframe_aggregate(operation='var', distinct=distinct, population=population)
 
-    def agg(self, func = None):
+    @collect_queryband(queryband="DF_agg")
+    def agg(self, func=None):
         """
         DESCRIPTION:
             Perform aggregates using one or more operations.
@@ -4918,10 +5147,12 @@ class DataFrame():
 
         if not isinstance(func, str) and not isinstance(func, list) and not isinstance(func, dict):
             raise TeradataMlException(Messages.get_message(MessageCodes.UNSUPPORTED_DATATYPE,
-                                'func', ['str', 'list', 'dict']), MessageCodes.UNSUPPORTED_DATATYPE)
+                                                           'func', ['str', 'list', 'dict']),
+                                      MessageCodes.UNSUPPORTED_DATATYPE)
 
         return self._get_dataframe_aggregate(func)
 
+    @collect_queryband(arg_name="operation", prefix="DF")
     def _get_dataframe_aggregate(self, operation, **kwargs):
         """
         Returns the DataFrame given the aggregate operation or list of
@@ -5048,15 +5279,17 @@ class DataFrame():
             # Return Empty DataFrame if all the columns are selected in groupby as parent has
             if len(col_names) == 0:
                 aggregate_expression, new_column_names, new_column_types = \
-                        df_utils._construct_sql_expression_for_aggregations(self,
-                            groupby_col_names, groupby_col_types, operation,
-                            as_time_series_aggregate = is_time_series_aggregate, **kwargs)
+                    df_utils._construct_sql_expression_for_aggregations(self,
+                                                                        groupby_col_names, groupby_col_types, operation,
+                                                                        as_time_series_aggregate=is_time_series_aggregate,
+                                                                        **kwargs)
                 self._index_label = new_column_names
             else:
                 aggregate_expression, new_column_names, new_column_types = \
-                        df_utils._construct_sql_expression_for_aggregations(self,
-                            col_names, col_types, operation, as_time_series_aggregate = is_time_series_aggregate,
-                            **kwargs)
+                    df_utils._construct_sql_expression_for_aggregations(self,
+                                                                        col_names, col_types, operation,
+                                                                        as_time_series_aggregate=is_time_series_aggregate,
+                                                                        **kwargs)
                 new_column_names = pti_default_cols_proj + groupby_col_names + new_column_names
                 new_column_types = pti_default_cols_types + groupby_col_types + new_column_types
 
@@ -5069,7 +5302,7 @@ class DataFrame():
             new_metaexpr = UtilFuncs._get_metaexpr_using_columns(aggregate_node_id,
                                                                  zip(new_column_names,
                                                                      new_column_types))
-            agg_df = self._create_dataframe_from_node\
+            agg_df = self._create_dataframe_from_node \
                 (aggregate_node_id, new_metaexpr, self._index_label)
 
             if (operation in ["sum", "csum", "mean"] and self._check_numeric_overflow(agg_df)):
@@ -5081,7 +5314,7 @@ class DataFrame():
                                               drop_columns=kwargs.get("drop_columns"))
                 else:
                     agg_df = getattr(promoted_df, operation)(distinct=kwargs.get("distinct"))
-            
+
             return agg_df
 
         except TeradataMlException:
@@ -5089,7 +5322,7 @@ class DataFrame():
         except Exception as err:
             raise TeradataMlException(Messages.get_message(
                 MessageCodes.EXECUTION_FAILED, "perform {} on DataFrame".format(operation), str(err)),
-                                      MessageCodes.EXECUTION_FAILED) from err
+                MessageCodes.EXECUTION_FAILED) from err
 
     def _check_numeric_overflow(self, result_df):
         """
@@ -5110,7 +5343,7 @@ class DataFrame():
             
         EXAMPLES :
             result = self._check_numeric_overflow(agg_df)
-        """       
+        """
         try:
             repr(result_df)
             return False
@@ -5119,7 +5352,7 @@ class DataFrame():
                 return True
             else:
                 raise tme
-    
+
     def _promote_dataframe_types(self):
         """
         Function promotes numeric column type to higher type to avoid numeric overflow
@@ -5152,9 +5385,8 @@ class DataFrame():
                 new_cols[col] = self[col].cast(type_=next_type[self[col].type.__class__])
             else:
                 new_cols[col] = self[col]
-        
+
         return self.assign(True, **new_cols)
-             
 
     def __repr__(self):
         """
@@ -5179,16 +5411,7 @@ class DataFrame():
         """
         try:
 
-            # Generate/Execute AED nodes
-            self.__execute_node_and_set_table_name(self._nodeid, self._metaexpr)
-
-            query = repr(self._metaexpr) + ' FROM ' + self._table_name
-
-            if self._orderby is not None:
-                query += ' ORDER BY ' + self._orderby
-
-            # Execute the query and get the results in a list and create a Pandas DataFrame from the same.
-            data, columns = UtilFuncs._execute_query(query=query, fetchWarnings=True)
+            data, columns = self.__get_data_columns()
             pandas_df = pd.DataFrame.from_records(data, columns=columns, coerce_float=True)
 
             if self._index_label:
@@ -5196,7 +5419,7 @@ class DataFrame():
 
             if self._undropped_index is not None:
                 for col in self._undropped_index:
-                    pandas_df.insert(0, col, pandas_df.index.get_level_values(col).tolist(), allow_duplicates = True)
+                    pandas_df.insert(0, col, pandas_df.index.get_level_values(col).tolist(), allow_duplicates=True)
 
             return pandas_df.to_string()
 
@@ -5209,18 +5432,15 @@ class DataFrame():
 
     def _repr_html_(self):
         """ Print method for teradataml for iPython rich display. """
-        # Generate/Execute AED nodes
-        self.__execute_node_and_set_table_name(self._nodeid, self._metaexpr)
-
-        query = repr(self._metaexpr) + ' FROM ' + self._table_name
 
-        if self._orderby is not None:
-            query += ' ORDER BY ' + self._orderby
-
-        # Execute the query and get the results in a list.
-        data, columns = UtilFuncs._execute_query(query=query, fetchWarnings=True)
+        # Check if class attributes __data and __data_columns are not None.
+        # If not None, reuse the data and columns.
+        # If None, generate latest results.
+        if self.__data is None and self.__data_columns is None:
+            self.__get_data_columns()
 
-        # Generate the HTML content from data and columns.
+        # Generate the HTML content from the class attributes __data and __data_columns
+        # which are updated by _repr_() function call which always executes before _repr_html_().
         indent = "\t"
         dindent = indent + indent
 
@@ -5233,11 +5453,11 @@ class DataFrame():
         html = "\n{0}".format(indent).join(header_html)
         html += '<html><table>\n{0}<tr id="HeaderRow">\n'.format(indent)
 
-        columns_html = "</th>\n{0}<th>".format(dindent).join(columns)
+        columns_html = "</th>\n{0}<th>".format(dindent).join(self.__data_columns)
         html += "{0}<th>{1}</th>\n".format(dindent, columns_html)
         html += "{0}</tr>\n".format(indent)
 
-        for row in data:
+        for row in self.__data:
             row_html = ["{0}<td>{1}</td>\n".format(dindent,
                                                    cell) for cell in row]
             html += "{1}<tr>\n{0}{1}</tr>\n".format("".join(row_html), indent)
@@ -5246,6 +5466,34 @@ class DataFrame():
 
         return html
 
+    def __get_data_columns(self):
+        """
+        DESCRIPTION:
+            Internal function to execute the node and get the result.
+
+        RETURNS:
+            tuple, first element represents data for the underlying query
+                   and second element represents the column names.
+
+        RAISES:
+            None.
+
+        EXAMPLES:
+            self.__get_data_columns()
+        """
+        self.__execute_node_and_set_table_name(self._nodeid, self._metaexpr)
+
+        query = repr(self._metaexpr) + ' FROM ' + self._table_name
+
+        if self._orderby is not None:
+            query += ' ORDER BY ' + self._orderby
+
+        # Execute the query and get the results in a list.
+        self.__data, self.__data_columns = UtilFuncs._execute_query(query=query, fetchWarnings=True)
+
+        return self.__data, self.__data_columns
+
+    @collect_queryband(queryband="DF_select")
     def select(self, select_expression):
         """
         DESCRIPTION:
@@ -5340,7 +5588,8 @@ class DataFrame():
         """
         try:
             if self._metaexpr is None:
-                raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INFO_ERROR), MessageCodes.TDMLDF_INFO_ERROR)
+                raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INFO_ERROR),
+                                          MessageCodes.TDMLDF_INFO_ERROR)
 
             # If invalid, appropriate exception raised; Processing ahead only for valid expressions
             select_exp_col_list = self.__validate_select_expression(select_expression)
@@ -5398,17 +5647,20 @@ class DataFrame():
 
             # TODO: Remove this check when same column multiple selection enabled
             if len(select_exp_col_list) > len(df_column_list):
-                raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_SELECT_INVALID_COLUMN, ', '.join(df_column_list)),
-                                          MessageCodes.TDMLDF_SELECT_INVALID_COLUMN)
+                raise TeradataMlException(
+                    Messages.get_message(MessageCodes.TDMLDF_SELECT_INVALID_COLUMN, ', '.join(df_column_list)),
+                    MessageCodes.TDMLDF_SELECT_INVALID_COLUMN)
 
-            all_cols_exist =  all(col in df_column_list for col in select_exp_col_list)
+            all_cols_exist = all(col in df_column_list for col in select_exp_col_list)
 
             if not all_cols_exist:
-                raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_SELECT_INVALID_COLUMN, ', '.join(df_column_list)),
-                                          MessageCodes.TDMLDF_SELECT_INVALID_COLUMN)
+                raise TeradataMlException(
+                    Messages.get_message(MessageCodes.TDMLDF_SELECT_INVALID_COLUMN, ', '.join(df_column_list)),
+                    MessageCodes.TDMLDF_SELECT_INVALID_COLUMN)
 
             return select_exp_col_list
 
+    @collect_queryband(queryband="DF_toPandas")
     def to_pandas(self, index_column=None, num_rows=99999, all_rows=False,
                   fastexport=False, catch_errors_warnings=False, **kwargs):
         """
@@ -5798,7 +6050,7 @@ class DataFrame():
                                      "Pandas DataFrame", str(err)),
                 MessageCodes.DATA_EXPORT_FAILED)
 
-    @argument_deprecation("future", ["lsuffix", "rsuffix"], True, ["lprefix", "rprefix"])
+    @collect_queryband(queryband="DF_join")
     def join(self, other, on=None, how="left", lsuffix=None, rsuffix=None,
              lprefix=None, rprefix=None):
         """
@@ -5875,18 +6127,12 @@ class DataFrame():
             lsuffix:
                 Optional Argument.
                 Specifies the suffix to be added to the left table columns.
-                Note:
-                    Behavior of the argument will change in future. 
-                    Use "lprefix" instead.
                 Default Value: None.
                 Types: str
 
             rsuffix:
                 Optional Argument.
                 Specifies the suffix to be added to the right table columns.
-                Note:
-                    Behavior of the argument will change in future. 
-                    Use "rprefix" instead.
                 Default Value: None.
                 Types: str
             
@@ -6045,15 +6291,13 @@ class DataFrame():
         # Validate argument types
         _Validators._validate_function_arguments(awu_matrix)
 
-
-        
         # If user has not provided suffix argument(s), then prefix argument(s) value(s) are passed by
         # user hence we will set the affix variables (laffix and raffix) with provided value(s).
         # affix_type is also set appropriately.
         if lsuffix is not None or rsuffix is not None:
             laffix = lsuffix
             raffix = rsuffix
-            affix_type = "suffix"  
+            affix_type = "suffix"
         else:
             laffix = lprefix
             raffix = rprefix
@@ -6079,12 +6323,13 @@ class DataFrame():
             if column in other_columns_lower_actual_map.keys():
                 if laffix is None and raffix is None:
                     raise TeradataMlException(
-                        Messages.get_message(MessageCodes.TDMLDF_REQUIRED_TABLE_ALIAS),MessageCodes.TDMLDF_REQUIRED_TABLE_ALIAS)
-        
+                        Messages.get_message(MessageCodes.TDMLDF_REQUIRED_TABLE_ALIAS),
+                        MessageCodes.TDMLDF_REQUIRED_TABLE_ALIAS)
+
         # Both affixes should not be equal to perform join.
         if laffix == raffix and laffix is not None:
             raise TeradataMlException(
-                Messages.get_message(MessageCodes.TDMLDF_INVALID_TABLE_ALIAS, 
+                Messages.get_message(MessageCodes.TDMLDF_INVALID_TABLE_ALIAS,
                                      "'l{affix_type}' and 'r{affix_type}'".format(affix_type=affix_type)),
                 MessageCodes.TDMLDF_INVALID_TABLE_ALIAS)
 
@@ -6120,7 +6365,7 @@ class DataFrame():
 
                 if isinstance(ori_condition, str):
                     columns = [column.strip() for column in condition.split(sep=conditional_separator)
-                            if len(column) > 0]
+                               if len(column) > 0]
 
                 if len(columns) != 2:
                     invalid_join_conditions.append(condition)
@@ -6135,7 +6380,8 @@ class DataFrame():
 
             if len(invalid_join_conditions) > 0:
                 raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_INVALID_JOIN_CONDITION,
-                            ", ".join(invalid_join_conditions)), MessageCodes.TDMLDF_INVALID_JOIN_CONDITION)
+                                                               ", ".join(invalid_join_conditions)),
+                                          MessageCodes.TDMLDF_INVALID_JOIN_CONDITION)
 
             join_condition = " and ".join(all_join_conditions)
         else:
@@ -6156,14 +6402,16 @@ class DataFrame():
                 df1_column_with_affix = self.__check_and_return_new_column_name(laffix, other_column,
                                                                                 other_columns_lower_actual_map.keys(),
                                                                                 "right", affix_type)
-                select_columns.append("{0} as {1}".format(self.__get_fully_qualified_col_name(other_column, "df1" if laffix is None else laffix),
-                                                          df1_column_with_affix))
+                select_columns.append("{0} as {1}".format(
+                    self.__get_fully_qualified_col_name(other_column, "df1" if laffix is None else laffix),
+                    df1_column_with_affix))
 
                 df2_column_with_affix = self.__check_and_return_new_column_name(raffix, column,
                                                                                 self_columns_lower_actual_map.keys(),
                                                                                 "left", affix_type)
-                select_columns.append("{0} as {1}".format(self.__get_fully_qualified_col_name(column, "df2" if raffix is None else raffix),
-                                                          df2_column_with_affix))
+                select_columns.append("{0} as {1}".format(
+                    self.__get_fully_qualified_col_name(column, "df2" if raffix is None else raffix),
+                    df2_column_with_affix))
 
                 # As we are creating new column name, adding it to new metadata dict for new dataframe from join.
                 self.__add_column_type_item_to_dict(new_metaexpr_columns_types,
@@ -6173,7 +6421,7 @@ class DataFrame():
                 self.__add_column_type_item_to_dict(new_metaexpr_columns_types,
                                                     UtilFuncs._teradata_unquote_arg(df2_column_with_affix, "\""),
                                                     other_column, df2_columns_types)
-                
+
             else:
                 # As column not present in right DataFrame, directly adding column to new metadata dict.
                 self.__add_column_type_item_to_dict(new_metaexpr_columns_types, column, column, df1_columns_types)
@@ -6187,7 +6435,7 @@ class DataFrame():
 
         # Create a node in AED using _aed_join
         join_node_id = self._aed_utils._aed_join(self._nodeid, other._nodeid, ", ".join(select_columns), how_lc,
-                                                 join_condition, "df1" if laffix is None else laffix, 
+                                                 join_condition, "df1" if laffix is None else laffix,
                                                  "df2" if raffix is None else raffix)
 
         # Constructing new Metadata (_metaexpr) without DB; using dummy select_nodeid and underlying table name.
@@ -6274,9 +6522,7 @@ class DataFrame():
         """
         if affix is None:
             return UtilFuncs._teradata_quote_arg(column, "\"", False)
-        
-        affix_type = "prefix" # TODO: [ELE-5480] Remove this line to enable suffix addition.
-        
+
         # If Prefix, affix is added before column name else it is appended.
         df1_column_with_affix = "{0}_{1}" if affix_type == "prefix" else "{1}_{0}"
         df1_column_with_affix = df1_column_with_affix.format(affix,
@@ -6292,7 +6538,7 @@ class DataFrame():
                 MessageCodes.TDMLDF_COLUMN_ALREADY_EXISTS)
         return UtilFuncs._teradata_quote_arg(df1_column_with_affix, "\"", False)
 
-    def __add_column_type_item_to_dict(self, new_metadata_dict, new_column,column, column_types):
+    def __add_column_type_item_to_dict(self, new_metadata_dict, new_column, column, column_types):
         """
         Add a column as key and datatype as a value to dictionary
 
@@ -6355,20 +6601,20 @@ class DataFrame():
                 return final
             else:
                 return colnames_list
-            
+
         elif kind == 'mergesort':
             if ascending == True:
                 return sorted(colnames_list)
             else:
-                return sorted(colnames_list, reverse=True)     
-            
+                return sorted(colnames_list, reverse=True)
+
         elif kind == 'heapsort':
-            end = len(colnames_list)  
+            end = len(colnames_list)
             start = end // 2 - 1
-            for i in range(start, -1, -1):   
-                self.__get_heap(colnames_list, end, i)   
-            for i in range(end-1, 0, -1):  
-                #swap(i, 0)  
+            for i in range(start, -1, -1):
+                self.__get_heap(colnames_list, end, i)
+            for i in range(end - 1, 0, -1):
+                # swap(i, 0)
                 colnames_list[i], colnames_list[0] = colnames_list[0], colnames_list[i]
                 colnames_list = self.__get_heap(colnames_list, i, 0)
             if ascending == True:
@@ -6394,9 +6640,9 @@ class DataFrame():
         RETURNS:
             Sorted list of column names indexed at i
         """
-        l=2 * i + 1
-        r=2 * (i + 1) 
-        max=i
+        l = 2 * i + 1
+        r = 2 * (i + 1)
+        max = i
         if l < n and colnames_list[i] < colnames_list[l]:
             max = l
         if r < n and colnames_list[max] < colnames_list[r]:
@@ -6406,7 +6652,8 @@ class DataFrame():
             self.__get_heap(colnames_list, n, max)
         return colnames_list
 
-    def to_sql(self, table_name, if_exists='fail', primary_index=None, temporary=False, schema_name=None, types = None,
+    @collect_queryband(queryband="DF_toSql")
+    def to_sql(self, table_name, if_exists='fail', primary_index=None, temporary=False, schema_name=None, types=None,
                primary_time_index_name=None, timecode_column=None, timebucket_duration=None,
                timezero_date=None, columns_list=None, sequence_column=None, seq_max=None, set_table=False):
         """
@@ -6619,13 +6866,13 @@ class DataFrame():
 
         """
 
-        return copy_to_sql(df = self, table_name = table_name, schema_name = schema_name,
-                    index = False, index_label = None, temporary = temporary,
-                    primary_index = primary_index, if_exists = if_exists, types = types,
-                    primary_time_index_name = primary_time_index_name, timecode_column = timecode_column,
-                    timebucket_duration = timebucket_duration, timezero_date = timezero_date, columns_list = columns_list,
-                    sequence_column = sequence_column, seq_max = seq_max, set_table = set_table)
-
+        return copy_to_sql(df=self, table_name=table_name, schema_name=schema_name,
+                           index=False, index_label=None, temporary=temporary,
+                           primary_index=primary_index, if_exists=if_exists, types=types,
+                           primary_time_index_name=primary_time_index_name, timecode_column=timecode_column,
+                           timebucket_duration=timebucket_duration, timezero_date=timezero_date,
+                           columns_list=columns_list,
+                           sequence_column=sequence_column, seq_max=seq_max, set_table=set_table)
 
     def _get_assign_allowed_types(self):
         """
@@ -6694,7 +6941,7 @@ class DataFrame():
         new_meta = UtilFuncs._get_metaexpr_using_parent_metaexpr(new_nodeid, new_meta)
         return (new_meta, new_nodeid)
 
-    def _create_dataframe_from_node(self, nodeid, metaexpr, index_label, undropped_columns = None):
+    def _create_dataframe_from_node(self, nodeid, metaexpr, index_label, undropped_columns=None):
         """
         DESCRIPTION:
             Function to create a teradataml DataFrame from node.
@@ -6702,7 +6949,7 @@ class DataFrame():
             be overridden by the child classes if required.
 
             For example,
-                This will always returns a teradataml DataFrame, but for
+                This will always return a teradataml DataFrame, but for
                 GeoDataFrame, we will return teradataml DataFrame or teradataml
                 GeoDataFrame, based on whether the resultant DataFrame contains
                 geometry column or not.
@@ -6786,7 +7033,8 @@ class DataFrame():
                 self.__execute_node_and_set_table_name(self._nodeid)
                 return True
 
-    def assign(self, drop_columns = False, **kwargs):
+    @collect_queryband(queryband="DF_assign")
+    def assign(self, drop_columns=False, **kwargs):
         """
         DESCRIPTION:
             Assign new columns to a teradataml DataFrame.
@@ -7127,12 +7375,12 @@ class DataFrame():
             is_allowed = lambda x: isinstance(*x) and type(x[0]) != bool
             value_type_allowed = map(is_allowed, ((val, t) for t in allowed_types))
 
-            #if callable(val):
+            # if callable(val):
             #    err = 'Unsupported callable value for key: {}'.format(key)
             #    raise ValueError(err)
 
             if not any(list(value_type_allowed)):
-                err = 'Unsupported values of type {t} for key {k}'.format(k = key, t = type(val))
+                err = 'Unsupported values of type {t} for key {k}'.format(k=key, t=type(val))
                 raise ValueError(err)
 
             if isinstance(val, ClauseElement) and not node_executed:
@@ -7153,6 +7401,7 @@ class DataFrame():
             msg = Messages.get_message(MessageCodes.TDMLDF_INFO_ERROR)
             raise TeradataMlException(msg, errcode) from err
 
+    @collect_queryband(queryband="DF_get")
     def get(self, key):
         """
         DESCRIPTION:
@@ -7232,7 +7481,8 @@ class DataFrame():
         """
         return self.select(key)
 
-    def set_index(self, keys, drop = True, append = False):
+    @collect_queryband(queryband="DF_setIndex")
+    def set_index(self, keys, drop=True, append=False):
         """
         DESCRIPTION:
             Assigns one or more existing columns as the new index to a teradataml DataFrame.
@@ -7447,7 +7697,8 @@ class DataFrame():
         """
         return self._index_label
 
-    def groupby(self, columns_expr):
+    @collect_queryband(queryband="DF_groupby")
+    def groupby(self, columns_expr, **kwargs):
         """
         DESCRIPTION:
             Applies GroupBy to one or more columns of a teradataml Dataframe.
@@ -7460,6 +7711,16 @@ class DataFrame():
                 Specifies the column name(s) to group by.
                 Types: str OR list of Strings (str)
 
+            kwargs:
+                Optional Argument.
+                Specifies keyword arguments.
+
+                option:
+                    Optional Argument.
+                    Specifies the groupby option.
+                    Permitted Values: "CUBE", "ROLLUP", None
+                    Types: str or NoneType
+
         NOTES:
             1. Users can still apply teradataml DataFrame methods (filters/sort/etc) on top of the result.
             2. Consecutive operations of grouping, i.e., groupby_time(), resample() and groupby() are not permitted.
@@ -7486,26 +7747,31 @@ class DataFrame():
 
         """
         # Argument validations
-        awu_matrix = []
-        awu_matrix.append(["columns_expr", columns_expr, False, (str, list), True])
+        arg_info_matrix = []
+        arg_info_matrix.append(["columns_expr", columns_expr, False, (str, list), True])
+        option = kwargs.get("option", None)
+        arg_info_matrix.append(["option", option, True, (str, type(None)), True,
+                                ["CUBE", "ROLLUP", None]])
 
         # Validate argument types
-        _Validators._validate_function_arguments(awu_matrix)
+        _Validators._validate_function_arguments(arg_info_matrix)
 
         # Checking each element in passed columns to be valid column in dataframe
         _Validators._validate_column_exists_in_dataframe(columns_expr, self._metaexpr)
 
         try:
-            column_list=[]
-            unsupported_types = ['BLOB', 'CLOB', 'PERIOD_DATE', 'PERIOD_TIME', 'PERIOD_TIMESTAMP', 'ARRAY', 'VARRAY', 'XML', 'JSON']
-            type_expr=[]
+            column_list = []
+            unsupported_types = ['BLOB', 'CLOB', 'PERIOD_DATE', 'PERIOD_TIME', 'PERIOD_TIMESTAMP', 'ARRAY', 'VARRAY',
+                                 'XML', 'JSON']
+            type_expr = []
             invalid_types = []
             # check for consecutive groupby operations
-            if isinstance(self, DataFrameGroupBy) or isinstance(self, DataFrameGroupByTime) :
-                raise TeradataMlException(Messages.get_message(MessageCodes.UNSUPPORTED_OPERATION), MessageCodes.UNSUPPORTED_OPERATION)
+            if isinstance(self, DataFrameGroupBy) or isinstance(self, DataFrameGroupByTime):
+                raise TeradataMlException(Messages.get_message(MessageCodes.UNSUPPORTED_OPERATION),
+                                          MessageCodes.UNSUPPORTED_OPERATION)
 
             if (isinstance(columns_expr, list)):
-                column_list=columns_expr
+                column_list = columns_expr
 
             elif (isinstance(columns_expr, str)):
                 column_list.append(columns_expr)
@@ -7530,15 +7796,15 @@ class DataFrame():
 
             groupbyexpr = ', '.join(UtilFuncs._teradata_quote_arg(col, "\"", False) for col in column_list)
             groupbyObj = DataFrameGroupBy(self._nodeid, self._metaexpr, self._column_names_and_types, self.columns,
-                                          groupbyexpr, column_list)
+                                          groupbyexpr, column_list, option)
             return groupbyObj
         except TeradataMlException:
             raise
 
-    def __group_time_series_data(self, timebucket_duration, timebucket_duration_arg_name = "timebucket_duration",
-                                 value_expression = None, timecode_column = None,
-                                 timecode_column_arg_name = "timecode_column", sequence_column = None,
-                                 fill = None, fill_arg_name = "fill"):
+    def __group_time_series_data(self, timebucket_duration, timebucket_duration_arg_name="timebucket_duration",
+                                 value_expression=None, timecode_column=None,
+                                 timecode_column_arg_name="timecode_column", sequence_column=None,
+                                 fill=None, fill_arg_name="fill"):
         """
         DESCRIPTION:
             Internal function to resample/group time series data using Group By Time and a column.
@@ -7782,7 +8048,8 @@ class DataFrame():
 
                 if len(invalid_types) > 0:
                     raise TeradataMlException(Messages.get_message(MessageCodes.UNSUPPORTED_DATATYPE, invalid_types,
-                                                                   "ANY, except following {}".format(unsupported_types)),
+                                                                   "ANY, except following {}".format(
+                                                                       unsupported_types)),
                                               MessageCodes.UNSUPPORTED_DATATYPE)
 
                 groupby_column_expr = ', '.join(UtilFuncs._teradata_quote_arg(col, "\"", False)
@@ -7792,7 +8059,7 @@ class DataFrame():
 
             groupbyObj = DataFrameGroupByTime(nodeid=self._nodeid, metaexpr=self._metaexpr,
                                               column_names_and_types=self._column_names_and_types, columns=self.columns,
-                                              groupby_value_expr = groupby_column_expr,
+                                              groupby_value_expr=groupby_column_expr,
                                               column_list=group_by_column_list, timebucket_duration=timebucket_duration,
                                               value_expression=value_expression, timecode_column=timecode_column,
                                               sequence_column=sequence_column, fill=fill)
@@ -7800,8 +8067,9 @@ class DataFrame():
         except TeradataMlException:
             raise
 
-    def groupby_time(self, timebucket_duration, value_expression = None, timecode_column = None, sequence_column = None,
-                     fill = None):
+    @collect_queryband(queryband="DF_groupbyTime")
+    def groupby_time(self, timebucket_duration, value_expression=None, timecode_column=None, sequence_column=None,
+                     fill=None):
         """
         DESCRIPTION:
             Apply Group By Time to one or more columns of a teradataml DataFrame.
@@ -8079,11 +8347,12 @@ class DataFrame():
 
         """
         return self.__group_time_series_data(timebucket_duration=timebucket_duration, value_expression=value_expression,
-                                             timecode_column = timecode_column, sequence_column = sequence_column,
-                                             fill = fill)
+                                             timecode_column=timecode_column, sequence_column=sequence_column,
+                                             fill=fill)
 
-    def resample(self, rule, value_expression = None, on = None, sequence_column = None,
-                     fill_method = None):
+    @collect_queryband(queryband="DF_resample")
+    def resample(self, rule, value_expression=None, on=None, sequence_column=None,
+                 fill_method=None):
         """
         DESCRIPTION:
             Resample time series data. This function allows grouping done by time on
@@ -8360,10 +8629,11 @@ class DataFrame():
         """
         return self.__group_time_series_data(timebucket_duration=rule, timebucket_duration_arg_name="rule",
                                              value_expression=value_expression, timecode_column_arg_name="on",
-                                             timecode_column = on, sequence_column = sequence_column,
-                                             fill = fill_method, fill_arg_name="fill_method")
+                                             timecode_column=on, sequence_column=sequence_column,
+                                             fill=fill_method, fill_arg_name="fill_method")
 
-    def get_values(self, num_rows = 99999):
+    @collect_queryband(queryband="DF_getValues")
+    def get_values(self, num_rows=99999):
         """
         DESCRIPTION:
             Retrieves all values (only) present in a teradataml DataFrame.
@@ -8548,6 +8818,7 @@ class DataFrame():
         dimension = self.shape
         return dimension[0] * dimension[1]
 
+    @collect_queryband(queryband="DF_merge")
     def merge(self, right, on=None, how="inner", left_on=None, right_on=None, use_index=False,
               lsuffix=None, rsuffix=None):
         """
@@ -8555,6 +8826,7 @@ class DataFrame():
             Merges two teradataml DataFrames together.
          
             Supported merge operations are:
+                - cross: Returns cartesian product between the two dataframes.
                 - inner: Returns only matching rows, non-matching rows are eliminated.
                 - left: Returns all matching rows plus non-matching rows from the left teradataml DataFrame.
                 - right: Returns all matching rows plus non-matching rows from the right teradataml DataFrame.
@@ -8767,27 +9039,26 @@ class DataFrame():
                 Messages.get_message(MessageCodes.MUST_PASS_ARGUMENT, "left_on", "right_on"),
                 MessageCodes.MUST_PASS_ARGUMENT)
 
-        if isinstance(on,list):
+        if isinstance(on, list):
             join_conditions = on
         elif isinstance(on, (str, ColumnExpression)):
             join_conditions = [on]
         else:
             join_conditions = []
 
-
         if isinstance(left_on, list) and isinstance(right_on, list) and len(left_on) != len(right_on):
             raise TeradataMlException(
-                  Messages.get_message(MessageCodes.TDMLDF_UNEQUAL_NUMBER_OF_COLUMNS, "left_on", "right_on"),
-                  MessageCodes.TDMLDF_UNEQUAL_NUMBER_OF_COLUMNS)
+                Messages.get_message(MessageCodes.TDMLDF_UNEQUAL_NUMBER_OF_COLUMNS, "left_on", "right_on"),
+                MessageCodes.TDMLDF_UNEQUAL_NUMBER_OF_COLUMNS)
 
         elif isinstance(left_on, list) and isinstance(right_on, (str, ColumnExpression)) and len(left_on) != 1:
             raise TeradataMlException(
-                  Messages.get_message(MessageCodes.TDMLDF_UNEQUAL_NUMBER_OF_COLUMNS, "left_on", "right_on"),
-                  MessageCodes.TDMLDF_UNEQUAL_NUMBER_OF_COLUMNS)
+                Messages.get_message(MessageCodes.TDMLDF_UNEQUAL_NUMBER_OF_COLUMNS, "left_on", "right_on"),
+                MessageCodes.TDMLDF_UNEQUAL_NUMBER_OF_COLUMNS)
 
         elif isinstance(right_on, list) and isinstance(left_on, (str, ColumnExpression)) and len(right_on) != 1:
             raise TeradataMlException(
-                  Messages.get_message(MessageCodes.TDMLDF_UNEQUAL_NUMBER_OF_COLUMNS, "left_on", "right_on"),
+                Messages.get_message(MessageCodes.TDMLDF_UNEQUAL_NUMBER_OF_COLUMNS, "left_on", "right_on"),
                 MessageCodes.TDMLDF_UNEQUAL_NUMBER_OF_COLUMNS)
 
         if left_on is not None and not isinstance(left_on, list):
@@ -8812,7 +9083,6 @@ class DataFrame():
                 if isinstance(right_on[index], ColumnExpression):
                     right_on[index] = right_on[index].compile()
 
-
         if left_on is not None and right_on is not None:
             for left_column, right_column in zip(left_on, right_on):
                 join_conditions.append("{} = {}".format(tdp.quote(left_column), tdp.quote(right_column)))
@@ -8828,7 +9098,7 @@ class DataFrame():
 
         if use_index:
             if self._index_label is None or right._index_label is None:
-                    raise TeradataMlException(
+                raise TeradataMlException(
                     Messages.get_message(MessageCodes.TDMLDF_INDEXES_ARE_NONE), MessageCodes.TDMLDF_INDEXES_ARE_NONE)
 
             left_index_labels = self._index_label
@@ -8841,9 +9111,9 @@ class DataFrame():
             for left_index_label, right_index_label in zip(left_index_labels, right_index_labels):
                 join_conditions.append("{} = {}".format(tdp.quote(left_index_label), tdp.quote(right_index_label)))
 
-
         return self.join(other=right, on=join_conditions, how=how, lsuffix=lsuffix, rsuffix=rsuffix)
 
+    @collect_queryband(queryband="DF_squeeze")
     def squeeze(self, axis=None):
         """
         DESCRIPTION:
@@ -8955,7 +9225,7 @@ class DataFrame():
         num_row, num_col = self.shape
 
         # Check if the number of elements in DF = 1
-        if (num_row, num_col) == (1,1) and axis is None:
+        if (num_row, num_col) == (1, 1) and axis is None:
             # To get the single row/column value in the DF, we need to execute the node
             # Generate/Execute AED nodes
             self.__execute_node_and_set_table_name(self._nodeid)
@@ -8981,12 +9251,13 @@ class DataFrame():
                 return self
 
         if axis == 1:
-            return Series._from_dataframe(self, axis = 1)
+            return Series._from_dataframe(self, axis=1)
         else:
             # TODO : Research and add capabilities to handle rowexpression based return objects
             # For now, returning the DataFrame as is
             return self
 
+    @collect_queryband(queryband="DF_sortIndex")
     def sort_index(self, axis=0, ascending=True, kind='quicksort'):
         """
         DESCRIPTION:
@@ -9093,6 +9364,7 @@ class DataFrame():
         except TeradataMlException:
             raise
 
+    @collect_queryband(queryband="DF_concat")
     def concat(self, other, join='OUTER', allow_duplicates=True, sort=False, ignore_index=False):
         """
         DESCRIPTION:
@@ -9278,14 +9550,14 @@ class DataFrame():
         if isinstance(samples, float) and samples > 1:
             raise TeradataMlException(
                 Messages.get_message(MessageCodes.INVALID_ARG_VALUE, str(samples), arg_name,
-                         "greater than 0 and less than or equal to 1"),
-                         MessageCodes.INVALID_ARG_VALUE)
+                                     "greater than 0 and less than or equal to 1"),
+                MessageCodes.INVALID_ARG_VALUE)
         if isinstance(samples, list) and all(isinstance(item, float) for item in samples) \
-           and sum(samples) > 1:
+                and sum(samples) > 1:
             raise TeradataMlException(
                 Messages.get_message(MessageCodes.INVALID_ARG_VALUE, str(samples), arg_name,
-                         "a list having sum of all elements greater than 0 and less than or equal to 1" ),
-                         MessageCodes.INVALID_ARG_VALUE)
+                                     "a list having sum of all elements greater than 0 and less than or equal to 1"),
+                MessageCodes.INVALID_ARG_VALUE)
 
         return True
 
@@ -9316,10 +9588,10 @@ class DataFrame():
 
         # Raise exception if the length of list is greater than 16.
         if len(samples) > 16:
-           raise TeradataMlException(
+            raise TeradataMlException(
                 Messages.get_message(MessageCodes.INVALID_ARG_VALUE, str(samples), arg_name,
-                         "a list having less than or equal to 16 samples"),
-                         MessageCodes.INVALID_ARG_VALUE)
+                                     "a list having less than or equal to 16 samples"),
+                MessageCodes.INVALID_ARG_VALUE)
 
         return True
 
@@ -9354,26 +9626,26 @@ class DataFrame():
 
         # Raise exception if number of rows given are negative.
         if isinstance(samples, (int, float)) and samples < 0 or isinstance(samples, list) \
-                     and any(item < 0 for item in samples):
+                and any(item < 0 for item in samples):
             raise TeradataMlException(
                 Messages.get_message(MessageCodes.INVALID_ARG_VALUE, str(samples), arg_name,
-                         "greater than 0" ),
-                         MessageCodes.INVALID_ARG_VALUE)
+                                     "greater than 0"),
+                MessageCodes.INVALID_ARG_VALUE)
 
         # Raise exception if fractions specified as 0.
-        if isinstance(samples,  float) and samples == 0 or (isinstance(samples, list) \
-                     and all(isinstance(item, float) for item in samples) 
-                     and any(item == 0 for item in samples)):
+        if isinstance(samples, float) and samples == 0 or (isinstance(samples, list) \
+                                                           and all(isinstance(item, float) for item in samples)
+                                                           and any(item == 0 for item in samples)):
             raise TeradataMlException(
                 Messages.get_message(MessageCodes.INVALID_ARG_VALUE, str(samples), arg_name,
-                         "greater than 0" ),
-                         MessageCodes.INVALID_ARG_VALUE)
-
+                                     "greater than 0"),
+                MessageCodes.INVALID_ARG_VALUE)
 
         return True
 
-    def sample(self, n = None, frac = None, replace = False, randomize = False, case_when_then = None, case_else = None, 
-               stratify_column = None, seed = None, id_column = None):
+    @collect_queryband(queryband="DF_sample")
+    def sample(self, n=None, frac=None, replace=False, randomize=False, case_when_then=None, case_else=None,
+               stratify_column=None, seed=None, id_column=None):
         """
         DESCRIPTION:
             Allows to sample few rows from dataframe directly or based on conditions.
@@ -9679,21 +9951,21 @@ class DataFrame():
         try:
             if n is not None and frac is not None:
                 raise TeradataMlException(Messages.get_message(MessageCodes.EITHER_THIS_OR_THAT_ARGUMENT,
-                                                           "n", "frac"),
-                          MessageCodes.EITHER_THIS_OR_THAT_ARGUMENT)
+                                                               "n", "frac"),
+                                          MessageCodes.EITHER_THIS_OR_THAT_ARGUMENT)
             if n is not None and case_when_then is not None:
                 raise TeradataMlException(Messages.get_message(MessageCodes.EITHER_THIS_OR_THAT_ARGUMENT,
-                                                           "n", "case_when_then"),
-                          MessageCodes.EITHER_THIS_OR_THAT_ARGUMENT)
+                                                               "n", "case_when_then"),
+                                          MessageCodes.EITHER_THIS_OR_THAT_ARGUMENT)
             if frac is not None and case_when_then is not None:
                 raise TeradataMlException(Messages.get_message(MessageCodes.EITHER_THIS_OR_THAT_ARGUMENT,
-                                                           "frac", "case_when_then"),
-                          MessageCodes.EITHER_THIS_OR_THAT_ARGUMENT)
+                                                               "frac", "case_when_then"),
+                                          MessageCodes.EITHER_THIS_OR_THAT_ARGUMENT)
             _Validators._validate_dependent_argument("case_else", case_else, "case_when_then", case_when_then)
             if n is None and frac is None and case_when_then is None:
-                raise TeradataMlException(Messages.get_message(MessageCodes.EITHER_THIS_OR_THAT_ARGUMENT, 
-                                                           "n or frac", "case_when_then"), 
-                          MessageCodes.EITHER_THIS_OR_THAT_ARGUMENT)
+                raise TeradataMlException(Messages.get_message(MessageCodes.EITHER_THIS_OR_THAT_ARGUMENT,
+                                                               "n or frac", "case_when_then"),
+                                          MessageCodes.EITHER_THIS_OR_THAT_ARGUMENT)
 
             # Argument validations
             awu_matrix = []
@@ -9739,7 +10011,7 @@ class DataFrame():
                 self.__validate_sum_of_list_for_sample_api(frac, "frac")
                 self.__validate_number_of_rows_for_sample_api(frac, "frac")
                 case_when_then = {}
-                list_of_fracs  = frac
+                list_of_fracs = frac
 
                 # When stratify column is passed for sample then perform TrainTestSplit 
                 # for data sampling. 
@@ -9750,9 +10022,9 @@ class DataFrame():
                     # For statify column Train Test split size must sum up to 1.
                     if len(list_of_fracs) == 1:
                         list_of_fracs.append(1 - list_of_fracs[0])
-                    
+
                     # Call TrainTestSplit and return the result dataframe.
-                    TrainTestSplit_out = TrainTestSplit(data = self,
+                    TrainTestSplit_out = TrainTestSplit(data=self,
                                                         id_column=id_column,
                                                         train_size=list_of_fracs[0],
                                                         test_size=list_of_fracs[1],
@@ -9762,11 +10034,11 @@ class DataFrame():
                     # for backward compatibility.
                     _sampled_df = TrainTestSplit_out.result
                     # Column name "TD_IsTrainRow" renamed to "sampleid".
-                    return _sampled_df.assign(sampleid = case([
-                            (_sampled_df.TD_IsTrainRow == 0, 2)], 
-                            else_=1)).drop("TD_IsTrainRow", axis = 1)
-                    
-                     
+                    return _sampled_df.assign(sampleid=case([
+                        (_sampled_df.TD_IsTrainRow == 0, 2)],
+                        else_=1)).drop("TD_IsTrainRow", axis=1)
+
+
 
             else:
                 # Creating OrderDict for 'case_when_then' so that order of keys doesn't change after
@@ -9774,8 +10046,8 @@ class DataFrame():
                 case_when_then = OrderedDict(case_when_then)
                 if len(case_when_then) > 16:
                     raise TeradataMlException(
-                          Messages.get_message(MessageCodes.TDML_SAMPLE_INVALID_NUMBER_OF_SAMPLES, "case_when_then"), 
-                          MessageCodes.TDML_SAMPLE_INVALID_NUMBER_OF_SAMPLES)
+                        Messages.get_message(MessageCodes.TDML_SAMPLE_INVALID_NUMBER_OF_SAMPLES, "case_when_then"),
+                        MessageCodes.TDML_SAMPLE_INVALID_NUMBER_OF_SAMPLES)
 
                 transformed_case_when_then = OrderedDict()
                 for when_condition, then_sample_number in case_when_then.items():
@@ -9791,12 +10063,12 @@ class DataFrame():
 
                     # Validating values in the dict.
                     if isinstance(then_sample_number, int) or (isinstance(then_sample_number, list) \
-                       and isinstance(then_sample_number[0], int)):
+                                                               and isinstance(then_sample_number[0], int)):
                         _Validators._validate_function_arguments([["Values in case_when_then", then_sample_number,
-                                                     True, (int, list)]])
+                                                                   True, (int, list)]])
                     else:
                         _Validators._validate_function_arguments([["Values in case_when_then", then_sample_number,
-                                                     True, ((float, list))]])
+                                                                   True, ((float, list))]])
 
                     if isinstance(then_sample_number, list):
                         self.__validate_len_of_list_for_sample_api(then_sample_number, "case_when_then")
@@ -9818,11 +10090,11 @@ class DataFrame():
 
                     case_else_awu_matrix = []
                     if isinstance(case_else[0], int):
-                        case_else_awu_matrix.append(['Number of rows or fractions in case_else', 
-                                                      case_else, True, (int, list)])
+                        case_else_awu_matrix.append(['Number of rows or fractions in case_else',
+                                                     case_else, True, (int, list)])
                     else:
-                        case_else_awu_matrix.append(['Number of rows or fractions in case_else', 
-                                                      case_else, True, (float, list)])
+                        case_else_awu_matrix.append(['Number of rows or fractions in case_else',
+                                                     case_else, True, (float, list)])
 
                     # Validating argument values for 'case_else'.
                     _Validators._validate_function_arguments(case_else_awu_matrix)
@@ -9848,16 +10120,25 @@ class DataFrame():
             for column in self.columns:
                 self.__add_column_type_item_to_dict(new_metaexpr_columns_types, column,
                                                     column, df_columns_types)
-    
+
             # As we are creating new column name, adding it to new metadata dict
             new_metaexpr_columns_types[sample_column] = INTEGER()
             sample_node_id = self._aed_utils._aed_sample(self._nodeid, ",".join(selected_columns),
                                              list_of_fracs, replace, randomize, case_when_then, case_else_var)
-            column_info = ((col_name, col_type) for col_name, col_type in 
+
+            column_info = ((col_name, col_type) for col_name, col_type in
                                                 new_metaexpr_columns_types.items())
             # Get new metaexpr for sample_node_id
             new_metaexpr = UtilFuncs._get_metaexpr_using_columns(sample_node_id, column_info, is_persist=True)
-            return self._create_dataframe_from_node(sample_node_id, new_metaexpr, self._index_label)
+
+            # Make this non-lazy. Added this in order to fix https://teradata-pe.atlassian.net/browse/ELE-6368
+            # Cannot use __execute_node_and_set_table_name because self points to original df.
+            # Hence, setting the __table_name with _execute_node_return_db_object_name.
+
+            df = self._create_dataframe_from_node(sample_node_id, new_metaexpr, self._index_label)
+            df.__table_name = df_utils._execute_node_return_db_object_name(sample_node_id, new_metaexpr)
+
+            return df
 
         except TeradataMlException:
             raise
@@ -9873,7 +10154,8 @@ class DataFrame():
             msg = Messages.get_message(errcode)
             raise TeradataMlException(msg, errcode) from err
 
-    def show_query(self, full_query = False):
+    @collect_queryband(queryband="DF_showQuery")
+    def show_query(self, full_query=False):
         """
         DESCRIPTION:
             Function returns underlying SQL for the teradataml DataFrame. It is the same 
@@ -10016,6 +10298,7 @@ class DataFrame():
             msg = Messages.get_message(errcode)
             raise TeradataMlException(msg, errcode) from err
 
+    @collect_queryband(queryband="DF_mapRow")
     def map_row(self,
                 user_function,
                 exec_mode='IN-DB',
@@ -10083,9 +10366,6 @@ class DataFrame():
                     * LOCAL: Execute the function locally on sample data (at
                              most "num_rows" rows) from the teradataml
                              DataFrame.
-                    * SANDBOX: Execute the function locally within a sandbox
-                               environment on sample data (at most "num_rows"
-                               rows) from the teradataml DataFrame.
                 Default value: 'IN-DB'
                 Types: str
 
@@ -10103,7 +10383,7 @@ class DataFrame():
                 Optional Argument.
                 Specifies the maximum number of sample rows to use from the
                 teradataml DataFrame to apply the user defined function to when
-                "exec_mode" is 'LOCAL' or 'SANDBOX'.
+                "exec_mode" is 'LOCAL'.
                 Default value: 1000
                 Types: int
 
@@ -10383,6 +10663,7 @@ class DataFrame():
 
         return tbl_op_util.execute()
 
+    @collect_queryband(queryband="DF_mapPartition")
     def map_partition(self,
                       user_function,
                       exec_mode='IN-DB',
@@ -10454,9 +10735,6 @@ class DataFrame():
                     * LOCAL: Execute the function locally on sample data (at
                              most "num_rows" rows) from the teradataml
                              DataFrame.
-                    * SANDBOX: Execute the function locally within a sandbox
-                               environment on sample data (at most "num_rows"
-                               rows) from the teradataml DataFrame.
                 Default value: 'IN-DB'
                 Types: str
 
@@ -10474,7 +10752,7 @@ class DataFrame():
                 Optional Argument.
                 Specifies the maximum number of sample rows to use from the
                 teradataml DataFrame to apply the user defined function to when
-                "exec_mode" is 'LOCAL' or 'SANDBOX'.
+                "exec_mode" is 'LOCAL'.
                 Default value: 1000
                 Types: int
 
@@ -10795,6 +11073,7 @@ class DataFrame():
 
         return tbl_op_util.execute()
 
+    @collect_queryband(queryband="DF_apply")
     def apply(self,
               user_function,
               exec_mode='REMOTE',
@@ -11148,8 +11427,8 @@ class DataFrame():
         # When returns argument is not specified, assume output schema
         # is same as input table schema.
         default_returns = OrderedDict(zip(self.columns,
-                                      [col.type for col in
-                                      self._metaexpr.c]))
+                                          [col.type for col in
+                                           self._metaexpr.c]))
         returns = kwargs.pop('returns', default_returns)
         arg_info_matrix.append(["returns", returns, False, (dict)])
 
@@ -11194,6 +11473,7 @@ class DataFrame():
 
         return tbl_op_util.execute()
 
+    @collect_queryband(queryband="DF_window")
     def window(self,
                partition_columns=None,
                order_columns=None,
@@ -11240,7 +11520,7 @@ class DataFrame():
                         columns of a teradataml DataFrame.
                      3. "partition_columns" supports only columns specified in
                         groupby function, if window is initiated on DataFrameGroupBy.
-                Types: str OR list of Strings (str)
+                Types: str OR list of Strings (str) OR ColumnExpression OR list of ColumnExpressions
 
             order_columns:
                 Optional Argument.
@@ -11254,17 +11534,24 @@ class DataFrame():
                        columns of a teradataml DataFrame.
                     2. "order_columns" supports only columns specified in
                         groupby, if window is initiated on DataFrameGroupBy.
-
-                Types: str OR list of Strings (str)
+                    3. When ColumnExpression(s) is(are) passed to "order_columns", then the
+                       corresponding expression takes precedence over arguments
+                       "sort_ascending" and "nulls_first". Say, ColumnExpression is col1, then
+	                   1. col1.asc() or col.desc() is effective irrespective of "sort_ascending".
+	                   2. col1.nulls_first() or col.nulls_last() is effective irrespective of "nulls_first".
+	                   3. Any combination of above two take precedence over "sort_ascending" and "nulls_first".
+                Types: str OR list of Strings (str) OR ColumnExpression OR list of ColumnExpressions
 
             sort_ascending:
                 Optional Argument.
                 Specifies whether column ordering should be in ascending or
                 descending order.
                 Default Value: True (ascending)
-                Note:
-                    When "order_columns" argument is not specified, this argument
-                    is ignored.
+                Notes:
+                     * When "order_columns" argument is not specified, this argument
+                       is ignored.
+                     * When ColumnExpression(s) is(are) passed to "order_columns", then the
+                       argument is ignored.
                 Types: bool
 
             nulls_first:
@@ -11272,9 +11559,11 @@ class DataFrame():
                 Specifies whether null results are to be listed first or last
                 or scattered.
                 Default Value: None
-                Note:
-                    When "order_columns" argument is not specified, this argument
-                    is ignored.
+                Notes:
+                     * When "order_columns" argument is not specified, this argument
+                       is ignored.
+                     * When "order_columns" is a ColumnExpression(s), this argument
+                       is ignored.
                 Types: bool
 
             window_start_point:
@@ -11362,19 +11651,18 @@ class DataFrame():
             #            between unbounded preceding and 3 preceding with
             #            "partition_columns" and "order_columns" argument with
             #            default sorting.
-            >>> window = df.window(partition_columns="Feb",
-            ...                    order_columns=["Feb", "datetime"],
+            >>> window = df.window(partition_columns=df.Feb,
+            ...                    order_columns=[df.Feb, "datetime"],
             ...                    window_start_point=None,
             ...                    window_end_point=-3)
             >>>
 
             # Example 3: Create a moving (rolling) window with rows between
-            #            current row and 3 following with sorting done on 'Feb',
-            #            'datetime' columns in descending order and
-            #            "partition_columns" argument.
-            >>> window = df.window(partition_columns="Feb",
-            ...                    order_columns=["Feb", "datetime"],
-            ...                    sort_ascending=False,
+            #            current row and 3 following with sorting done on 'Feb'
+            #            in ascending order, datetime' columns in descending order
+            #            and "partition_columns" argument.
+            >>> window = df.window(partition_columns=df.Feb,
+            ...                    order_columns=[df.Feb.asc(), df.datetime.desc()],
             ...                    window_start_point=0,
             ...                    window_end_point=3)
             >>>
@@ -11384,30 +11672,26 @@ class DataFrame():
             #            sorting done on 'Feb', 'datetime' columns in ascending
             #            order and NULL values in 'Feb', 'datetime'
             #            columns appears at last.
-            >>> window = df.window(partition_columns="Feb",
-            ...                    order_columns=["Feb", "datetime"],
-            ...                    nulls_first=False,
+            >>> window = df.window(partition_columns=df.Feb,
+            ...                    order_columns=[df.Feb.nulls_first(), df.datetime.nulls_first()],
             ...                    window_start_point=0,
             ...                    window_end_point=None)
             >>>
 
             # Example 5: Create a grouping window, with sorting done on 'Feb',
-            #            'datetime' columns in ascending order and NULL values
-            #            in 'Feb', 'datetime' columns appears at last.
+            #            'datetime' columns in ascending order with NULL values
+            #            in 'Feb' column appears at first and 'datetime' column
+            #            appears at last.
             >>> window = df.window(partition_columns="Feb",
-            ...                    order_columns=["Feb", "datetime"],
-            ...                    sort_ascending=False,
-            ...                    nulls_first=False,
+            ...                    order_columns=[df.Feb.nulls_first(), df.datetime.nulls_last()],
             ...                    window_start_point=None,
             ...                    window_end_point=None)
             >>>
 
             # Example 6: Create a window on a teradataml DataFrame, which
             #            ignores all the parameters while creating window.
-            >>> window = df.window(partition_columns="Feb",
-            ...                    order_columns=["Feb", "datetime"],
-            ...                    sort_ascending=False,
-            ...                    nulls_first=False,
+            >>> window = df.window(partition_columns=df.Feb,
+            ...                    order_columns=[df.Feb.desc().nulls_last(), df.datetime.desc().nulls_last()]
             ...                    ignore_window=True)
             >>>
 
@@ -11462,6 +11746,7 @@ class DataFrame():
                       window_end_point=window_end_point,
                       ignore_window=ignore_window)
 
+    @collect_queryband(queryband="DF_dropDuplicate")
     def drop_duplicate(self, column_names=None):
         """
         DESCRIPTION:
@@ -11535,6 +11820,7 @@ class DataFrame():
         new_metaexpr = UtilFuncs._get_metaexpr_using_columns(sel_nodeid, col_names_types.items())
         return self._create_dataframe_from_node(sel_nodeid, new_metaexpr, self._index_label)
 
+    @collect_queryband(queryband="DF_toCsv")
     def to_csv(self, csv_file,
                num_rows=99999,
                all_rows=False,
@@ -11760,10 +12046,11 @@ class DataFrame():
                 Messages.get_message(MessageCodes.DATA_EXPORT_FAILED, "to_csv",
                                      "CSV file", str(err)),
                 MessageCodes.DATA_EXPORT_FAILED)
-    
+
+    @collect_queryband(queryband="DF_pivot")
     def pivot(self,
               columns=None,
-              aggfuncs=None, 
+              aggfuncs=None,
               limit_combinations=False,
               margins=None,
               returns=None,
@@ -12110,7 +12397,7 @@ class DataFrame():
         if columns_arg_req and isinstance(columns, dict):
             expected_value_types = (int, float, str, _ListOf(int), _ListOf(float), _ListOf(str), DataFrame)
             _Validators._validate_dict_argument_key_value(arg_name="columns", arg_dict=columns,
-                                                          key_types=(ColumnExpression, ),
+                                                          key_types=(ColumnExpression,),
                                                           value_types=expected_value_types)
         if margins:
             _Validators._validate_dict_argument_key_value(arg_name="margins", arg_dict=margins,
@@ -12159,7 +12446,7 @@ class DataFrame():
                                                     "DataFrame specified as value in 'columns' argument "
                                                     "should have only one column.")
                         raise ValueError(err_)
-                    _column_value = [* (i[0] for i in _v_df.drop_duplicate().get_values())]
+                    _column_value = [*(i[0] for i in _v_df.drop_duplicate().get_values())]
                 else:
                     # We are allowing users to pass an int, str, float or list of int, float, str.
                     # Convert it to list, if it is not a list.
@@ -12238,7 +12525,7 @@ class DataFrame():
         non_participating_columns = [col for col in self.columns if col not in participating_columns]
 
         # Generating WITH clause.
-        with_clause, seperator  = "", ""
+        with_clause, seperator = "", ""
         with_clause_column_names = []
         if margins:
             # margins will be a dict. Key is analytic function name. Value can be a tuple or list of tuple.
@@ -12284,7 +12571,8 @@ class DataFrame():
         sql = "SELECT * FROM {} PIVOT ({for_clause} {with_clause}) {derived_table_clause}".format(
             self._table_name, for_clause=for_clause, with_clause=with_clause, derived_table_clause=tmp_clause)
         return DataFrame.from_query(sql)
-    
+
+    @collect_queryband(queryband="DF_unpivot")
     def unpivot(self,
                 columns=None,
                 transpose_column=None,
@@ -12546,7 +12834,7 @@ class DataFrame():
         arg_info_matrix.append(["exclude_nulls", exclude_nulls, True, (bool)])
         arg_info_matrix.append(["returns", returns, True, (str, list), True])
         arg_info_matrix.append(["all_columns", all_columns, True, (bool)])
-        for i in range(1, int(len(kwargs)/2) + 1):
+        for i in range(1, int(len(kwargs) / 2) + 1):
             # Get the values of colN where N is in range(1, half the length of kwargs + 1).
             col = kwargs.get("col{}".format(i), None)
             col_val = kwargs.get("col{}_value".format(i), None)
@@ -12703,7 +12991,7 @@ class DataFrame():
                 self._nodeid, self._metaexpr)
 
         # Generate the SELECT query.
-        select_query = 'SELECT * FROM {tbl_name} UNPIVOT{excl_null} ({for_cl}) {tmp_cl};'.\
+        select_query = 'SELECT * FROM {tbl_name} UNPIVOT{excl_null} ({for_cl}) {tmp_cl};'. \
             format(tbl_name=self._table_name,
                    excl_null="" if exclude_nulls else " INCLUDE NULLS",
                    for_cl=for_clause,
@@ -12712,6 +13000,7 @@ class DataFrame():
         # Create the teradataml dataframe from SELECT query and return the same.
         return DataFrame.from_query(select_query)
 
+    @collect_queryband(queryband="DF_plot")
     def plot(self, x, y, scale=None, kind="line", **kwargs):
         """
         DESCRIPTION:
@@ -13075,6 +13364,14 @@ class DataFrame():
                     Applicable only for the wiggle and mesh plots.
                 Types: int OR float
 
+            ignore_nulls:
+                Optional Argument.
+                Specifies whether to delete rows with null values or not present in 'x', 'y' and
+                'scale' params.
+                Default Value: False
+                Types: bool
+
+
         RAISES:
             TeradataMlException
 
@@ -13437,6 +13734,7 @@ class DataFrame():
         """
         return _Plot(x=x, y=y, scale=scale, kind=kind, **kwargs)
 
+    @collect_queryband(queryband="DF_itertuples")
     def itertuples(self, name='Row', num_rows=None):
         """
         DESCRIPTION:
@@ -13513,6 +13811,287 @@ class DataFrame():
             for rec in cur:
                 yield rec
 
+    @collect_queryband(queryband="DF_replace")
+    def replace(self, to_replace, value=None, subset=None):
+        """
+        DESCRIPTION:
+            Function replaces every occurrence of "to_replace" with the "value"
+            in the columns mentioned in "subset". When "subset" is not provided,
+            function replaces in all columns.
+
+        PARAMETERS:
+            to_replace:
+                Required Argument.
+                Specifies a ColumnExpression or a literal that the function
+                searches for values in the Column. Use ColumnExpression when
+                you want to match the condition based on a DataFrameColumn
+                function, else use literal.
+                Note:
+                    Only ColumnExpressions generated from DataFrameColumn
+                    functions are supported. BinaryExpressions are not supported.
+                    Example: Consider teradataml DataFrame has two columns COL1, COL2.
+                             df.COL1.abs() is supported but df.COL1 == df.COL2 is not
+                             supported.
+                Supported column types: CHAR, VARCHAR, FLOAT, INTEGER, DECIMAL
+                Types: ColumnExpression OR int OR float OR str OR dict
+
+            value:
+                Required argument when "to_replace" is not a dictionary. Optional otherwise.
+                Specifies a ColumnExpression or a literal that replaces
+                the "to_replace" in the column. Use ColumnExpression when
+                you want to replace based on a DataFrameColumn function, else
+                use literal.
+                Notes:
+                     * Argument is ignored if "to_replace" is a dictionary.
+                     * Only ColumnExpressions generated from DataFrameColumn
+                       functions are supported. BinaryExpressions are not supported.
+                       Example: Consider teradataml DataFrame has two columns COL1, COL2.
+                                df.COL1.abs() is supported but df.COL1 == df.COL2 is not
+                                supported.
+                Supported column types: CHAR, VARCHAR, FLOAT, INTEGER, DECIMAL
+                Types: ColumnExpression OR int OR float OR str
+
+            subset:
+                Optional Argument.
+                Specifies column(s) to consider for replacing the values.
+                Types: ColumnExpression OR str OR list
+
+        RAISES:
+            TeradataMlException
+
+        RETURNS:
+            teradataml DataFrame
+
+        EXAMPLES:
+            # Load the data to run the example.
+            >>> load_example_data("dataframe", "admissions_train")
+
+            # Create a DataFrame on 'admissions_train' table.
+            >>> df = DataFrame("admissions_train")
+            >>> print(df)
+               masters   gpa     stats programming  admitted
+            id
+            15     yes  4.00  Advanced    Advanced         1
+            34     yes  3.85  Advanced    Beginner         0
+            13      no  4.00  Advanced      Novice         1
+            38     yes  2.65  Advanced    Beginner         1
+            5       no  3.44    Novice      Novice         0
+            40     yes  3.95    Novice    Beginner         0
+            7      yes  2.33    Novice      Novice         1
+            22     yes  3.46    Novice    Beginner         0
+            26     yes  3.57  Advanced    Advanced         1
+            17      no  3.83  Advanced    Advanced         1
+
+            # Example 1: Replace the string 'Advanced' with 'Good' in columns 'stats'
+            #            and 'programming'.
+            >>> res = df.replace("Advanced", "Good", subset=["stats", "programming"])
+            >>> print(res)
+               masters   gpa   stats programming  admitted
+            id
+            13      no  4.00    Good      Novice         1
+            36      no  3.00    Good      Novice         0
+            15     yes  4.00    Good        Good         1
+            40     yes  3.95  Novice    Beginner         0
+            22     yes  3.46  Novice    Beginner         0
+            38     yes  2.65    Good    Beginner         1
+            26     yes  3.57    Good        Good         1
+            5       no  3.44  Novice      Novice         0
+            7      yes  2.33  Novice      Novice         1
+            19     yes  1.98    Good        Good         0
+
+            # Example 2: Replace the string 'Advanced' with 'Good' and 'Beginner' with 'starter'
+            #            in columns 'stats' and 'programming'.
+            >>> res = df.replace({"Advanced": "Good", "Beginner": "starter"}, subset=["stats", "programming"])
+            >>> print(res)
+               masters   gpa   stats programming  admitted
+            id
+            15     yes  4.00    Good        Good         1
+            7      yes  2.33  Novice      Novice         1
+            22     yes  3.46  Novice     starter         0
+            17      no  3.83    Good        Good         1
+            13      no  4.00    Good      Novice         1
+            38     yes  2.65    Good     starter         1
+            26     yes  3.57    Good        Good         1
+            5       no  3.44  Novice      Novice         0
+            34     yes  3.85    Good     starter         0
+            40     yes  3.95  Novice     starter         0
+
+            # Example 3: Append the string '_New' to 'stats' column when values in
+            #           'programming' and 'stats' are same.
+            >>> res = df.replace({df.programming: df.stats+"_New"}, subset=["stats"])
+            >>> print(res)
+               masters   gpa         stats programming  admitted
+            id
+            15     yes  4.00  Advanced_New    Advanced         1
+            34     yes  3.85      Advanced    Beginner         0
+            13      no  4.00      Advanced      Novice         1
+            38     yes  2.65      Advanced    Beginner         1
+            5       no  3.44    Novice_New      Novice         0
+            40     yes  3.95        Novice    Beginner         0
+            7      yes  2.33    Novice_New      Novice         1
+            22     yes  3.46        Novice    Beginner         0
+            26     yes  3.57  Advanced_New    Advanced         1
+            17      no  3.83  Advanced_New    Advanced         1
+
+            # Example 4: Round the values of gpa to it's nearest integer.
+            >>> res = df.replace({df.gpa: df.gpa.round(0)}, subset=["gpa"])
+            >>> print(res)
+               masters  gpa     stats programming  admitted
+            id
+            15     yes  4.0  Advanced    Advanced         1
+            7      yes  2.0    Novice      Novice         1
+            22     yes  3.0    Novice    Beginner         0
+            17      no  4.0  Advanced    Advanced         1
+            13      no  4.0  Advanced      Novice         1
+            38     yes  3.0  Advanced    Beginner         1
+            26     yes  4.0  Advanced    Advanced         1
+            5       no  3.0    Novice      Novice         0
+            34     yes  4.0  Advanced    Beginner         0
+            40     yes  4.0    Novice    Beginner         0
+
+            # Example 5: Replace the value of masters with '1' if value is 'yes'
+            #            and with '0' if value is no.
+            >>> res = df.replace({'yes': 1, 'no': 0}, subset=["masters"])
+            >>> print(res)
+               masters   gpa     stats programming  admitted
+            id
+            15       1  4.00  Advanced    Advanced         1
+            7        1  2.33    Novice      Novice         1
+            22       1  3.46    Novice    Beginner         0
+            17       0  3.83  Advanced    Advanced         1
+            13       0  4.00  Advanced      Novice         1
+            38       1  2.65  Advanced    Beginner         1
+            26       1  3.57  Advanced    Advanced         1
+            5        0  3.44    Novice      Novice         0
+            34       1  3.85  Advanced    Beginner         0
+            40       1  3.95    Novice    Beginner         0
+        """
+        _validation_matrix = []
+        _validation_matrix.append(["to_replace", to_replace, True, (int, float, str, dict, ColumnExpression)])
+        _validation_matrix.append(["value", value, False, (int, float, str, dict, type(None), ColumnExpression)])
+        _validation_matrix.append(["subset", subset, False, (str, list, type(None))])
+        _Validators._validate_function_arguments(_validation_matrix)
+
+        if subset is None:
+            subset = self.columns
+        else:
+            subset = [col.name if not isinstance(col, str) else col for col in UtilFuncs._as_list(subset)]
+
+        if not isinstance(to_replace, dict):
+            to_replace = {to_replace: value}
+
+        new_columns = {}
+        for column in self.columns:
+            new_columns[column] = self[column].replace(to_replace) if column in subset else self[column]
+        return self.assign(**new_columns, drop_columns=True).select(self.columns)
+
+    @collect_queryband(queryband="DF_cube")
+    def cube(self, columns):
+        """
+        DESCRIPTION:
+            cube() function creates a multi-dimensional cube for the DataFrame
+            using the specified column(s), and there by running aggregates on
+            it to produce the aggregations on different dimensions.
+
+
+        PARAMETERS:
+            columns:
+                Required Argument.
+                Specifies the name(s) of input teradataml DataFrame column(s).
+                Types: str OR list of str(s)
+
+        RETURNS:
+            teradataml DataFrameGroupBy
+
+        RAISES:
+            TeradataMlException
+
+        EXAMPLES :
+            # Example 1: Analyzes the data by grouping into masters and stats dimensions.
+            >>> load_example_data("dataframe","admissions_train")
+            >>> df = DataFrame("admissions_train")
+            >>> df1 = df.cube(["masters", "stats"]).sum()
+            >>> df1
+              masters     stats  sum_id  sum_gpa  sum_admitted
+            0      no  Beginner       8     3.60             1
+            1    None  Advanced     555    84.21            16
+            2    None  Beginner      21    18.31             3
+            3     yes  Beginner      13    14.71             2
+            4    None      None     820   141.67            26
+            5     yes  Advanced     366    49.26             7
+            6      no      None     343    63.96            16
+            7    None    Novice     244    39.15             7
+            8      no  Advanced     189    34.95             9
+            9     yes    Novice      98    13.74             1
+
+        """
+        # Validate columns argument.
+        arg_info_matrix = []
+        arg_info_matrix.append(["columns", columns, False, (str, list), True])
+
+        # Validate argument types
+        _Validators._validate_function_arguments(arg_info_matrix)
+
+        # Checking each element in passed columns to be valid column in dataframe
+        _Validators._validate_column_exists_in_dataframe(columns, self._metaexpr)
+
+        # Query generation of cube API is same as the group by.
+        # Only 'cube' is concatenated with 'group by' clause.
+        return self.groupby(columns, option="cube")
+
+    @collect_queryband(queryband="DF_rollup")
+    def rollup(self, columns):
+        """
+        DESCRIPTION:
+            rollup() function creates a multi-dimensional rollup for the DataFrame
+            using the specified column(s), and there by running aggregates on
+            it to produce the aggregations on different dimensions.
+
+
+        PARAMETERS:
+            columns:
+                Required Argument.
+                Specifies the name(s) of input teradataml DataFrame column(s).
+                Types: str OR list of str(s)
+
+        RETURNS:
+            teradataml DataFrameGroupBy
+
+        RAISES:
+            TeradataMlException
+
+        EXAMPLES :
+            # Example 1: Analyzes the data by grouping into masters and stats dimensions.
+            >>> load_example_data("dataframe","admissions_train")
+            >>> df = DataFrame("admissions_train")
+            >>> df1 = df.rollup(["masters", "stats"]).sum()
+            >>> df1
+              masters     stats  sum_id  sum_gpa  sum_admitted
+            0      no      None     343    63.96            16
+            1     yes      None     477    77.71            10
+            2    None      None     820   141.67            26
+            3      no    Novice     146    25.41             6
+            4      no  Beginner       8     3.60             1
+            5     yes    Novice      98    13.74             1
+            6     yes  Beginner      13    14.71             2
+            7     yes  Advanced     366    49.26             7
+            8      no  Advanced     189    34.95             9
+
+        """
+        # Validate columns argument.
+        arg_info_matrix = []
+        arg_info_matrix.append(["columns", columns, False, (str, list), True])
+
+        # Validate argument types
+        _Validators._validate_function_arguments(arg_info_matrix)
+
+        # Checking each element in passed columns to be valid column in dataframe
+        _Validators._validate_column_exists_in_dataframe(columns, self._metaexpr)
+
+        # Query generation of cube API is same as the group by.
+        # Only 'rollup' is concatenated with 'group by' clause.
+        return self.groupby(columns, option="rollup")
+
 
 class DataFrameGroupBy(DataFrame):
     """
@@ -13520,7 +14099,8 @@ class DataFrameGroupBy(DataFrame):
     Updates AED node for DataFrame groupby object.
 
     """
-    def __init__(self, nodeid, metaexpr, column_names_and_types, columns, groupbyexpr, column_list):
+
+    def __init__(self, nodeid, metaexpr, column_names_and_types, columns, groupbyexpr, column_list, option=None):
         """
         init() method for DataFrameGroupBy.
 
@@ -13555,11 +14135,17 @@ class DataFrameGroupBy(DataFrame):
                 Specifies list of columns provided by user to be part group by clause.
                 Types: str or List of Strings
 
+            option:
+                Optional Argument.
+                Specifies the groupby option.
+                Permitted Values: "CUBE", "ROLLUP", None
+                Types: str or NoneType
+
         RETURNS:
             teradataml DataFrameGroupBy instance
         """
         super(DataFrameGroupBy, self).__init__()
-        self._nodeid = self._aed_utils._aed_groupby(nodeid, groupbyexpr)
+        self._nodeid = self._aed_utils._aed_groupby(nodeid, groupbyexpr, option)
         self._metaexpr = metaexpr
         self._column_names_and_types = column_names_and_types
         self._columns = columns
@@ -13583,7 +14169,7 @@ class DataFrameGroupBy(DataFrame):
             allowed_types = self._get_assign_allowed_types()
         """
         from sqlalchemy.sql.functions import Function
-        return (type(None), int, float, str, decimal.Decimal, Function, ColumnExpression)
+        return (type(None), int, float, str, decimal.Decimal, Function, ColumnExpression, ClauseElement)
 
     def _generate_assign_metaexpr_aed_nodeid(self, drop_columns, **kwargs):
         """
@@ -13675,8 +14261,10 @@ class DataFrameGroupByTime(DataFrame):
     Updates AED node for DataFrame GROUP BY TIME object.
 
     """
-    def __init__(self, nodeid, metaexpr, column_names_and_types, columns, groupby_value_expr, column_list, timebucket_duration,
-                 value_expression = None, timecode_column = None, sequence_column = None, fill = None):
+
+    def __init__(self, nodeid, metaexpr, column_names_and_types, columns, groupby_value_expr, column_list,
+                 timebucket_duration,
+                 value_expression=None, timecode_column=None, sequence_column=None, fill=None):
         """
         init() method for DataFrameGroupByTime.
 
@@ -13762,10 +14350,10 @@ class DataFrameGroupByTime(DataFrame):
         timecode_column = "" if timecode_column is None else UtilFuncs._process_for_teradata_keyword(timecode_column)
         sequence_column = "" if sequence_column is None else UtilFuncs._process_for_teradata_keyword(sequence_column)
 
-        self._nodeid = self._aed_utils._aed_groupby_time(nodeid = nodeid, timebucket_duration = timebucket_duration,
-                                                         value_expression = groupby_value_expr,
-                                                         using_timecode = timecode_column, seqno_col = sequence_column,
-                                                         fill = fill)
+        self._nodeid = self._aed_utils._aed_groupby_time(nodeid=nodeid, timebucket_duration=timebucket_duration,
+                                                         value_expression=groupby_value_expr,
+                                                         using_timecode=timecode_column, seqno_col=sequence_column,
+                                                         fill=fill)
 
         # MetaExpression is same as that of parent.
         self._metaexpr = metaexpr
@@ -13788,6 +14376,7 @@ class DataFrameGroupByTime(DataFrame):
         self._sequence_column = sequence_column
         self._fill = fill
 
+    @collect_queryband(queryband="DF_bottom")
     def bottom(self, number_of_values_to_column, with_ties=False):
         """
         DESCRIPTION:
@@ -14059,6 +14648,7 @@ class DataFrameGroupByTime(DataFrame):
 
         return self.__process_time_series_aggregate_with_multi_input_arguments(number_of_values_to_column, operation)
 
+    @collect_queryband(queryband="DF_deltaT")
     def delta_t(self, start_condition, end_condition):
         """
         DESCRIPTION:
@@ -14310,12 +14900,14 @@ class DataFrameGroupByTime(DataFrame):
         operation = "delta_t"
 
         kwargs = {
-            "start_condition": start_condition.compile() if isinstance(start_condition, ColumnExpression) else start_condition,
+            "start_condition": start_condition.compile() if isinstance(start_condition,
+                                                                       ColumnExpression) else start_condition,
             "end_condition": end_condition.compile() if isinstance(end_condition, ColumnExpression) else end_condition
         }
         return self._get_dataframe_aggregate(operation=operation, **kwargs)
 
-    def first(self, columns = None):
+    @collect_queryband(queryband="DF_first")
+    def first(self, columns=None):
         """
         DESCRIPTION:
             Returns the oldest value, determined by the timecode, for each group. FIRST is a single-threaded function.
@@ -14507,8 +15099,9 @@ class DataFrameGroupByTime(DataFrame):
         # Checking each element in passed columns to be valid column in dataframe
         _Validators._validate_column_exists_in_dataframe(columns, self._metaexpr)
 
-        return self._get_dataframe_aggregate(operation = 'first', columns=columns)
+        return self._get_dataframe_aggregate(operation='first', columns=columns)
 
+    @collect_queryband(queryband="DF_last")
     def last(self, columns=None):
         """
         DESCRIPTION:
@@ -14703,8 +15296,9 @@ class DataFrameGroupByTime(DataFrame):
         # Checking each element in passed columns to be valid column in dataframe
         _Validators._validate_column_exists_in_dataframe(columns, self._metaexpr)
 
-        return self._get_dataframe_aggregate(operation = 'last', columns=columns)
+        return self._get_dataframe_aggregate(operation='last', columns=columns)
 
+    @collect_queryband(queryband="DF_mad")
     def mad(self, constant_multiplier_columns=None):
         """
         DESCRIPTION:
@@ -14912,6 +15506,7 @@ class DataFrameGroupByTime(DataFrame):
 
         return self.__process_time_series_aggregate_with_multi_input_arguments(constant_multiplier_columns, 'mad')
 
+    @collect_queryband(queryband="DF_mode")
     def mode(self):
         """
         DESCRIPTION:
@@ -15066,6 +15661,7 @@ class DataFrameGroupByTime(DataFrame):
         """
         return self._get_dataframe_aggregate(operation='mode')
 
+    @collect_queryband(queryband="DF_percentile")
     def percentile(self, percentile, distinct=False, interpolation="LINEAR"):
         """
         DESCRIPTION:
@@ -15330,6 +15926,7 @@ class DataFrameGroupByTime(DataFrame):
         return self._get_dataframe_aggregate(operation='percentile', percentile=percentile,
                                              distinct=distinct, interpolation=interpolation)
 
+    @collect_queryband(queryband="DF_top")
     def top(self, number_of_values_to_column, with_ties=False):
         """
         DESCRIPTION:
@@ -15745,7 +16342,8 @@ class DataFrameGroupByTime(DataFrame):
                 remaining_columns = list(set(self.columns) - set(columns_processed))
                 unsupported_types = _Dtypes._get_unsupported_data_types_for_aggregate_operations(operation)
                 for column in remaining_columns:
-                    if not isinstance(self._td_column_names_and_sqlalchemy_types[column.lower()], tuple(unsupported_types)):
+                    if not isinstance(self._td_column_names_and_sqlalchemy_types[column.lower()],
+                                      tuple(unsupported_types)):
                         # We should not involve columns used in value expression of GROUP BY TIME clause as well.
                         if column not in self._value_expression:
                             default_constant_for_columns.append(column)
@@ -15964,9 +16562,9 @@ class _TDUAF(DataFrame):
         self._awu_matrix.append(["id_sequence", self._id_sequence, True, (str, list), True])
         self._awu_matrix.append(["payload_field", self._payload_field, not self._is_payload_required(), (str, list), True])
         self._awu_matrix.append(["payload_content", self._payload_content, not self._is_payload_required(), str, True,
-                           ["REAL", "COMPLEX", "AMPL_PHASE", "AMPL_PHASE_RADIANS", "AMPL_PHASE_DEGREES",
-                            "MULTIVAR_REAL", "MULTIVAR_COMPLEX", "MULTIVAR_ANYTYPE", "MULTIVAR_AMPL_PHASE",
-                            "MULTIVAR_AMPL_PHASE_RADIANS", "MULTIVAR_AMPL_PHASE_DEGREES"]])
+                                 ["REAL", "COMPLEX", "AMPL_PHASE", "AMPL_PHASE_RADIANS", "AMPL_PHASE_DEGREES",
+                                  "MULTIVAR_REAL", "MULTIVAR_COMPLEX", "MULTIVAR_ANYTYPE", "MULTIVAR_AMPL_PHASE",
+                                  "MULTIVAR_AMPL_PHASE_RADIANS", "MULTIVAR_AMPL_PHASE_DEGREES"]])
         self._awu_matrix.append(["layer", self._layer, True, str, True])
 
         # store the columns to check against the DataFrame.
@@ -16061,7 +16659,7 @@ class _TDUAF(DataFrame):
         # Declare a function to return a generator object. Note that, this should be a function because,
         # generator object exhausts after the first usage. So, if it is a regular variable,
         # _non_parameterised_sql will not have any data to consume from generator object.
-        get_sql_clauses = lambda : ("{}{}".format(" "*4, c) for c in sql_clauses)
+        get_sql_clauses = lambda: ("{}{}".format(" " * 4, c) for c in sql_clauses)
 
         self._parameterised_sql = self._spec_header.format(
             "\n" + ", \n".join(get_sql_clauses()).format(*(["?"]*len(sql_values)))), sql_values
@@ -16345,7 +16943,7 @@ class TDSeries(_TDUAF):
 
         self._additional_spec["SERIES_ID ({})"] = ", ".join(UtilFuncs._as_list(self._id))
 
-    def _create_dataframe_from_node(self, nodeid, metaexpr, index_label, undropped_columns = None):
+    def _create_dataframe_from_node(self, nodeid, metaexpr, index_label, undropped_columns=None):
         """
         DESCRIPTION:
             Function to call the _create_validate_dataframe_from_node which will create
@@ -16527,7 +17125,7 @@ class TDAnalyticResult(_TDUAF):
 
         self._spec_header = "ART_SPEC({})"
 
-    def _create_dataframe_from_node(self, nodeid, metaexpr, index_label, undropped_columns = None):
+    def _create_dataframe_from_node(self, nodeid, metaexpr, index_label, undropped_columns=None):
         """
         DESCRIPTION:
             Function to call the _create_validate_dataframe_from_node which will create
@@ -16716,7 +17314,8 @@ class TDMatrix(_TDUAF):
         self._column_index = column_index
         self._column_index_style = column_index_style
 
-        super().__init__(data=data, id=id, row_index=row_index, row_index_style=row_index_style, id_sequence=id_sequence,
+        super().__init__(data=data, id=id, row_index=row_index, row_index_style=row_index_style,
+                         id_sequence=id_sequence,
                          payload_field=payload_field, payload_content=payload_content, layer=layer)
         self._awu_matrix.append(["column_index", self._column_index, False, (str), True])
         self._awu_matrix.append(
@@ -16733,8 +17332,7 @@ class TDMatrix(_TDUAF):
 
         self._additional_spec["MATRIX_ID ({})"] = ", ".join(UtilFuncs._as_list(self._id))
 
-
-    def _create_dataframe_from_node(self, nodeid, metaexpr, index_label, undropped_columns = None):
+    def _create_dataframe_from_node(self, nodeid, metaexpr, index_label, undropped_columns=None):
         """
             DESCRIPTION:
                 Function to call the _create_validate_dataframe_from_node which will create
@@ -16793,6 +17391,7 @@ class TDGenSeries():
     """
     TDGenSeries class for UAF Functions.
     """
+
     def __init__(self, instances, data_types, start, offset, num_entries):
         """
         Generate a series to be passed to a UAF function rather than using a
@@ -16849,7 +17448,7 @@ class TDGenSeries():
             # Create a TDGenSeries object to be passed as input to UAF functions.
             >>> series = TDGenSeries(instances = {"BuoyID": 3}, data_types = INTEGER(), start=0, offset=1, num_entries=5)
         """
-        
+
         self._instances = instances
         self._data_types = data_types
         self._start = start
@@ -16943,4 +17542,4 @@ class TDGenSeries():
         if not self._parameterised_sql:
             self._generate_spec()
 
-        return self._parameterised_sql
+        return self._parameterised_sql