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

teradataml/dataframe/dataframe.py

@@ -24,6 +24,7 @@ import teradataml.context.context as tdmlctx
 from collections import OrderedDict, namedtuple
 from sqlalchemy.sql import ClauseElement
 from teradataml import execute_sql
+from teradataml import GarbageCollector
 from teradataml.dataframe.sql import _MetaExpression
 from teradataml.dataframe.sql_interfaces import ColumnExpression
 from teradataml.dataframe.sql_functions import case
@@ -41,6 +42,7 @@ from teradataml.dataframe.indexer import _LocationIndexer
 from teradataml.common.aed_utils import AedUtils
 from teradataml.options.display import display
 from teradataml.dataframe.copy_to import copy_to_sql
+from teradataml.dataframe.row import _Row
 from teradataml.dataframe.setop import concat
 from teradataml.plot.plot import _Plot
 from teradataml.scriptmgmt.UserEnv import UserEnv
@@ -52,7 +54,9 @@ 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
+from teradataml.telemetry_utils.queryband import collect_queryband
+from teradataml.options.configure import configure
+from teradataml.utils.internal_buffer import _InternalBuffer
 
 # TODO use logger when available on master branch
 # logger = teradatapylog.getLogger()
@@ -150,6 +154,11 @@ class DataFrame():
         # This attribute added to add setter for columns property,
         # it is required when setting columns from groupby
         self._columns = None
+        # This attribute stores the internal AED query and avoid multiple
+        # calls to AED utility function aed_show_query()
+        self._aed_query = None
+        # This attribute stores the type of query stored in self._aed_query.
+        self._is_full_query = None
 
         # Property to determine if table is an ART table or not.
         self._is_art = None
@@ -417,6 +426,130 @@ class DataFrame():
 
         return df
 
+    def create_temp_view(self, name):
+        """
+        DESCRIPTION:
+            Creates a temporary view for session on the DataFrame.
+
+        PARAMETERS:
+            name:
+                Required Argument.
+                Specifies the name of the temporary view.
+                Type: str
+
+        RETURNS:
+            None
+
+        RAISES:
+            OperationalError (When view already exists).
+
+        EXAMPLES:
+            # Load the data to run the example.
+            >>> load_example_data("dataframe", "admissions_train")
+            >>> df = DataFrame("admissions_train")
+            >>> df
+                masters   gpa     stats programming  admitted
+            id
+            38     yes  2.65  Advanced    Beginner         1
+            7      yes  2.33    Novice      Novice         1
+            26     yes  3.57  Advanced    Advanced         1
+            17      no  3.83  Advanced    Advanced         1
+            34     yes  3.85  Advanced    Beginner         0
+            13      no  4.00  Advanced      Novice         1
+            32     yes  3.46  Advanced    Beginner         0
+            11      no  3.13  Advanced    Advanced         1
+            15     yes  4.00  Advanced    Advanced         1
+            36      no  3.00  Advanced      Novice         0
+
+            # Example 1: Create view 'new_admissions'.
+            >>> df.create_temp_view("new_admissions")
+            >>> new_df = DataFrame("new_admissions")
+            >>> new_df
+                masters   gpa     stats programming  admitted
+            id
+            38     yes  2.65  Advanced    Beginner         1
+            7      yes  2.33    Novice      Novice         1
+            26     yes  3.57  Advanced    Advanced         1
+            17      no  3.83  Advanced    Advanced         1
+            34     yes  3.85  Advanced    Beginner         0
+            13      no  4.00  Advanced      Novice         1
+            32     yes  3.46  Advanced    Beginner         0
+            11      no  3.13  Advanced    Advanced         1
+            15     yes  4.00  Advanced    Advanced         1
+            36      no  3.00  Advanced      Novice         0
+        """
+        # Validating Arguments
+        arg_type_matrix = []
+        arg_type_matrix.append(["name", name, False, (str), True])
+        _Validators._validate_function_arguments(arg_type_matrix)
+
+        GarbageCollector._add_to_garbagecollector(name, TeradataConstants.TERADATA_VIEW)
+        UtilFuncs._create_view(name, self.show_query())
+
+    def materialize(self):
+        """
+        DESCRIPTION:
+            Method to materialize teradataml DataFrame into a database object.
+            Notes:
+                * DataFrames are materialized in either view/table/volatile table,
+                  which is decided and taken care by teradataml.
+                * If user wants to materialize object into specific database object
+                  such as table/volatile table, use 'to_sql()' or 'copy_to_sql()' or
+                  'fastload()' functions.
+                * Materialized object is garbage collected at the end of the session.
+
+        PARAMETERS:
+            None
+
+        RETURNS:
+            DataFrame
+
+        EXAMPLES:
+            >>> load_example_data("dataframe", "admissions_train")
+            >>> df = DataFrame("admissions_train")
+            >>> df
+               masters   gpa     stats programming  admitted
+            id
+            13      no  4.00  Advanced      Novice         1
+            26     yes  3.57  Advanced    Advanced         1
+            5       no  3.44    Novice      Novice         0
+            19     yes  1.98  Advanced    Advanced         0
+            15     yes  4.00  Advanced    Advanced         1
+            40     yes  3.95    Novice    Beginner         0
+            7      yes  2.33    Novice      Novice         1
+            22     yes  3.46    Novice    Beginner         0
+            36      no  3.00  Advanced      Novice         0
+            38     yes  2.65  Advanced    Beginner         1
+
+            # Example 1: Perform operations on teradataml DataFrame
+            #            and materializeit in a database object.
+            >>> df2 = df.get([["id", "masters", "gpa"]])
+
+            # Initially table_name will be None.
+            >>> df2._table_name
+
+            >>> df2.materialize()
+               masters   gpa
+            id
+            15     yes  4.00
+            7      yes  2.33
+            22     yes  3.46
+            17      no  3.83
+            13      no  4.00
+            38     yes  2.65
+            26     yes  3.57
+            5       no  3.44
+            34     yes  3.85
+            40     yes  3.95
+
+            # After materialize(), view name will be assigned.
+            >>> df2._table_name
+            '"ALICE"."ml__select__172077355985236"'
+            >>>
+        """
+        self.__execute_node_and_set_table_name(self._nodeid, self._metaexpr)
+        return self
+
     @collect_queryband(queryband="DF_fillna")
     def fillna(self, value=None, columns=None, literal_value=False):
         """
@@ -5017,7 +5150,7 @@ class DataFrame():
                     'median', 'var'
 
                 Acceptable formats for function(s) are
-                    string, dictionary or list of strings/functions.
+                    string, dictionary, list of strings/functions/ColumnExpression or ColumnExpression.
 
                 Accepted combinations are:
                     1. String function name
@@ -5025,12 +5158,57 @@ class DataFrame():
                     3. Dictionary containing column name as key and
                        aggregate function name (string or list of
                        strings) as value
+                    4. ColumnExpression built using the aggregate functions. 
+                    5. List of ColumnExpression built using the aggregate functions.
+
+                Note:
+                * The name of the output columns are generated based on aggregate functions and column names.
+                    For Example, 
+                    1. "func" passed as a string. 
+                        >>> df.agg('mean')
+                        Assume that the column names of the dataframe are employee_no, first_name, marks, dob, joined_date.
+                        After the above operation, the output column names are: 
+                          mean_employee_no, mean_marks, mean_dob, mean_joined_date 
+
+                    2. "func" passed as a list of string functions.
+                        >>> df.agg(['min', 'sum'])
+                        Assume that the column names of the dataframe are employee_no, first_name, marks, dob, joined_date.
+                        After the above operation, the output column names are:
+                          min_employee_no, sum_employee_no, min_first_name, min_marks, sum_marks, min_dob, min_joined_date
+
+                    3. "func" passed as a dictionary containing column name as key and aggregate function name as value. 
+                        >>> df.agg({'employee_no' : ['min', 'sum', 'var'], 'first_name' : ['min']})
+                        Output column names after the above operation are:
+                          min_employee_no, sum_employee_no, var_employee_no, min_first_name
+
+                    4. "func" passed as a ColumnExpression built using the aggregate functions.
+                        >>> df.agg(df.first_name.count())
+                        Output column name after the above operation is:
+                          count(first_name)
+
+                    5. "func" passed as a list of ColumnExpression built using the aggregate functions.
+                        >>> df.agg([df.employee_no.min(), df.first_name.count()])
+                        Output column names after the above operation are:
+                          min(employee_no), count(first_name)
+
+                * On ColumnExpression or list of ColumnExpression alias() can be used to 
+                  return the output columns with aliased name.
+                    For Example,
+                    >>> df.agg(df.first_name.count().alias("total_names"))
+                    Output column name after the above operation is:
+                      total_names
+
+                    >>> df.agg([df.joined_date.min().alias("min_date"), df.first_name.count().alias("total_names")])
+                    Output column names after the above operation are:
+                      min_date, total_names
+
 
         RETURNS:
             teradataml DataFrame object with operations
             mentioned in parameter 'func' performed on specified
             columns.
 
+
         RAISES:
             TeradataMLException
             1. TDMLDF_AGGREGATE_FAILED - If operations on given columns
@@ -5072,8 +5250,8 @@ class DataFrame():
                 valid datatype.
 
                 Possible error message:
-                Invalid type(s) passed to argument 'func', should be:"\
-                             "['str', 'list', 'dict'].
+                Invalid type(s) passed to argument 'func', should be:
+                ['str, dict, ColumnExpression or list of values of type(s): str, ColumnExpression'].
 
         EXAMPLES :
             # Load the data to run the example.
@@ -5090,21 +5268,49 @@ class DataFrame():
             112               None  None  None    18/12/05
             >>>
 
-            # Dictionary of column names to string function/list of string functions as parameter.
+            # Get the minimum, sum and variance of employee number and minimum and mean of name,
+            # by passing dictionary of column names to string function/list of string functions as parameter.
             >>> df.agg({'employee_no' : ['min', 'sum', 'var'], 'first_name' : ['min', 'mean']})
-                  min_employee_no sum_employee_no  var_employee_no min_first_name
-                0             100             313        44.333333           abcd
+              min_employee_no sum_employee_no  var_employee_no min_first_name
+            0             100             313        44.333333           abcd
 
-            # List of string functions as parameter.
+            # Get the minimum and sum of all the columns in the dataframe,
+            # by passing list of string functions as parameter.
             >>> df.agg(['min', 'sum'])
-                  min_employee_no sum_employee_no min_first_name min_marks sum_marks min_dob min_joined_date
-                0             100             313           abcd      None      None    None      1902-05-12
+              min_employee_no sum_employee_no min_first_name min_marks sum_marks min_dob min_joined_date
+            0             100             313           abcd      None      None    None      1902-05-12
 
-            # A string function as parameter.
+            # Get the mean of all the columns in the dataframe, by passing string function as parameter.
             >>> df.agg('mean')
                mean_employee_no mean_marks mean_dob mean_joined_date
             0        104.333333       None     None         60/12/04
 
+            # Get the total names in the dataframe, by running count() on the "first_name"
+            # and passing ColumnExpression as parameter.
+            >>> df.agg(df.first_name.count())
+               count(first_name)
+            0                  2
+
+            # Get the minimum of joining date and total of names in the dataframe, 
+            # by running min() on joined_date and count() on the "first_name"
+            # and passing list of ColumnExpression as parameter.
+            >>> df.agg([df.employee_no.min(), df.first_name.count()])
+               min(employee_no)  count(first_name)
+            0               100                  2
+
+            # Get the total names in the dataframe, by running count() on the "first_name" and
+            # use alias() to have the output column named as "total_names".
+            >>> df.agg(df.first_name.count().alias("total_names"))
+               total_names
+            0            2
+
+            # Get the minimum of joining date and total names in the dataframe, 
+            # by running min() on joined_date and count() on the "first_name" and 
+            # use alias() to have the output column named as "min_date" and "total_names".
+            >>> df.agg([df.joined_date.min().alias("min_date"), df.first_name.count().alias("total_names")])
+               min_date  total_names
+            0  02/12/05            2
+
             # Select only subset of columns from the DataFrame.
             >>> df1 = df.select(['employee_no', 'first_name', 'joined_date'])
 
@@ -5145,9 +5351,9 @@ class DataFrame():
             raise TeradataMlException(Messages.get_message(MessageCodes.MISSING_ARGS, "func"),
                                       MessageCodes.MISSING_ARGS)
 
-        if not isinstance(func, str) and not isinstance(func, list) and not isinstance(func, dict):
+        if not isinstance(func, (str, list, dict, ColumnExpression)):
             raise TeradataMlException(Messages.get_message(MessageCodes.UNSUPPORTED_DATATYPE,
-                                                           'func', ['str', 'list', 'dict']),
+                                      'func', ['str, dict, ColumnExpression or list of values of type(s): str, ColumnExpression']),
                                       MessageCodes.UNSUPPORTED_DATATYPE)
 
         return self._get_dataframe_aggregate(func)
@@ -5169,6 +5375,8 @@ class DataFrame():
                     3. Dictionary containing column name as key and
                        aggregate function name (string or list of
                        strings) as value
+                    4. ColumnExpression built using the aggregate functions. 
+                    5. List of ColumnExpression built using the aggregate functions.
 
             **kwargs: Keyword arguments. Mainly used for Time Series Aggragates.
 
@@ -5345,7 +5553,9 @@ class DataFrame():
             result = self._check_numeric_overflow(agg_df)
         """
         try:
-            repr(result_df)
+            # Printing the DF will actually run underlying select query and
+            # will brought up numeric overflow if any. Only materializing won't work.
+            print(result_df)
             return False
         except TeradataMlException as tme:
             if "Numeric overflow occurred during computation" in str(tme):
@@ -5481,18 +5691,73 @@ class DataFrame():
         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 not self._table_name:
+            if not self._aed_query:
+                self.__generate_aed_query()
+            # TODO: Check the length of query and if it fails, create a view in catch block.
+            # Address in this JIRA: https://teradata-pe.atlassian.net/browse/ELE-6922
+            query = repr(self._metaexpr) + ' FROM ( ' + self._aed_query + ' ) as temp_table'
+        else:
+            query = repr(self._metaexpr) + ' FROM ' + self._table_name
 
         if self._orderby is not None:
             query += ' ORDER BY ' + self._orderby
 
+        query += ';'
         # 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
 
+    def __generate_aed_query(self, full_query=False):
+        """
+        DESCRIPTION:
+            Internal function to return underlying SQL for the teradataml
+            DataFrame. It is the same SQL that is used to view the data for
+            a teradataml DataFrame.
+
+        PARAMETERS:
+            full_query:
+                Optional Argument.
+                Specifies if the complete query for the dataframe should be returned.
+                When this parameter is set to True, query for the dataframe is returned
+                with respect to the base dataframe's table (from_table() or from_query())
+                or from the output tables of analytical functions (if there are any in the
+                workflow). This query may or may not be directly used to retrieve data
+                for the dataframe upon which the function is called.
+                When this parameter is not used, string returned is the query already used
+                or will be used to retrieve data for the teradataml DataFrame.
+                Default Value: False
+                Types: bool
+
+        RETURNS:
+            String representing the underlying SQL query for the teradataml DataFrame.
+
+        RAISES:
+            None.
+
+        EXAMPLES:
+            self.__generate_aed_query()
+        """
+        # Run aed call only when _aed_query is None or
+        # the type of current stored query (full/short) is not matching
+        # with asked query type.
+        if (not self._aed_query) or (not self._is_full_query == full_query):
+            node_id = self._nodeid
+
+            if isinstance(self, (DataFrameGroupBy, DataFrameGroupByTime)):
+                # If dataframe is either of type groupby or groupbytime
+                # then get its parent dataframe nodeid and return queries
+                # for the same
+                node_id = self._aed_utils._aed_get_parent_nodeids(self._nodeid)[0]
+
+            queries = self._aed_utils._aed_show_query(node_id, query_with_reference_to_top=full_query)
+            # Store query and type of query in class attributes to avoid future runs.
+            self._aed_query = queries[0][0]
+            self._is_full_query = full_query
+
+        return self._aed_query
+
     @collect_queryband(queryband="DF_select")
     def select(self, select_expression):
         """
@@ -7032,6 +7297,97 @@ class DataFrame():
             if function_name is None or function_name in VANTAGE_FUNCTION_ARGTYPE_DEPENDENT_MAPPER:
                 self.__execute_node_and_set_table_name(self._nodeid)
                 return True
+            
+    def _assign_udf(self, udf_expr):
+        """
+        DESCRIPTION:
+            Internal function for DataFrame.assign() to execute the udf using 
+            Script Table Operator and create new column for teradataml DataFrame.
+
+        PARAMETER:
+            udf_expr:
+                Required Argument.
+                Specifies a dictionary of column name to UDF expressions.
+                Types: dict
+
+        RETURNS:
+            teradataml DataFrame
+
+        RAISES:
+            None.
+
+        EXAMPLES:
+            self._assign_udf(udf_expr)
+        """
+
+        df = self
+        env_name = None
+        # Create a dictionary of env_name to list of output columns to be run on that env.
+        env_mapper = OrderedDict()
+
+        exec_mode = 'REMOTE' if UtilFuncs._is_lake() else 'IN-DB'
+        if exec_mode == 'REMOTE':
+            if _InternalBuffer.get("auth_token") is None:
+                raise TeradataMlException(Messages.get_message(
+                MessageCodes.FUNC_EXECUTION_FAILED, "'udf'", 'Authentication token is required to run udf. Set token using set_auth_token().'),
+                                      MessageCodes.FUNC_EXECUTION_FAILED)
+            else: 
+                for colname, col in udf_expr.items():
+                    env_name = UtilFuncs._get_env_name(col)
+                    # Store the env_name and its corresponding output column   
+                    if env_name in env_mapper:
+                        env_mapper[env_name].append(colname)
+                    else:
+                        env_mapper[env_name] = [colname]
+        else:
+            env_mapper[env_name] = udf_expr.keys()
+            
+        for env_name, cols in env_mapper.items():
+            # Create a dictionary of output columns to column type.
+            returns = OrderedDict([(column.name, column.type) for column in df._metaexpr.c])
+            # Store the udf functions
+            user_function = []
+            # Create a dictionary of output column name to udf name
+            columns_definitions = {}
+            # Create a dictionary of output column name to udf arguments
+            function_args = {}
+            for colname, col in udf_expr.items():
+                delimiter = col._delimiter
+                quotechar = col._quotechar
+                if colname in cols:
+                    user_function.append(col._udf)
+                    function_args[colname] = col._udf_args if col._udf_args else ()
+                    returns[colname] = col.type
+                    columns_definitions[colname] = col._udf.__name__
+
+            tbl_operators = _TableOperatorUtils([],
+                                                df,
+                                                "udf",
+                                                user_function,
+                                                exec_mode,
+                                                chunk_size=None,
+                                                returns=returns,
+                                                delimiter=delimiter,
+                                                quotechar=quotechar,
+                                                num_rows=1,
+                                                auth=None,
+                                                data_partition_column=None,
+                                                data_hash_column=None,
+                                                data_order_column=None,
+                                                is_local_order=None,
+                                                nulls_first=None,
+                                                sort_ascending=None,
+                                                charset=None,
+                                                env_name = env_name,
+                                                style = "csv",
+                                                function_args=function_args,
+                                                columns_definitions=columns_definitions,
+                                                output_type_converters={
+                                                    col_name: _Dtypes._teradata_type_to_python_type(col_type)
+                                                    for col_name, col_type in returns.items()})
+
+            df = tbl_operators.execute()
+        return df
 
     @collect_queryband(queryband="DF_assign")
     def assign(self, drop_columns=False, **kwargs):
@@ -7043,10 +7399,12 @@ class DataFrame():
             drop_columns:
                 Optional Argument.
                 If True, drop columns that are not specified in assign.
-                Note:
-                    When DataFrame.assign() is run on DataFrame.groupby(), this argument
-                    is ignored. In such cases, all columns are dropped and only new columns
-                    and grouping columns are returned.
+                Notes:
+                    1. When DataFrame.assign() is run on DataFrame.groupby(), this argument
+                       is ignored. In such cases, all columns are dropped and only new columns
+                       and grouping columns are returned.
+                    2. Argument is ignored for UDF functions.
+
                 Default Value: False
                 Types: bool
 
@@ -7062,6 +7420,7 @@ class DataFrame():
                     * SQLAlchemy ClauseElements.
                       (See teradataml extension with SQLAlchemy in teradataml User Guide
                        and Function reference guide for more details)
+                    * Function - udf.
 
 
         RETURNS:
@@ -7087,6 +7446,16 @@ class DataFrame():
                used, but the column used in such function must be a part of group by columns.
                See examples for teradataml extension with SQLAlchemy on using various
                functions with DataFrame.assign().
+             6. UDF expressions can run on both Vantage Cloud Lake leveraging Apply Table Operator
+               of Open Analytics Framework and Enterprise leveraging Vantage's Script Table Operator.
+             7. One can pass both regular expressions and udf expressions to this API.
+               However, regular expressions are computed first followed by udf expressions.
+               Hence the order of columns also maintained in same order.
+               Look at Example 18 to understand more.
+             8. While passing multiple udf expressions, one can not pass one column output
+               as another column input in the same ``assign`` call.
+             9. If user pass multiple udf expressions, delimiter and quotechar specified in 
+               last udf expression are considered for processing.
 
         RAISES:
              1. ValueError - When a callable is passed as a value, or columns from different
@@ -7348,6 +7717,134 @@ class DataFrame():
             1  Advanced       2.886226  3.508750     84.21
             2    Novice       6.377775  3.559091     39.15
             >>>
+
+            #
+            # Executing user defined function (UDF) with assign()
+            #
+            # Example 15: Create two user defined functions to 'to_upper' and 'sum',
+            #            'to_upper' to get the values in 'accounts' to upper case and 
+            #            'sum' to add length of string values in column 'accounts' 
+            #             with column 'Feb' and store the result in Integer type column.
+            >>> @udf
+            ... def to_upper(s):
+            ...     if s is not None:
+            ...         return s.upper()
+            >>>
+            >>> from teradatasqlalchemy.types import INTEGER
+            >>> @udf(returns=INTEGER()) 
+            ... def sum(x, y):
+            ...     return len(x)+y
+            >>>
+            # Assign both Column Expressions returned by user defined functions
+            # to the DataFrame.
+            >>> res = df.assign(upper_stats = to_upper('accounts'), len_sum = sum('accounts', 'Feb'))
+            >>> res
+                        Feb    Jan    Mar    Apr  datetime upper_stats  len_sum
+            accounts                                                             
+            Blue Inc     90.0   50.0   95.0  101.0  17/01/04    BLUE INC       98
+            Red Inc     200.0  150.0  140.0    NaN  17/01/04     RED INC      207
+            Yellow Inc   90.0    NaN    NaN    NaN  17/01/04  YELLOW INC      100
+            Jones LLC   200.0  150.0  140.0  180.0  17/01/04   JONES LLC      209
+            Orange Inc  210.0    NaN    NaN  250.0  17/01/04  ORANGE INC      220
+            Alpha Co    210.0  200.0  215.0  250.0  17/01/04    ALPHA CO      218
+            >>>
+
+            # Example 16: Create a user defined function to add 4 to the 'datetime' column
+            #             and store the result in DATE type column.
+            >>> from teradatasqlalchemy.types import DATE
+            >>> import datetime
+            >>> @udf(returns=DATE())
+            ... def add_date(x, y):
+            ...     return (datetime.datetime.strptime(x, "%y/%m/%d")+datetime.timedelta(y)).strftime("%y/%m/%d")
+            >>>
+            # Assign the Column Expression returned by user defined function
+            # to the DataFrame.
+            >>> res = df.assign(new_date = add_date('datetime', 4))
+            >>> res
+                            Feb    Jan    Mar    Apr  datetime  new_date
+            accounts                                                  
+            Alpha Co    210.0  200.0  215.0  250.0  17/01/04  17/01/08
+            Blue Inc     90.0   50.0   95.0  101.0  17/01/04  17/01/08
+            Jones LLC   200.0  150.0  140.0  180.0  17/01/04  17/01/08
+            Orange Inc  210.0    NaN    NaN  250.0  17/01/04  17/01/08
+            Yellow Inc   90.0    NaN    NaN    NaN  17/01/04  17/01/08
+            Red Inc     200.0  150.0  140.0    NaN  17/01/04  17/01/08
+            >>>
+
+            # Example 17: Create a user defined functions to 'to_upper' to get
+            #             the values in 'accounts' to upper case and create a
+            #             new column with a string literal value.
+            >>> @udf
+            ... def to_upper(s):
+            ...     if s is not None:
+            ...         return s.upper()
+            >>>
+            # Assign both expressions to the DataFrame.
+            >>> res = df.assign(upper_stats = to_upper('accounts'), new_col = 'string')
+            >>> res
+                          Feb    Jan    Mar    Apr  datetime new_col upper_stats
+            accounts                                                            
+            Alpha Co    210.0  200.0  215.0  250.0  17/01/04  string    ALPHA CO
+            Blue Inc     90.0   50.0   95.0  101.0  17/01/04  string    BLUE INC
+            Yellow Inc   90.0    NaN    NaN    NaN  17/01/04  string  YELLOW INC
+            Jones LLC   200.0  150.0  140.0  180.0  17/01/04  string   JONES LLC
+            Red Inc     200.0  150.0  140.0    NaN  17/01/04  string     RED INC
+            Orange Inc  210.0    NaN    NaN  250.0  17/01/04  string  ORANGE INC
+            >>>
+
+            # Example 18: Create two user defined functions to 'to_upper' and 'sum'
+            #             and create new columns with string literal value and
+            #             arithmetic operation on column 'Feb'.
+            >>> @udf
+            ... def to_upper(s):
+            ...     if s is not None:
+            ...         return s.upper()
+            >>>
+            >>> from teradatasqlalchemy.types import INTEGER
+            >>> @udf(returns=INTEGER()) 
+            ... def sum(x, y):
+            ...     return len(x)+y
+            >>>
+            # Assign all expressions to the DataFrame.
+            >>> res = df.assign(upper_stats = to_upper('accounts'),new_col = 'abc', 
+            ...                 len_sum = sum('accounts', 'Feb'), col_sum = df.Feb+1)
+            >>> res
+                          Feb    Jan    Mar    Apr  datetime  col_sum new_col upper_stats  len_sum
+            accounts                                                                              
+            Blue Inc     90.0   50.0   95.0  101.0  17/01/04     91.0     abc    BLUE INC       98
+            Alpha Co    210.0  200.0  215.0  250.0  17/01/04    211.0     abc    ALPHA CO      218
+            Jones LLC   200.0  150.0  140.0  180.0  17/01/04    201.0     abc   JONES LLC      209
+            Yellow Inc   90.0    NaN    NaN    NaN  17/01/04     91.0     abc  YELLOW INC      100
+            Orange Inc  210.0    NaN    NaN  250.0  17/01/04    211.0     abc  ORANGE INC      220
+            Red Inc     200.0  150.0  140.0    NaN  17/01/04    201.0     abc     RED INC      207
+            >>>
+
+            # Example 19: Convert the values is 'accounts' column to upper case using a user 
+            #             defined function on Vantage Cloud Lake.
+            # Create a Python 3.10.5 environment with given name and description in Vantage.
+            >>> env = create_env('test_udf', 'python_3.10.5', 'Test environment for UDF')
+            User environment 'test_udf' created.
+            >>>
+            # Create a user defined functions to 'to_upper' to get the values in upper case 
+            # and pass the user env to run it on.
+            >>> from teradataml.dataframe.functions import udf
+            >>> @udf(env_name = env)
+            ... def to_upper(s):
+            ...     if s is not None:
+            ...         return s.upper()
+            >>>
+            # Assign the Column Expression returned by user defined function
+            # to the DataFrame.
+            >>> df.assign(upper_stats = to_upper('accounts'))
+                          Feb    Jan    Mar    Apr  datetime upper_stats
+            accounts                                                    
+            Alpha Co    210.0  200.0  215.0  250.0  17/01/04    ALPHA CO
+            Blue Inc     90.0   50.0   95.0  101.0  17/01/04    BLUE INC
+            Yellow Inc   90.0    NaN    NaN    NaN  17/01/04  YELLOW INC
+            Jones LLC   200.0  150.0  140.0  180.0  17/01/04   JONES LLC
+            Orange Inc  210.0    NaN    NaN  250.0  17/01/04  ORANGE INC
+            Red Inc     200.0  150.0  140.0    NaN  17/01/04     RED INC
+            >>>
         """
         # Argument validations
         awu_matrix = []
@@ -7393,13 +7890,35 @@ class DataFrame():
             msg = Messages.get_message(MessageCodes.TDMLDF_INFO_ERROR)
             raise TeradataMlException(msg, MessageCodes.TDMLDF_INFO_ERROR)
 
-        try:
-            (new_meta, new_nodeid) = self._generate_assign_metaexpr_aed_nodeid(drop_columns, **kwargs)
-            return self._create_dataframe_from_node(new_nodeid, new_meta, self._index_label)
-        except Exception as err:
-            errcode = MessageCodes.TDMLDF_INFO_ERROR
-            msg = Messages.get_message(MessageCodes.TDMLDF_INFO_ERROR)
-            raise TeradataMlException(msg, errcode) from err
+        # Create a dictionary of column name to udf expressions and 
+        # column name to normal/regular expressions.
+        udf_expr = {}
+        regular_expr = {}
+        for colname, col in kwargs.items():
+            # If value passed in kwargs is a ColumnExpression and is a udf, store it.
+            if isinstance(col, ColumnExpression) and col._udf:
+                udf_expr[colname] = col
+            else:
+                regular_expr[colname] = col
+        df = self
+
+        # If kwargs contains both regular and udf expressions, first create new columns 
+        # from normal/regular expressions then on the output dataframe create new columns
+        # from udf expression.
+        if bool(regular_expr):
+            try:
+                (new_meta, new_nodeid) = df._generate_assign_metaexpr_aed_nodeid(drop_columns, **regular_expr)
+                df = df._create_dataframe_from_node(new_nodeid, new_meta, df._index_label)
+            except Exception as err:
+                errcode = MessageCodes.TDMLDF_INFO_ERROR
+                msg = Messages.get_message(MessageCodes.TDMLDF_INFO_ERROR)
+                raise TeradataMlException(msg, errcode) from err
+            
+        if bool(udf_expr):
+            df = df._assign_udf(udf_expr)
+
+        return df
+
 
     @collect_queryband(queryband="DF_get")
     def get(self, key):
@@ -10013,9 +10532,10 @@ class DataFrame():
                 case_when_then = {}
                 list_of_fracs = frac
 
-                # When stratify column is passed for sample then perform TrainTestSplit 
-                # for data sampling. 
-                if stratify_column is not None:
+                # When stratify column is passed for sample or when seed is passed for 
+                # reproducibilty of result then 
+                # perform TrainTestSplit for data sampling. 
+                if stratify_column is not None or seed is not None:
                     # Local import TrainTestSplit function.
                     from teradataml.analytics.sqle import TrainTestSplit
 
@@ -10029,7 +10549,16 @@ class DataFrame():
                                                         train_size=list_of_fracs[0],
                                                         test_size=list_of_fracs[1],
                                                         stratify_column=stratify_column,
-                                                        seed=seed)
+                                                        seed=seed,
+                                                        persist=True,
+                                                        display_table_name=False)
+                    
+                    # Retrieve the table name from TrainTestSplit_out object.
+                    table_name = TrainTestSplit_out.result._table_name
+
+                    # Add the table to garbage collector.
+                    table_added = GarbageCollector._add_to_garbagecollector(table_name)
+
                     # Retrieve the sampled result and updated the column name and values
                     # for backward compatibility.
                     _sampled_df = TrainTestSplit_out.result
@@ -10133,10 +10662,10 @@ class DataFrame():
 
             # 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.
+            # 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)
+            df._table_name = df_utils._execute_node_return_db_object_name(sample_node_id, new_metaexpr)
 
             return df
 
@@ -10267,26 +10796,14 @@ class DataFrame():
              where admitted > 0) as temp_table SAMPLE 0.9'
 
         """
+        # Argument validations
+        awu_matrix = []
+        awu_matrix.append(["full_query", full_query, False, (bool)])
+        # Validate argument types
+        _Validators._validate_function_arguments(awu_matrix)
 
         try:
-            # Argument validations
-            awu_matrix = []
-            awu_matrix.append(["full_query", full_query, False, (bool)])
-            # Validate argument types
-            _Validators._validate_function_arguments(awu_matrix)
-
-            node_id = self._nodeid
-
-            if isinstance(self, (DataFrameGroupBy, DataFrameGroupByTime)):
-                # If dataframe is either of type groupby or groupbytime 
-                # then get it's parent dataframe nodeid and return queries 
-                # for the same
-                node_id = self._aed_utils._aed_get_parent_nodeids(self._nodeid)[0]
-
-            queries = self._aed_utils._aed_show_query(node_id, query_with_reference_to_top=full_query)
-
-            return queries[0][0]
-
+            return self.__generate_aed_query(full_query)
         except TeradataMlException:
             raise
 
@@ -10296,7 +10813,7 @@ class DataFrame():
         except Exception as err:
             errcode = MessageCodes.TDMLDF_INFO_ERROR
             msg = Messages.get_message(errcode)
-            raise TeradataMlException(msg, errcode) from err
+            raise TeradataMlException(msg, errcode) from err        
 
     @collect_queryband(queryband="DF_mapRow")
     def map_row(self,
@@ -13755,7 +14272,7 @@ class DataFrame():
                 Types: int OR NoneType
 
         RETURNS:
-            iterator, an object to iterate over namedtuples for each row in the DataFrame.
+            iterator, an object to iterate over row in the DataFrame.
 
         RAISES:
             None
@@ -13804,9 +14321,10 @@ class DataFrame():
         cur = execute_sql(query)
 
         if name:
+            columns = [column[0] for column in cur.description]
             for rec in cur:
-                Row = namedtuple(name, [column[0] for column in cur.description])
-                yield Row(*rec)
+                row = _Row(columns=columns, values=rec)
+                yield row
         else:
             for rec in cur:
                 yield rec
@@ -16626,7 +17144,7 @@ class _TDUAF(DataFrame):
         # UAF Functions do not accept double quotes.
         db_name = UtilFuncs._extract_db_name(table_name)
         if db_name:
-            table_name = "{}.{}".format(db_name, UtilFuncs._extract_table_name(table_name))
+            table_name = '"{}"."{}"'.format(db_name, UtilFuncs._extract_table_name(table_name))
         else:
             table_name = UtilFuncs._extract_table_name(table_name)