teradataml 20.0.0.1__py3-none-any.whl → 20.0.0.3__py3-none-any.whl

teradataml/dataframe/dataframe.py

@@ -19,6 +19,7 @@ import pandas as pd
 import re
 import sqlalchemy
 import sys
+import urllib.parse
 import teradataml.context.context as tdmlctx
 
 from collections import OrderedDict, namedtuple
@@ -42,7 +43,9 @@ 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.dbutils.dbutils import list_td_reserved_keywords
 from teradataml.plot.plot import _Plot
 from teradataml.scriptmgmt.UserEnv import UserEnv
 from teradataml.utils.dtypes import _Dtypes, _ListOf, _TupleOf
@@ -53,7 +56,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
+from teradataml.telemetry_utils.queryband import collect_queryband
+from teradataml.options.configure import configure
+from teradataml.utils.internal_buffer import _InternalBuffer
+from teradataml.common.constants import OutputStyle
 
 # TODO use logger when available on master branch
 # logger = teradatapylog.getLogger()
@@ -151,6 +157,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
@@ -221,7 +232,7 @@ class DataFrame():
 
                 self._nodeid = self._aed_utils._aed_query(self._query, temp_table_name)
             else:
-                if inspect.stack()[1][3] not in ['_from_node', '__init__']:
+                if inspect.stack()[1][3] not in ['_from_node', '__init__', 'alias']:
                     raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_CREATE_FAIL),
                                               MessageCodes.TDMLDF_CREATE_FAIL)
 
@@ -233,6 +244,7 @@ class DataFrame():
             self._iloc = _LocationIndexer(self, integer_indexing=True)
             self.__data = None
             self.__data_columns = None
+            self._alias = None
 
         except TeradataMlException:
             raise
@@ -242,6 +254,100 @@ class DataFrame():
             raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_CREATE_FAIL),
                                       MessageCodes.TDMLDF_CREATE_FAIL) from err
 
+    @property
+    def db_object_name(self):
+        """
+        DESCRIPTION:
+            Get the underlying database object name, on which DataFrame is
+            created.
+
+        RETURNS:
+            str representing object name of DataFrame
+
+        EXAMPLES:
+            >>> load_example_data("dataframe", "sales")
+            >>> df = DataFrame('sales')
+            >>> df.db_object_name
+            '"sales"'
+        """
+        if self._table_name is not None:
+            return self._table_name
+        else:
+            msg = "Object name is available once DataFrame is materialized. " \
+                  "Use DataFrame.materialize() to materialize DataFrame."
+            print(msg)
+
+    def alias(self, alias_name):
+        """
+        DESCRIPTION:
+            Method to create an aliased teradataml DataFrame.
+            Note:
+                * This method is recommended to be used before performing
+                  self join using DataFrame's join() API.
+
+        PARAMETERS:
+            alias_name:
+                Required Argument.
+                Specifies the alias name to be assigned to a teradataml DataFrame.
+                Types: str
+
+        RETURNS:
+            teradataml 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: Create an alias of teradataml DataFrame.
+
+            >>> df2 = df.alias("adm_trn")
+
+            # Print aliased DataFrame.
+            >>> df2
+               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
+        """
+        arg_info_matrix = [["alias_name", alias_name, False, (str), True]]
+        _Validators._validate_function_arguments(arg_info_matrix)
+        try:
+            alias_df = self._from_node(self._nodeid, self._metaexpr, self._index_label,
+                                              reuse_metaexpr=False)
+            # Assigning self attributes to newly created alias dataframe.
+            alias_df._table_name = self._table_name
+            alias_df._index = self._index
+            alias_df._index_label = self._index_label
+            setattr(alias_df._metaexpr.t, "table_alias", alias_name)
+            alias_df._alias = alias_name
+            return alias_df
+        except Exception as err:
+            error_code = MessageCodes.EXECUTION_FAILED
+            error_msg = Messages.get_message(
+                error_code, "create alias dataFrame", '{}'.format(str(err)))
+            raise TeradataMlException(error_msg, error_code)
+
     @classmethod
     @collect_queryband(queryband="DF_fromTable")
     def from_table(cls, table_name, index=True, index_label=None):
@@ -356,7 +462,7 @@ class DataFrame():
         return cls(index=index, index_label=index_label, query=query, materialize=materialize)
 
     @classmethod
-    def _from_node(cls, nodeid, metaexpr, index_label=None, undropped_index=None):
+    def _from_node(cls, nodeid, metaexpr, index_label=None, undropped_index=None, reuse_metaexpr=True):
         """
         Private class method for creating a DataFrame from a nodeid and parent metadata.
 
@@ -377,6 +483,12 @@ class DataFrame():
                 Optional Argument.
                 List specifying index column(s) to be retained as columns for printing.
 
+            reuse_metaexpr:
+                Optional Argument.
+                Specifies the flag to decide whether to use same _MetaExpression object or not.
+                Default Value: True
+                Types: bool
+
         EXAMPLES:
             from teradataml.dataframe.dataframe import DataFrame
             df = DataFrame._from_node(1234, metaexpr)
@@ -392,32 +504,171 @@ class DataFrame():
         df = cls()
         df._nodeid = nodeid
         df._source_type = SourceType.TABLE.value
-        df._get_metadata_from_metaexpr(metaexpr)
+
+        if not reuse_metaexpr:
+            # Create new _MetaExpression object using reference metaExpression
+            # for newly created DataFrame.
+            df._metaexpr = UtilFuncs._get_metaexpr_using_parent_metaexpr(nodeid, metaexpr)
+            # When metaexpression is created using only column information from parent DataFrame,
+            # underlying SQLAlchemy table is created with '' string as Table name.
+            # Assign name from reference mataexpression here.
+            df._metaexpr.t.name = metaexpr.t.name
+            # Populate corresponding information into newly created DataFrame object
+            # using newly created metaExpression.
+            df._get_metadata_from_metaexpr(df._metaexpr)
+        else:
+            # Populate corresponding information into newly created DataFrame object
+            # using reference metaExpression.
+            df._get_metadata_from_metaexpr(metaexpr)
 
         if isinstance(index_label, str):
             index_label = [index_label]
 
-        if index_label is not None and all(elem in [col.name for col in metaexpr.c] for elem in index_label):
+        if index_label is not None and all(elem in [col.name for col in df._metaexpr.c] for elem in index_label):
             df._index_label = index_label
         elif index_label is not None and all(UtilFuncs._teradata_quote_arg(elem, "\"", False)
-                                             in [col.name for col in metaexpr.c] for elem in index_label):
+                                             in [col.name for col in df._metaexpr.c] for elem in index_label):
             df._index_label = index_label
 
         # Set the flag suggesting that the _index_label is set,
-        # and that a database lookup wont be required even when it is None.
+        # and that a database lookup won't be required even when it is None.
         df._index_query_required = False
 
         if isinstance(undropped_index, str):
             undropped_index = [undropped_index]
 
-        if undropped_index is not None and all(elem in [col.name for col in metaexpr.c] for elem in undropped_index):
+        if undropped_index is not None and all(elem in [col.name for col in df._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):
+                                                 in [col.name for col in df._metaexpr.c] for elem in undropped_index):
             df._undropped_index = undropped_index
 
         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):
         """
@@ -657,7 +908,10 @@ class DataFrame():
         Private method for setting _metaexpr and retrieving column names and types.
 
         PARAMETERS:
-            metaexpr - Parent meta data (_MetaExpression object).
+            metaexpr:
+                Required Argument.
+                Specifies parent meta data (_MetaExpression object).
+                Types: _MetaExpression
 
         RETURNS:
             None
@@ -670,7 +924,8 @@ class DataFrame():
         self._column_names_and_types = []
         self._td_column_names_and_types = []
         self._td_column_names_and_sqlalchemy_types = {}
-        for col in metaexpr.c:
+
+        for col in self._metaexpr.c:
             if isinstance(col.type, sqlalchemy.sql.sqltypes.NullType):
                 tdtype = TeradataTypes.TD_NULL_TYPE.value
             else:
@@ -1934,7 +2189,7 @@ class DataFrame():
             else:
                 col_filters = col_names
 
-            col_filters_decode = ["decode(\"{}\", null, 0, 1)".format(col_name) for col_name in col_filters]
+            col_filters_decode = ["CASE WHEN \"{}\" IS NULL THEN 0 ELSE 1 END".format(col_name) for col_name in col_filters]
             fmt_filter = " + ".join(col_filters_decode)
 
             if thresh is not None:
@@ -5421,6 +5676,8 @@ class DataFrame():
             result = self._check_numeric_overflow(agg_df)
         """
         try:
+            # Printing the DF will actually run underlying select query and
+            # will brought up numeric overflow if any. Only materializing won't work.
             repr(result_df)
             return False
         except TeradataMlException as tme:
@@ -5557,18 +5814,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):
         """
@@ -5830,6 +6142,8 @@ class DataFrame():
                     * "open_sessions" specifies the number of Teradata data transfer
                       sessions to be opened for fastexport. This argument is only applicable
                       in fastexport mode.
+                    * Function returns the pandas dataframe with Decimal columns types as float instead of object.
+                      If user want datatype to be object, set argument "coerce_float" to False.
 
                 Notes:
                     1. For additional information about "coerce_float" and
@@ -6145,15 +6459,22 @@ class DataFrame():
             Supported join operators are =, ==, <, <=, >, >=, <> and != (= and <> operators are
             not supported when using DataFrame columns as operands).
 
-            Note:
-                1.  When multiple join conditions are given, they are joined using AND boolean
-                    operator. Other boolean operators are not supported.
-                2.  Nesting of join on conditions in column expressions using & and | is not
-                    supported. The example for unsupported nested join on conditions is:
-                    on = [(df1.a == df1.b) & (df1.c == df1.d)]
+            Notes:
+                1.  When multiple join conditions are given as a list string/ColumnExpression,
+                    they are joined using AND operator.
+                2.  Two or more on conditions can be combined using & and | operators
+                    and can be passed as single ColumnExpression.
+                    You can use (df1.a == df1.b) & (df1.c == df1.d) in place of
+                    [df1.a == df1.b, df1.c == df1.d].
+                3.  Two or more on conditions can not be combined using pythonic 'and'
+                    and 'or'.
+                    You can use (df1.a == df1.b) & (df1.c == df1.d) in place of
+                    [df1.a == df1.b and df1.c == df1.d].
+                4.  Performing self join using same DataFrame object in 'other'
+                    argument is not supported. In order to perform self join,
+                    first create aliased DataFrame using alias() API and pass it
+                    for 'other' argument. Refer to Example 10 in EXAMPLES section.
 
-                    You can use [df1.a == df1.b, df1.c == df1.d] in place of
-                    [(df1.a == df1.b) & (df1.c == df1.d)].
 
         PARAMETERS:
 
@@ -6181,15 +6502,20 @@ class DataFrame():
                   is the column of left dataframe df1 and col2 is the column of right
                   dataframe df2.
                   Examples:
-                    1. [df1.a == df2.a, df1.b == df2.b] indicates df1.a = df2.a and df1.b = df2.b.
-                    2. [df1.a == df2.b, df1.c == df2.d] indicates df1.a = df2.b and df1.c = df2.d.
-                    3. [df1.a <= df2.b and df1.c > df2.d] indicates df1.a <= df2.b and df1.c > df2.d.
-                    4. [df1.a < df2.b and df1.c >= df2.d] indicates df1.a < df2.b and df1.c >= df2.d.
+                    1. [df1.a == df2.a, df1.b == df2.b] indicates df1.a = df2.a AND df1.b = df2.b.
+                    2. [df1.a == df2.b, df1.c == df2.d] indicates df1.a = df2.b AND df1.c = df2.d.
+                    3. [df1.a <= df2.b & df1.c > df2.d] indicates df1.a <= df2.b AND df1.c > df2.d.
+                    4. [df1.a < df2.b | df1.c >= df2.d] indicates df1.a < df2.b OR df1.c >= df2.d.
                     5. df1.a != df2.b indicates df1.a != df2.b.
                 • The combination of both string comparisons and comparisons as column expressions.
                   Examples:
-                    1. ["a", df1.b == df2.b] indicates df1.a = df2.a and df1.b = df2.b.
-                    2. [df1.a <= df2.b, "c > d"] indicates df1.a <= df2.b and df1.c > df2.d.
+                    1. ["a", df1.b == df2.b] indicates df1.a = df2.a AND df1.b = df2.b.
+                    2. [df1.a <= df2.b, "c > d"] indicates df1.a <= df2.b AND df1.c > df2.d.
+                • ColumnExpressions containing FunctionExpressions which represent SQL functions
+                  invoked on DataFrame Columns.
+                  Examples:
+                    1. (df1.a.round(1) - df2.a.round(1)).mod(2.5) > 2
+                    2. df1.a.floor() - df2.b.floor() > 2
 
                 Types: str (or) ColumnExpression (or) List of strings(str) or ColumnExpressions
 
@@ -6211,7 +6537,7 @@ class DataFrame():
                 Specifies the suffix to be added to the right table columns.
                 Default Value: None.
                 Types: str
-            
+
             lprefix:
                 Optional Argument.
                 Specifies the prefix to be added to the left table columns.
@@ -6261,7 +6587,7 @@ class DataFrame():
             0       2       2  analytics      2.3      2.3    b  analytics    b
             1       1       1   teradata      1.3      1.3    a   teradata    a
 
-            # Example 2: One "on" argument condition is ColumnExpression and other is string having two 
+            # Example 2: One "on" argument condition is ColumnExpression and other is string having two
             #            columns with left outer join.
             >>> df1.join(df2, on = [df1.col2 == df2.col4,"col5 = col7"], how = "left", lprefix = "t1", rprefix = "t2")
               t1_col1 t2_col1       col2  t1_col3  t2_col3 col5       col4  col7
@@ -6275,7 +6601,7 @@ class DataFrame():
             0       2       2  analytics      2.3      2.3    b  analytics    b
             1       1       1   teradata      1.3      1.3    a   teradata    a
 
-            # Example 4: One "on" argument condition is ColumnExpression and other is string having two 
+            # Example 4: One "on" argument condition is ColumnExpression and other is string having two
             #            columns with full join.
             >>> df1.join(other = df2, on = ["col2=col4",df1.col5 == df2.col7], how = "full", lprefix = "t1", rprefix = "t2")
               t1_col1 t2_col1       col2  t1_col3  t2_col3  col5       col4  col7
@@ -6353,7 +6679,53 @@ class DataFrame():
             3         Beginner  Beginner    1   3.95      Beginner   3.70    Novice          0          1        no       yes
             3         Beginner  Beginner    2   3.76      Beginner   3.70    Novice          0          1        no       yes
             3         Beginner    Novice    3   3.70      Beginner   3.70    Novice          1          1        no        no
+
+            # Example 10: Perform self join using aliased DataFrame.
+            # Create an aliased DataFrame.
+            >>> lhs  = DataFrame("admissions_train").head(3).sort("id")
+            >>> rhs = lhs.alias("rhs")
+            # Use aliased DataFrame for self join.
+            >>> joined_df = lhs.join(other=rhs, how="cross", lprefix="l", rprefix="r")
+            >>> joined_df
+               l_id  r_id l_masters r_masters  l_gpa  r_gpa   l_stats   r_stats l_programming r_programming  l_admitted  r_admitted
+            0     1     3       yes        no   3.95   3.70  Beginner    Novice      Beginner      Beginner           0           1
+            1     2     2       yes       yes   3.76   3.76  Beginner  Beginner      Beginner      Beginner           0           0
+            2     2     3       yes        no   3.76   3.70  Beginner    Novice      Beginner      Beginner           0           1
+            3     3     1        no       yes   3.70   3.95    Novice  Beginner      Beginner      Beginner           1           0
+            4     3     3        no        no   3.70   3.70    Novice    Novice      Beginner      Beginner           1           1
+            5     3     2        no       yes   3.70   3.76    Novice  Beginner      Beginner      Beginner           1           0
+            6     2     1       yes       yes   3.76   3.95  Beginner  Beginner      Beginner      Beginner           0           0
+            7     1     2       yes       yes   3.95   3.76  Beginner  Beginner      Beginner      Beginner           0           0
+            8     1     1       yes       yes   3.95   3.95  Beginner  Beginner      Beginner      Beginner           0           0
+
+            # Example 11: Perform join with compound 'on' condition having
+            #             more than one binary operator.
+            >>> rhs_2 = lhs.assign(double_gpa=lhs.gpa * 2)
+            >>> joined_df_2 = lhs.join(rhs_2, on=rhs_2.double_gpa == lhs.gpa * 2, how="left", lprefix="l", rprefix="r")
+            >>> joined_df_2
+               l_id  r_id l_masters r_masters  l_gpa  r_gpa   l_stats   r_stats l_programming r_programming  l_admitted  r_admitted  double_gpa
+            0     3     3        no        no   3.70   3.70    Novice    Novice      Beginner      Beginner           1           1        7.40
+            1     2     2       yes       yes   3.76   3.76  Beginner  Beginner      Beginner      Beginner           0           0        7.52
+            2     1     1       yes       yes   3.95   3.95  Beginner  Beginner      Beginner      Beginner           0           0        7.90
+
+            # Example 12: Perform join on DataFrames with 'on' condition
+            #             having FunctionExpression.
+            >>> df = DataFrame("admissions_train")
+            >>> df2 = df.alias("rhs_df")
+            >>> joined_df_3 = df.join(df2, on=(df.gpa.round(1) - df2.gpa.round(1)).mod(2.5) > 2,
+            >>>                       how="inner", lprefix="l")
+            >>> joined_df_3.sort(["id", "l_id"])
+                l_id	id	l_masters	masters	 l_gpa	 gpa	 l_stats	   stats  l_programming	programming	l_admitted	admitted
+            0      1	24	      yes	     no	  3.95	1.87	Beginner	Advanced	   Beginner	     Novice	         0	       1
+            1     13	24	       no	     no	   4.0	1.87	Advanced	Advanced	     Novice	     Novice	         1	       1
+            2     15	24	      yes	     no	   4.0	1.87	Advanced	Advanced	   Advanced	     Novice	         1	       1
+            3     25	24	       no	     no	  3.96	1.87	Advanced	Advanced	   Advanced	     Novice	         1	       1
+            4     27	24	      yes	     no	  3.96	1.87	Advanced	Advanced	   Advanced	     Novice	         0	       1
+            5     29	24	      yes	     no	   4.0	1.87	  Novice	Advanced	   Beginner	     Novice          0	       1
+            6     40	24	     yes	     no	  3.95	1.87      Novice	Advanced	   Beginner	     Novice	         0	       1
+
         """
+
         # Argument validations
         awu_matrix = []
         awu_matrix.append(["other", other, False, (DataFrame)])
@@ -6367,17 +6739,11 @@ 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"
-        else:
-            laffix = lprefix
-            raffix = rprefix
-            affix_type = "prefix"
+        # If self and other DataFrames are pointing to same Table object,
+        # raise error.
+        if self._metaexpr.t is other._metaexpr.t:
+            raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_ALIAS_REQUIRED, "join"),
+                                      MessageCodes.TDMLDF_ALIAS_REQUIRED)
 
         how_lc = how.lower()
 
@@ -6395,12 +6761,33 @@ class DataFrame():
         for col in other.columns:
             other_columns_lower_actual_map[col.lower()] = col
 
-        for column in self_columns_lower_actual_map.keys():
-            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)
+        # Set the affix variables (laffix and raffix) with provided value(s)
+        # of lsuffix, rsuffix, lprefix and rprefix.
+        # Also set affix_type appropriately.
+        laffix = None
+        raffix = None
+        affix_type = None
+        if lsuffix is not None or rsuffix is not None:
+            laffix = lsuffix
+            raffix = rsuffix
+            affix_type = "suffix"
+        elif lprefix is not None or rprefix is not None:
+            laffix = lprefix
+            raffix = rprefix
+            affix_type = "prefix"
+
+        # Same column names can be present in two dataframes involved
+        # in join operation in below two cases:
+        # Case 1: Self join.
+        # Case 2: Two tables having common column names.
+        # In any case, at least one kind of affix is required to generate
+        # distinct column names in resultant table. Throw error if no affix
+        # is available.
+        if not set(self_columns_lower_actual_map.keys()).isdisjoint(other_columns_lower_actual_map.keys()):
+            if affix_type is None:
+                raise TeradataMlException(
+                    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:
@@ -6409,115 +6796,158 @@ class DataFrame():
                                      "'l{affix_type}' and 'r{affix_type}'".format(affix_type=affix_type)),
                 MessageCodes.TDMLDF_INVALID_TABLE_ALIAS)
 
-        if how_lc != "cross":
-            if isinstance(on, str) or isinstance(on, ColumnExpression):
-                on = [on]
-
-            all_join_conditions = []
-            invalid_join_conditions = []
-            # Forming join condition
-            for condition in on:
-                ori_condition = condition
-
-                if not isinstance(condition, (ColumnExpression, str)):
-                    invalid_join_conditions.append(condition)
-                    continue
-
-                # Process only when the on condition is string or a ColumnExpression
-                if isinstance(condition, ColumnExpression):
-                    columns = condition.original_column_expr
-                    condition = condition.compile()
-
-                for op in TeradataConstants.TERADATA_JOIN_OPERATORS.value:
-                    if op in condition:
-                        conditional_separator = op
-                        break
-                else:
-                    # If no join condition is mentioned, default is taken as equal.
-                    # If on is ['a'], then it is equal to 'df1.a = df2.a'
-                    columns = [condition, condition]
-                    condition = "{0} = {0}".format(condition)
-                    conditional_separator = "="
-
-                if isinstance(ori_condition, str):
-                    columns = [column.strip() for column in condition.split(sep=conditional_separator)
-                               if len(column) > 0]
-
-                if len(columns) != 2:
-                    invalid_join_conditions.append(condition)
-                else:
-                    left_col = self.__add_alias_to_column(columns[0], self, laffix if laffix is not None else "df1")
-                    right_col = self.__add_alias_to_column(columns[1], other, raffix if raffix is not None else "df2")
-                    if conditional_separator == "!=":
-                        # "!=" is python way of expressing 'not equal to'. "<>" is Teradata way of
-                        # expressing 'not equal to'. Adding support for "!=".
-                        conditional_separator = "<>"
-                    all_join_conditions.append('{0} {1} {2}'.format(left_col, conditional_separator, right_col))
-
-            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_condition = " and ".join(all_join_conditions)
-        else:
-            join_condition = ""
-
-        df1_columns_types = df_utils._get_required_columns_types_from_metaexpr(self._metaexpr)
-        df2_columns_types = df_utils._get_required_columns_types_from_metaexpr(other._metaexpr)
-
-        select_columns = []
-        new_metaexpr_columns_types = OrderedDict()
-
-        for column in self.columns:
-            if df_utils._check_column_exists(column.lower(), other_columns_lower_actual_map.keys()):
-                # Check if column found in other DataFrame has same case or different.
-                # Return the column name from the other DataFrame.
-                other_column = other_columns_lower_actual_map[column.lower()]
-
-                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))
-
-                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))
-
-                # 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,
-                                                    UtilFuncs._teradata_unquote_arg(df1_column_with_affix, "\""),
-                                                    column, df1_columns_types)
-
-                self.__add_column_type_item_to_dict(new_metaexpr_columns_types,
-                                                    UtilFuncs._teradata_unquote_arg(df2_column_with_affix, "\""),
-                                                    other_column, df2_columns_types)
-
+        try:
+            # Set an attribute named '_join_alias' to underlying SQLAlchemy table objects
+            # and use it as default alias for compiling.
+            setattr(self._metaexpr.t, "_join_alias", "lhs")
+            setattr(other._metaexpr.t, "_join_alias", "rhs")
+            lhs_alias = "lhs"
+            rhs_alias = "rhs"
+
+            # Step 1: Generate the on clause string.
+            if how_lc != "cross":
+                on = UtilFuncs._as_list(on)
+
+                all_join_conditions = []
+                invalid_join_conditions = []
+                # Forming join condition
+                for condition in on:
+                    # Process only when the on condition is either a string or a ColumnExpression.
+                    if not isinstance(condition, (ColumnExpression, str)):
+                        invalid_join_conditions.append(condition)
+                        continue
+
+                    # Generate final on clause string from string representation of condition.
+                    if isinstance(condition, str):
+                        # Process the string manually.
+                        # 1. Parse the string to get operator.
+                        for op in TeradataConstants.TERADATA_JOIN_OPERATORS.value:
+                            if op in condition:
+                                conditional_separator = op
+                                break
+                        else:
+                            # If no join condition is mentioned, then string represents the column.
+                            # In this case, default operator is taken as equal.
+                            # If on is ['a'], then it is equal to 'lhs.a = rhs.a'
+                            columns = [condition, condition]
+                            condition = "{0} = {0}".format(condition)
+                            conditional_separator = "="
+                        # 2. Split the string using operator and extract LHS and RHS
+                        # columns from a binary expression.
+                        columns = [column.strip() for column in condition.split(sep=conditional_separator)
+                                   if len(column) > 0]
+
+                        if len(columns) != 2:
+                            invalid_join_conditions.append(condition)
+                            # TODO: Raise exception here only.
+                        else:
+                            # 3. Generate fully qualified names using affix and table alias
+                            # and create final on clause condition string.
+                            left_col = self.__add_alias_to_column(columns[0], self, lhs_alias)
+                            right_col = self.__add_alias_to_column(columns[1], other, rhs_alias)
+                            if conditional_separator == "!=":
+                                # "!=" is python way of expressing 'not equal to'. "<>" is Teradata way of
+                                # expressing 'not equal to'. Adding support for "!=".
+                                conditional_separator = "<>"
+                            all_join_conditions.append(
+                                '{0} {1} {2}'.format(left_col, conditional_separator, right_col))
+
+                    # Generate on clause string from column expression.
+                    if isinstance(condition, ColumnExpression):
+                        compiled_condition = condition.compile(compile_kwargs={'include_table': True,
+                                                                               'literal_binds': True,
+                                                                               'table_name_kind': '_join_alias',
+                                                                               'compile_with_caller_table': True})
+
+                        all_join_conditions.append(compiled_condition)
+
+                # Raise error if invalid on conditions are passed.
+                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)
+
+                # Generate final on condition.
+                join_condition = " and ".join(all_join_conditions)
             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)
-                select_columns.append(UtilFuncs._teradata_quote_arg(column, "\"", False))
+                # In case of cross join no need of condition.
+                join_condition = ""
 
-        for column in other.columns:
-            if not df_utils._check_column_exists(column.lower(), self_columns_lower_actual_map.keys()):
-                # As column not present in left DataFrame, directly adding column to new metadata dict.
-                self.__add_column_type_item_to_dict(new_metaexpr_columns_types, column, column, df2_columns_types)
-                select_columns.append(UtilFuncs._teradata_quote_arg(column, "\"", False))
+            # Step 2: Generate the select clause string.
+            # Generate new column names for overlapping column names using lsuffix, rsuffix, lprefix, rprefix.
+            # Also, use table alias while addressing overlapping column names.
+            lhs_columns_types = df_utils._get_required_columns_types_from_metaexpr(self._metaexpr)
+            rhs_columns_types = df_utils._get_required_columns_types_from_metaexpr(other._metaexpr)
 
-        # 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,
-                                                 "df2" if raffix is None else raffix)
+            select_columns = []
+            new_metaexpr_columns_types = OrderedDict()
 
-        # Constructing new Metadata (_metaexpr) without DB; using dummy select_nodeid and underlying table name.
-        new_metaexpr = UtilFuncs._get_metaexpr_using_columns(join_node_id, new_metaexpr_columns_types.items())
+            # Processing columns in LHS DF/ self DF.
+            for column in self.columns:
+                if df_utils._check_column_exists(column.lower(), other_columns_lower_actual_map.keys()):
+                    # Check if column found in other DataFrame has same case or different.
+                    # Return the column name from the other DataFrame.
+                    other_column = other_columns_lower_actual_map[column.lower()]
+
+                    # Check if column name in LHS dataframe is same as that of in RHS dataframe.
+                    # If so, generate new name for LHS DF column using provided affix.
+                    df1_column_with_affix = self.__check_and_return_new_column_name(laffix, other_column,
+                                                                                    other_columns_lower_actual_map.keys(),
+                                                                                    "right", affix_type)
+
+                    # Generate select clause string for current column and append to list.
+                    select_columns.append("{0} as {1}".format(
+                        self.__get_fully_qualified_col_name(other_column, lhs_alias),
+                        df1_column_with_affix))
+
+                    # Check if column name in RHS dataframe is same as that of in LHS dataframe.
+                    # If so, generate new name for RHS DF column using provided affix.
+                    df2_column_with_affix = self.__check_and_return_new_column_name(raffix, column,
+                                                                                    self_columns_lower_actual_map.keys(),
+                                                                                    "left", affix_type)
+                    # Generate select clause string for current column and append to list.
+                    select_columns.append("{0} as {1}".format(
+                        self.__get_fully_qualified_col_name(column, rhs_alias),
+                        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,
+                                                        UtilFuncs._teradata_unquote_arg(df1_column_with_affix, "\""),
+                                                        column, lhs_columns_types)
+
+                    self.__add_column_type_item_to_dict(new_metaexpr_columns_types,
+                                                        UtilFuncs._teradata_unquote_arg(df2_column_with_affix, "\""),
+                                                        other_column, rhs_columns_types)
 
-        return self._create_dataframe_from_node(join_node_id, new_metaexpr, self._index_label)
+                else:
+                    # As column with same name is not present in RHS DataFrame now,
+                    # directly adding column to new metadata dict.
+                    self.__add_column_type_item_to_dict(new_metaexpr_columns_types, column, column, lhs_columns_types)
+                    select_columns.append(UtilFuncs._teradata_quote_arg(column, "\"", False))
+
+            # Processing columns in RHS DF/ other DF.
+            # Here we will only be processing columns which are not overlapping.
+            for column in other.columns:
+                if not df_utils._check_column_exists(column.lower(), self_columns_lower_actual_map.keys()):
+                    # As column not present in left DataFrame, directly adding column to new metadata dict.
+                    self.__add_column_type_item_to_dict(new_metaexpr_columns_types, column, column, rhs_columns_types)
+                    select_columns.append(UtilFuncs._teradata_quote_arg(column, "\"", False))
+
+            # Step 3: Create a node in AED using _aed_join using appropriate alias for involved tables.
+            join_node_id = self._aed_utils._aed_join(self._nodeid, other._nodeid, ", ".join(select_columns),
+                                                     how_lc, join_condition, lhs_alias, rhs_alias)
+
+            # Step 4: Constructing new Metadata (_metaexpr) without DB; using dummy select_nodeid
+            # and underlying table name.
+            new_metaexpr = UtilFuncs._get_metaexpr_using_columns(join_node_id, new_metaexpr_columns_types.items())
+
+            # Return a new joined dataframe.
+            return self._create_dataframe_from_node(join_node_id, new_metaexpr, self._index_label)
+        finally:
+            # Delete the '_join_alias' attribute attached to underlying
+            # SQLALchemy table objects.
+            delattr(self._metaexpr.t, "_join_alias")
+            delattr(other._metaexpr.t, "_join_alias")
 
     def __add_alias_to_column(self, column, df, alias):
         """
@@ -6577,7 +7007,7 @@ class DataFrame():
         return "{0}.{1}".format(UtilFuncs._teradata_quote_arg(alias, "\"", False),
                                 UtilFuncs._teradata_quote_arg(column, "\"", False))
 
-    def __check_and_return_new_column_name(self, affix, column, col_list, df_side, affix_type):
+    def __check_and_return_new_column_name(self, affix, column, col_list, other_df_side, affix_type):
         """
          Check new column name alias with column exists in col_list or not, if exists throws exception else
          returns new column name.
@@ -6586,7 +7016,7 @@ class DataFrame():
              affix  - affix to be added to column.
              column - column name.
              col_list - list of columns to check in which new column is exists or not.
-             df_side - Side of the dataframe.
+             other_df_side - Side on which the other dataframe in current join operation resides.
              affix_type - Type of affix. Either "prefix" or "suffix".
 
          EXAMPLES:
@@ -6600,19 +7030,19 @@ class DataFrame():
             return UtilFuncs._teradata_quote_arg(column, "\"", False)
 
         # 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,
-                                                             UtilFuncs._teradata_unquote_arg(column, "\""))
-        if df_utils._check_column_exists(df1_column_with_affix.lower(), col_list):
-            if df_side == "right":
-                suffix_side = "l{}".format(affix_type)
+        column_with_affix = "{0}_{1}" if affix_type == "prefix" else "{1}_{0}"
+        column_with_affix = column_with_affix.format(affix,
+                                                     UtilFuncs._teradata_unquote_arg(column, "\""))
+        if df_utils._check_column_exists(column_with_affix.lower(), col_list):
+            if other_df_side == "right":
+                affix_type = "l{}".format(affix_type)
             else:
-                suffix_side = "r{}".format(affix_type)
+                affix_type = "r{}".format(affix_type)
             raise TeradataMlException(
-                Messages.get_message(MessageCodes.TDMLDF_COLUMN_ALREADY_EXISTS, df1_column_with_affix, df_side,
-                                     suffix_side),
+                Messages.get_message(MessageCodes.TDMLDF_COLUMN_ALREADY_EXISTS, column_with_affix, other_df_side,
+                                     affix_type),
                 MessageCodes.TDMLDF_COLUMN_ALREADY_EXISTS)
-        return UtilFuncs._teradata_quote_arg(df1_column_with_affix, "\"", False)
+        return UtilFuncs._teradata_quote_arg(column_with_affix, "\"", False)
 
     def __add_column_type_item_to_dict(self, new_metadata_dict, new_column, column, column_types):
         """
@@ -7108,6 +7538,184 @@ 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':
+            _Validators._check_auth_token("udf")
+            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
+    
+    def _assign_call_udf(self, call_udf_expr):
+        """
+        DESCRIPTION:
+            Internal function for DataFrame.assign() to execute the call_udf using 
+            Script/Apply Table Operator and create new column for teradataml DataFrame.
+
+        PARAMETER:
+            call_udf_expr:
+                Required Argument.
+                Specifies a dictionary of column name to call_udf expressions.
+                Types: dict
+
+        RETURNS:
+            teradataml DataFrame
+
+        RAISES:
+            None.
+
+        EXAMPLES:
+            # call_udf_expr is a dictionary of column names to call_udf expressions.
+            call_udf_expr = {'upper_col': <teradataml.dataframe.sql._SQLColumnExpression object at 0x0000028E59C44310>,
+                            'sum_col': <teradataml.dataframe.sql._SQLColumnExpression object at 0x0000028E59C41690>}
+            self._assign_register(call_udf_expr)
+        """
+        df = self
+        # Create a dictionary of output columns to column type (teradata type).
+        returns = OrderedDict([(column.name, column.type) for column in df._metaexpr.c])
+        # Create a dictionary of output columns to column type (python types).
+        output_type_converters = {col_name: _Dtypes._teradata_type_to_python_type(col_type) \
+                                  for col_name, col_type in returns.items()}
+       
+        for colname, col in call_udf_expr.items():
+            returns[colname] = col.type
+            output_type_converters[colname] = _Dtypes._teradata_type_to_python_type(col.type)
+            script_name  = col._udf_script
+            delimiter = col._delimiter
+            quotechar = col._quotechar
+
+            # Create a dictionary of arguments to be passed to the script.
+            script_data = {}
+            script_data['input_cols'] = df.columns
+            script_data['output_cols'] = list(returns.keys())
+            script_data['output_type_converters'] = output_type_converters
+            script_data['function_args'] = {colname: col._udf_args}
+            script_data['delimiter'] = delimiter
+            script_data['qoutechar'] = quotechar
+
+            # Convert the dictionary to a string.
+            # The string is URL encoded to pass it as a parameter to the script.
+            script_data = urllib.parse.quote_plus(json.dumps(script_data))
+
+            if UtilFuncs._is_lake():
+                from teradataml.table_operators.Apply import Apply
+                apply_op_obj = Apply(data=df,
+                                    script_name=script_name,
+                                    env_name=col._env_name,
+                                    returns = returns,
+                                    delimiter = delimiter,
+                                    quotechar=quotechar,
+                                    files_local_path=GarbageCollector._get_temp_dir_name(),
+                                    apply_command="python3 {} {}".format(script_name, script_data)
+                                    )
+                try:
+                    df = apply_op_obj.execute_script(
+                        output_style=OutputStyle.OUTPUT_TABLE.value)
+                except Exception:
+                    raise
+            else:
+                import teradataml.context.context as context
+                database = context._get_current_databasename()
+
+                check_reserved_keyword = False if sorted(list(returns.keys())) == sorted(df.columns) else True
+
+                from teradataml.table_operators.Script import Script
+                table_op_obj = Script(data=df,
+                                    script_name=script_name,
+                                    files_local_path=GarbageCollector._get_temp_dir_name(),
+                                    script_command="{}/bin/python3  ./{}/{} {}".format(
+                                        configure.indb_install_location, database, script_name, script_data),
+                                    returns=returns,
+                                    quotechar=quotechar,
+                                    delimiter = delimiter
+                                    )
+                table_op_obj.check_reserved_keyword = check_reserved_keyword
+                try:
+                    df = table_op_obj.execute_script(
+                        output_style=OutputStyle.OUTPUT_TABLE.value)
+                except Exception:
+                    raise
+        return df
 
     @collect_queryband(queryband="DF_assign")
     def assign(self, drop_columns=False, **kwargs):
@@ -7119,10 +7727,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
 
@@ -7138,6 +7748,7 @@ class DataFrame():
                     * SQLAlchemy ClauseElements.
                       (See teradataml extension with SQLAlchemy in teradataml User Guide
                        and Function reference guide for more details)
+                    * Function - udf, call_udf.
 
 
         RETURNS:
@@ -7163,6 +7774,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
@@ -7424,6 +8045,158 @@ 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
+            >>>
+
+            # Example 20: Register and Call the user defined function to get the values upper case.
+            >>> from teradataml.dataframe.functions import udf, register, call_udf
+            >>> @udf
+            ... def to_upper(s):
+            ...     if s is not None:
+            ...         return s.upper()
+            >>>
+            # Register the created user defined function with name "upper".
+            >>> register("upper", to_upper)
+            >>>
+            # Call the user defined function registered with name "upper" and assign the 
+            # ColumnExpression returned to the DataFrame.
+            >>> res = df.assign(upper_col = call_udf("upper", ('accounts',)))
+            >>> res
+                          Feb    Jan    Mar    Apr  datetime   upper_col
+            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 = []
@@ -7469,13 +8242,42 @@ 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 = {}
+        call_udf_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
+            # If value passed in kwargs is a ColumnExpression and is a registerd udf script, store it.
+            elif isinstance(col, ColumnExpression) and col._udf_script:
+                call_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)
+
+        if bool(call_udf_expr):
+            df = df._assign_call_udf(call_udf_expr)
+
+        return df
+
 
     @collect_queryband(queryband="DF_get")
     def get(self, key):
@@ -9110,6 +9912,12 @@ class DataFrame():
         # Validate argument types
         _Validators._validate_function_arguments(awu_matrix)
 
+        # If self and right DataFrames are pointing to same Table object,
+        # raise error.
+        if self._metaexpr.t is right._metaexpr.t:
+            raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_ALIAS_REQUIRED, "merge"),
+                                      MessageCodes.TDMLDF_ALIAS_REQUIRED)
+
         if (right_on is not None and left_on is None) or (right_on is None and left_on is not None):
             raise TeradataMlException(
                 Messages.get_message(MessageCodes.MUST_PASS_ARGUMENT, "left_on", "right_on"),
@@ -10107,7 +10915,8 @@ class DataFrame():
                                                         test_size=list_of_fracs[1],
                                                         stratify_column=stratify_column,
                                                         seed=seed,
-                                                        persist=True)
+                                                        persist=True,
+                                                        display_table_name=False)
                     
                     # Retrieve the table name from TrainTestSplit_out object.
                     table_name = TrainTestSplit_out.result._table_name
@@ -10218,10 +11027,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
 
@@ -10352,26 +11161,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
 
@@ -10381,7 +11178,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,
@@ -11899,6 +12696,9 @@ class DataFrame():
             _Validators._validate_column_exists_in_dataframe(column_names, self._metaexpr,
                                                              False)
             column_names = list(dict.fromkeys(column_names))
+        
+        if list_td_reserved_keywords(column_names):
+            column_names = UtilFuncs._teradata_quote_arg(column_names, "\"", False)
 
         col_names_types = df_utils._get_required_columns_types_from_metaexpr(self._metaexpr, column_names)
         sel_nodeid = self._aed_utils._aed_select(self._nodeid, ','.join(column_names), True)
@@ -13840,7 +14640,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
@@ -13889,9 +14689,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