teradataml 20.0.0.6__py3-none-any.whl → 20.0.0.7__py3-none-any.whl

teradataml/dataframe/dataframe.py

@@ -27,8 +27,10 @@ import pandas as pd
 import sqlalchemy
 from sqlalchemy import Column
 from sqlalchemy.exc import NoSuchColumnError
+from datetime import datetime, date
 from sqlalchemy.sql import ClauseElement
 from teradatasql import OperationalError
+from teradatasqlalchemy import types as tdtypes
 from teradatasqlalchemy.dialect import dialect as td_dialect
 from teradatasqlalchemy.dialect import preparer
 from teradatasqlalchemy.types import (BIGINT, BYTEINT, DECIMAL, FLOAT, INTEGER,
@@ -38,7 +40,7 @@ import teradataml.context.context as tdmlctx
 from teradataml import GarbageCollector, execute_sql
 from teradataml.common.bulk_exposed_utils import \
     _validate_unimplemented_function
-from teradataml.common.constants import (AEDConstants, OutputStyle,
+from teradataml.common.constants import (AEDConstants, DataFrameTypes, OutputStyle,
                                          PTITableConstants, PythonTypes,
                                          SourceType, SQLConstants,
                                          SQLFunctionConstants,
@@ -239,6 +241,15 @@ class DataFrame():
                           included in the DataFrame if the dictionary contains those keys. If the dictionary does not
                           contain the specified keys, those columns will be added with NaN values.
                     Types: str OR list of str
+                
+                persist:
+                    Optional Argument.
+                    Specifies whether to persist the DataFrame.
+                    Note:
+                        * This argument is only applicable when the "data" argument is of type dict, list or 
+                          pandas DataFrame.
+                    Default Value: False
+                    Types: bool
 
         EXAMPLES:
             >>> from teradataml.dataframe.dataframe import DataFrame
@@ -366,15 +377,24 @@ class DataFrame():
         # This attribute stores the root DataFrame columns.
         self._root_columns = None
 
+        # Internal argument, when this attribute is set to True, the teradataml DataFrame locks
+        # the corresponding row(s) in the underlying table(s) while accessing the data.
+        _lock_rows = kwargs.get("_lock_rows", False)
+
         self._datalake = None
         self._database = None
         self._table = None
         self._otf = False
+        self._df_type = None
+        self._valid_time_column = None
+        self._transaction_time_column = None
+
 
         table_name = kwargs.get("table_name", None)
         primary_index = kwargs.get("primary_index", None)
         columns = kwargs.get("columns", None)
         types = kwargs.get("types", None)
+        persist = kwargs.get("persist", False)
 
         # Check if the data is an instance of in_schema or if the data is None
         # and table_name is an instance of in_schema, then assign the table_name,
@@ -441,9 +461,11 @@ class DataFrame():
                     pd_data = data.copy()
                     # If the columns are not of type string, then convert them to string.
                     pd_data.columns = [f"col_{i}" if isinstance(i, int) else i for i in pd_data.columns]
+
                     # Set the table_name to the name of the table created in the database.
                     table_name = UtilFuncs._generate_temp_table_name(prefix="from_pandas",
-                                                                table_type=TeradataConstants.TERADATA_TABLE)
+                                                                table_type=TeradataConstants.TERADATA_TABLE,
+                                                                gc_on_quit=not(persist))
 
                     copy_to_sql(pd_data, table_name, index=index, index_label=index_label, primary_index=primary_index,
                                 types=types)
@@ -491,6 +513,8 @@ class DataFrame():
 
                 if configure.temp_object_type == TeradataConstants.TERADATA_VOLATILE_TABLE:
                     __execute_params = (self._table_name, self._query, True)
+                elif configure.temp_object_type == TeradataConstants.TERADATA_VIEW:
+                    __execute_params = (self._table_name, self._query, _lock_rows)
 
                 try:
                     __execute(*__execute_params)
@@ -519,6 +543,7 @@ class DataFrame():
                     raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_CREATE_FAIL),
                                               MessageCodes.TDMLDF_CREATE_FAIL)
 
+            # _get_metaexpr() can be only used if self._table_name is set.
             if table_name or query:
                 self._metaexpr = self._get_metaexpr()
                 self._get_metadata_from_metaexpr(self._metaexpr)
@@ -717,7 +742,7 @@ class DataFrame():
 
     @classmethod
     @collect_queryband(queryband="DF_fromQuery")
-    def from_query(cls, query, index=True, index_label=None, materialize=False):
+    def from_query(cls, query, index=True, index_label=None, materialize=False, **kwargs):
         """
         Class method for creating a DataFrame from a query.
 
@@ -815,6 +840,7 @@ class DataFrame():
         df._nodeid = nodeid
         df._source_type = SourceType.TABLE.value
 
+
         if not reuse_metaexpr:
             # Create new _MetaExpression object using reference metaExpression
             # for newly created DataFrame.
@@ -862,7 +888,7 @@ class DataFrame():
 
     @classmethod
     @collect_queryband(queryband="DF_fromPandas")
-    def from_pandas(cls, pandas_df, index=True, index_label=None, primary_index=None):
+    def from_pandas(cls, pandas_df, index=True, index_label=None, primary_index=None, persist=False):
         """
         DESCRIPTION:
             Creates a teradataml DataFrame from a pandas DataFrame.
@@ -892,6 +918,12 @@ class DataFrame():
                 Specifies which column(s) to use as primary index for the teradataml DataFrame.
                 Types: str OR list of str
 
+            persist:
+                Optional Argument.
+                Specifies whether to persist the DataFrame.
+                Default Value: False
+                Types: bool
+
         RETURNS:
             teradataml DataFrame
 
@@ -942,14 +974,15 @@ class DataFrame():
         # Validate 'pandas_df' argument, other arguments, will be validated as part of DataFrame().
         arg_type_matrix = []
         arg_type_matrix.append(["pandas_df", pandas_df, False, (pd.DataFrame,), True])
-
+        arg_type_matrix.append(["persist", persist, True, (bool), True])
+        
         _Validators._validate_function_arguments(arg_type_matrix)
 
-        return cls(pandas_df, index, index_label, primary_index=primary_index)
+        return cls(pandas_df, index, index_label, primary_index=primary_index, persist=persist)
 
     @classmethod
     @collect_queryband(queryband="DF_fromDict")
-    def from_dict(cls, data, columns=None):
+    def from_dict(cls, data, columns=None, persist=False):
         """
         DESCRIPTION:
             Creates a DataFrame from a dictionary containing values as lists or numpy arrays.
@@ -969,6 +1002,12 @@ class DataFrame():
                 Specifies the column names for the DataFrame.
                 Types: str OR list of str
 
+            persist:
+                Optional Argument.
+                Specifies whether to persist the DataFrame.
+                Default Value: False
+                Types: bool
+
         RETURNS:
             teradataml DataFrame
 
@@ -1002,10 +1041,11 @@ class DataFrame():
         arg_type_matrix = []
         arg_type_matrix.append(["data", data, False, (dict), True])
         arg_type_matrix.append(["columns", columns, True, (str, list), True])
+        arg_type_matrix.append(["persist", persist, True, (bool), True])
 
         _Validators._validate_function_arguments(arg_type_matrix)
 
-        return cls(data, columns=columns, index=False)
+        return cls(data, columns=columns, index=False, persist=persist)
 
     @classmethod
     @collect_queryband(queryband="DF_fromRecords")
@@ -1049,6 +1089,12 @@ class DataFrame():
                     Specifies the number of rows to be read from the data if the data is iterator.
                     Types: int
 
+                persist:
+                    Optional Argument.
+                    Specifies whether to persist the DataFrame.
+                    Default Value: False
+                    Types: bool
+
         RETURNS:
             teradataml DataFrame
 
@@ -1136,6 +1182,7 @@ class DataFrame():
         exclude = kwargs.get("exclude", None)
         coerce_float = kwargs.get("coerce_float", True)
         nrows = kwargs.get("nrows", None)
+        persist = kwargs.get("persist", False)
 
         arg_type_matrix = []
         dtypes = (list, tuple, dict)
@@ -1144,6 +1191,7 @@ class DataFrame():
         arg_type_matrix.append(["exclude", exclude, True, (_ListOf(str),), True])
         arg_type_matrix.append(["coerce_float", coerce_float, True, (bool, ), True])
         arg_type_matrix.append(["nrows", nrows, True, (int,), True])
+        arg_type_matrix.append(["persist", persist, True, (bool,), True])
 
         _Validators._validate_function_arguments(arg_type_matrix)
 
@@ -1152,7 +1200,7 @@ class DataFrame():
 
         df = pd.DataFrame.from_records(data, columns=columns, exclude=exclude,
                                        coerce_float=coerce_float, nrows=nrows)
-        return cls(df, index=False)
+        return cls(df, index=False, persist=persist)
 
     def create_temp_view(self, name):
         """
@@ -1546,6 +1594,57 @@ class DataFrame():
         self._is_art = res[0][0] == 1
         return self._is_art
 
+
+    def _process_columns_metadata(self):
+        """
+        DESCRIPTION:
+            Processes the metadata of columns to determine their time dimension properties
+            and to check whether database object is a view, volatile table, or ART table.
+
+        PARAMETERS:
+            None
+
+        RAISES:
+            None
+
+        RETURNS:
+            Tuple containing five boolean values:
+                - is_view: True if the database object is a view, False otherwise.
+                - is_volatile: True if the database object is a volatile table, False otherwise.
+                - is_art_table: True if the database object is an ART table, False otherwise.
+                - has_valid_time: True if any column has a valid time dimension, False otherwise.
+                - has_transaction_time: True if any column has a transaction time dimension, False otherwise.
+        EXAMPLES:
+            >>> load_example_data("teradataml", "Employee")
+            >>> df = DataFrame.from_table("Employee")
+            >>> is_view, is_volatile, is_art_table, valid_time, transaction_time = (
+                df._process_columns_metadata()
+                )
+            >>> is_view, is_volatile, is_art_table, valid_time, transaction_time
+            (False, False, False, True, True)
+
+        """
+
+        is_view = is_volatile = is_art_table = False
+
+        for col in self._metaexpr.c:
+            metadata = col.expression.info
+            time_dimension = metadata.get('time_dimension')
+            is_view = metadata.get('is_view', is_view)
+            is_volatile = metadata.get('is_volatile', is_volatile)
+            is_art_table = metadata.get('is_art_table', is_art_table)
+
+            if time_dimension == "V":
+                self._valid_time_column = col
+
+            if time_dimension == "T":
+                self._transaction_time_column = col
+
+        has_valid_time = self._valid_time_column is not None
+        has_transaction_time = self._transaction_time_column is not None
+
+        return is_view, is_volatile, is_art_table, has_valid_time, has_transaction_time
+
     def _get_metadata_from_metaexpr(self, metaexpr):
         """
         Private method for setting _metaexpr and retrieving column names and types.
@@ -1598,6 +1697,7 @@ class DataFrame():
         meta = sqlalchemy.MetaData()
         db_schema = UtilFuncs._extract_db_name(self._table_name)
         db_table_name = UtilFuncs._extract_table_name(self._table_name)
+
         if not self._datalake:
             t = sqlalchemy.Table(db_table_name, meta, schema=db_schema, autoload_with=eng)
             return _MetaExpression(t)
@@ -1626,7 +1726,7 @@ class DataFrame():
         # Create a SQLAlchemy table object representing datalake table.
         t = sqlalchemy.Table(self._table, meta, schema=self._database,
                              *(Column(col_name, col_type) for col_name, col_type in zip(col_names, col_types)))
-        return _MetaExpression(t)
+        return _MetaExpression(t, datalake=self._datalake)
 
     def __getattr__(self, name):
         """
@@ -2165,6 +2265,148 @@ class DataFrame():
         td_metadata = [(column.name, repr(column.type)) for column in self._metaexpr.c]
         return MetaData(td_metadata)
 
+    @property
+    def df_type(self):
+        """
+        DESCRIPTION:
+            Returns the type of the DataFrame based on the underlying database object.
+            Possible teradataml DataFrame types are:
+                - VALID_TIME_VIEW: DataFrame is created on Valid-Time dimension view.
+                - TRANSACTION_TIME_VIEW: DataFrame is created on Transaction-Time dimension view.
+                - BI_TEMPORAL_VIEW: DataFrame is created on Bi-temporal view.
+                - VALID_TIME: DataFrame is created on Valid-Time dimension table.
+                - TRANSACTION_TIME: DataFrame is created on Transaction-Time dimension table.
+                - BI_TEMPORAL: DataFrame is created on Bi-temporal dimension table.
+                - VIEW: DataFrame is created on a view.
+                - TABLE: DataFrame is created on a table.
+                - OTF: DataFrame is created on an OTF table.
+                - ART: DataFrame is created on an ART table.
+                - VOLATILE_TABLE: DataFrame is created on a volatile table.
+                - BI_TEMPORAL_VOLATILE_TABLE: DataFrame is created on a Bi-temporal dimension volatile table.
+                - VALID_TIME_VOLATILE_TABLE: DataFrame is created on a Valid-Time dimension volatile table.
+                - TRANSACTION_TIME_VOLATILE_TABLE: DataFrame is created on a Transaction-Time dimension volatile table.
+
+        RETURNS:
+            str
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            # Load the data to run the example.
+            >>> load_example_data("teradataml", "Employee_roles") # load valid time data.
+            >>> load_example_data("teradataml", "Employee_Address") # load transaction time data.
+            >>> load_example_data("teradataml", "Employee") # load bitemporal data.
+            >>> load_example_data("uaf", ["ocean_buoys2"]) # load data to create art table.
+            >>> load_example_data('dataframe', ['admissions_train']) # load data to create a regular table.
+
+            # Example 1: DataFrame created on a Valid-Time dimension table.
+            >>> df = DataFrame.from_table('Employee_roles')
+            >>> df.df_type
+            'VALID_TIME'
+
+            # Example 2: DataFrame created on a Transaction-Time dimension table.
+            >>> df = DataFrame.from_table('Employee_Address')
+            >>> df.df_type
+            'TRANSACTION_TIME'
+
+            # Example 3: DataFrame created on a Bi-temporal dimension table.
+            >>> df = DataFrame.from_table('Employee')
+            >>> df.df_type
+            'BI_TEMPORAL'
+
+            # Example 4: DataFrame created on a ART table.
+            >>> data = DataFrame.from_table('ocean_buoys2')
+            >>> from teradataml import TDSeries,SInfo
+            >>> data_series_df = TDSeries(data=data,
+            ...                           id=["ocean_name","buoyid"],
+            ...                           row_index="TD_TIMECODE",
+            ...                           row_index_style="TIMECODE",
+            ...                           payload_field="jsoncol.Measure.salinity",
+            ...                           payload_content="REAL")
+            >>> uaf_out = SInfo(data=data_series_df, output_table_name='TSINFO_RESULTS')
+            >>> df = DataFrame.from_table('TSINFO_RESULTS')
+            >>> df.df_type
+            'ART'
+
+            # Example 5: DataFrame created on a regular table.
+            >>> df = DataFrame.from_table('admissions_train')
+            >>> df.df_type
+            'REGULAR_TABLE'
+
+            # Example 6: DataFrame created on a volatile table.
+            >>> df = DataFrame.from_table('admissions_train')
+            >>> df.to_sql(table_name='admissions_train_volatile', temporary=True)
+            >>> df = DataFrame.from_table('admissions_train_volatile')
+            >>> df.df_type
+            'VOLATILE_TABLE'
+
+            # Example 7: DataFrame created on a Bi-temporal dimension view.
+            >>> execute_sql('create view Employee_view AS SEQUENCED VALIDTIME AND SEQUENCED TRANSACTIONTIME select * from Employee')
+            >>> df = DataFrame.from_table('Employee_view')
+            >>> df.df_type
+            'BI_TEMPORAL_VIEW'
+
+        """
+
+        if self._df_type is not None:
+            return self._df_type
+
+        is_view, is_volatile, is_art_table, valid_time, transaction_time = (
+            self._process_columns_metadata()
+        )
+
+        # Check if the DataFrame is created from an OTF table
+        if self._otf:
+            self._df_type = DataFrameTypes.OTF_TABLE.value
+            return self._df_type
+
+        # Check if the DataFrame is created from an ART table
+        if is_art_table:
+            self._df_type = DataFrameTypes.ART_TABLE.value
+            return self._df_type
+
+        # Determine the type based on valid-time, transaction-time columns, and volatility
+        if valid_time and transaction_time:
+            if is_volatile:
+                self._df_type = DataFrameTypes.BI_TEMPORAL_VOLATILE_TABLE.value
+            else:
+                self._df_type = (
+                    DataFrameTypes.BI_TEMPORAL_VIEW.value
+                    if is_view
+                    else DataFrameTypes.BI_TEMPORAL.value
+                )
+        elif valid_time:
+            if is_volatile:
+                self._df_type = DataFrameTypes.VALID_TIME_VOLATILE_TABLE.value
+            else:
+                self._df_type = (
+                    DataFrameTypes.VALID_TIME_VIEW.value
+                    if is_view
+                    else DataFrameTypes.VALID_TIME.value
+                )
+        elif transaction_time:
+            if is_volatile:
+                self._df_type = DataFrameTypes.TRANSACTION_TIME_VOLATILE_TABLE.value
+            else:
+                self._df_type = (
+                    DataFrameTypes.TRANSACTION_TIME_VIEW.value
+                    if is_view
+                    else DataFrameTypes.TRANSACTION_TIME.value
+                )
+        else:
+            self._df_type = (
+                DataFrameTypes.VOLATILE_TABLE.value
+                if is_volatile
+                else (
+                    DataFrameTypes.VIEW.value
+                    if is_view
+                    else DataFrameTypes.REGULAR_TABLE.value
+                )
+            )
+
+        return self._df_type
+
     @collect_queryband(queryband="DF_info")
     def info(self, verbose=True, buf=None, max_cols=None, null_counts=False):
         """
@@ -6408,7 +6650,8 @@ class DataFrame():
 
             new_metaexpr = UtilFuncs._get_metaexpr_using_columns(aggregate_node_id,
                                                                  zip(new_column_names,
-                                                                     new_column_types))
+                                                                     new_column_types),
+                                                                 datalake=self._metaexpr.datalake)
             agg_df = self._create_dataframe_from_node \
                 (aggregate_node_id, new_metaexpr, self._index_label)
 
@@ -6827,7 +7070,8 @@ class DataFrame():
             sel_nodeid = self._aed_utils._aed_select(self._nodeid, column_expression)
 
             # Constructing new Metadata (_metaexpr) without DB; using dummy select_nodeid and underlying table name.
-            new_metaexpr = UtilFuncs._get_metaexpr_using_columns(sel_nodeid, col_names_types.items())
+            new_metaexpr = UtilFuncs._get_metaexpr_using_columns(sel_nodeid, col_names_types.items(),
+                                                                 datalake=self._metaexpr.datalake)
             return self._create_dataframe_from_node(sel_nodeid, new_metaexpr, self._index_label)
 
         except TeradataMlException:
@@ -7777,7 +8021,8 @@ class DataFrame():
 
             # 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())
+            new_metaexpr = UtilFuncs._get_metaexpr_using_columns(join_node_id, new_metaexpr_columns_types.items(),
+                                                                 datalake=self._metaexpr.datalake)
 
             # Return a new joined dataframe.
             return self._create_dataframe_from_node(join_node_id, new_metaexpr, self._index_label)
@@ -9150,7 +9395,6 @@ class DataFrame():
 
         return df
 
-
     @collect_queryband(queryband="DF_get")
     def get(self, key):
         """
@@ -9260,7 +9504,7 @@ class DataFrame():
             append:
                 Optional Argument.
                 Specifies whether or not to append requested columns to the existing index.
-    `           When append is False, replaces existing index.
+                When append is False, replaces existing index.
                 When append is True, retains both existing & currently appended index.
                 Default Value: False
                 Types: bool
@@ -9476,8 +9720,8 @@ class DataFrame():
                 include_grouping_columns:
                     Optional Argument.
                     Specifies whether to include aggregations on the grouping column(s) or not.
-                    When set to True, the resultant DataFrame will have the aggregations on the 
-                    columns mentioned in "columns_expr". Otherwise, resultant DataFrame will not have 
+                    When set to True, the resultant DataFrame will have the aggregations on the
+                    columns mentioned in "columns_expr". Otherwise, resultant DataFrame will not have
                     aggregations on the columns mentioned in "columns_expr".
                     Default Value: False
                     Types: bool
@@ -9517,7 +9761,7 @@ class DataFrame():
             26     yes  3.57  Advanced    Advanced         1
             17      no  3.83  Advanced    Advanced         1
 
-            # Example 1: Find the minimum value of all valid columns by 
+            # Example 1: Find the minimum value of all valid columns by
             #            grouping the DataFrame with column 'masters'.
             >>> df1 = df.groupby(["masters"])
             >>> df1.min()
@@ -9538,7 +9782,7 @@ class DataFrame():
 
             # Example 3: Find the sum of all valid columns by grouping the DataFrame with
             #            columns 'masters' and 'admitted'. Do not include grouping columns
-            #            in aggregate function 'sum'. 
+            #            in aggregate function 'sum'.
             >>> df1 = df.groupby(["masters", "admitted"], include_grouping_columns=False)
             >>> df1.sum()
               masters  admitted  sum_id  sum_gpa
@@ -11964,7 +12208,8 @@ class DataFrame():
             column_info = ((col_name, col_type) for col_name, col_type in
                                                 new_metaexpr_columns_types.items())
             # Get new metaexpr for sample_node_id
-            new_metaexpr = UtilFuncs._get_metaexpr_using_columns(sample_node_id, column_info, is_persist=True)
+            new_metaexpr = UtilFuncs._get_metaexpr_using_columns(sample_node_id, column_info, is_persist=True,
+                                                                 datalake=self._metaexpr.datalake)
 
             # 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.
@@ -13399,9 +13644,9 @@ class DataFrame():
                     3. When ColumnExpression(s) is(are) passed to "order_columns", then the
                        corresponding expression takes precedence over arguments
                        "sort_ascending" and "nulls_first". Say, ColumnExpression is col1, then
-	                   1. col1.asc() or col.desc() is effective irrespective of "sort_ascending".
-	                   2. col1.nulls_first() or col.nulls_last() is effective irrespective of "nulls_first".
-	                   3. Any combination of above two take precedence over "sort_ascending" and "nulls_first".
+                       1. col1.asc() or col.desc() is effective irrespective of "sort_ascending".
+                       2. col1.nulls_first() or col.nulls_last() is effective irrespective of "nulls_first".
+                       3. Any combination of above two take precedence over "sort_ascending" and "nulls_first".
                 Types: str OR list of Strings (str) OR ColumnExpression OR list of ColumnExpressions
 
             sort_ascending:
@@ -13682,7 +13927,9 @@ class DataFrame():
 
         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)
-        new_metaexpr = UtilFuncs._get_metaexpr_using_columns(sel_nodeid, col_names_types.items())
+        new_metaexpr = UtilFuncs._get_metaexpr_using_columns(sel_nodeid, col_names_types.items(),
+                                                             datalake=self._metaexpr.datalake)
+
         return self._create_dataframe_from_node(sel_nodeid, new_metaexpr, self._index_label)
 
     @collect_queryband(queryband="DF_toCsv")
@@ -15880,8 +16127,8 @@ class DataFrame():
             include_grouping_columns:
                 Optional Argument.
                 Specifies whether to include aggregations on the grouping column(s) or not.
-                When set to True, the resultant DataFrame will have the aggregations on the 
-                columns mentioned in "columns". Otherwise, resultant DataFrame will not have 
+                When set to True, the resultant DataFrame will have the aggregations on the
+                columns mentioned in "columns". Otherwise, resultant DataFrame will not have
                 aggregations on the columns mentioned in "columns".
                 Default Value: False
                 Types: bool
@@ -15946,7 +16193,7 @@ class DataFrame():
 
             # Example 3: Find the avg of all valid columns by grouping the DataFrame with
             #            columns 'masters' and 'admitted'. Do not include grouping columns
-            #            in aggregate function 'avg'. 
+            #            in aggregate function 'avg'.
             >>> df1 = df.cube(["masters", "admitted"], include_grouping_columns=False).avg()
             >>> df1
               masters  admitted     avg_id   avg_gpa
@@ -15993,8 +16240,8 @@ class DataFrame():
             include_grouping_columns:
                 Optional Argument.
                 Specifies whether to include aggregations on the grouping column(s) or not.
-                When set to True, the resultant DataFrame will have the aggregations on the 
-                columns mentioned in "columns". Otherwise, resultant DataFrame will not have 
+                When set to True, the resultant DataFrame will have the aggregations on the
+                columns mentioned in "columns". Otherwise, resultant DataFrame will not have
                 aggregations on the columns mentioned in "columns".
                 Default Value: False
                 Types: bool
@@ -16039,7 +16286,7 @@ class DataFrame():
             6     yes  Beginner      13    14.71             2
             7     yes  Advanced     366    49.26             7
             8      no  Advanced     189    34.95             9
-            
+
             # Example 2: Find the avg of all valid columns by grouping the DataFrame
             #            with columns 'masters' and 'admitted'. Include grouping columns
             #            in aggregate function 'avg'.
@@ -16331,6 +16578,878 @@ class DataFrame():
                                                            "Use valid timestamp or correct snapshot id listed using 'snapshots' property.".format(as_of)),
                                       MessageCodes.FUNC_EXECUTION_FAILED)
 
+    def as_of(self, **kwargs):
+        """
+        DESCRIPTION:
+            Function to get DataFrame at specific time on temporal table.
+            Note:
+                Function is supported only on temporal tables or temporal views.
+
+        PARAMETERS:
+            kwargs:
+                Specifies keyword arguments.
+
+                valid_time:
+                    Optional Argument.
+                    Specifies the valid time to retrieve data from DataFrame created on either ValidTime
+                    or BiTemporal table/view.
+                    Notes:
+                         * Either "valid_time" or "transaction_time" must be provided.
+                         * Argument accepts below values:
+                             * "current" - to get the current valid time data.
+                             * any string other than "current" is considered as date and data will be retrieved at that of time.
+                             * date object - to get the data valid on that date.
+                             * datetime object - to get the data valid at that point of time.
+                             * tuple - to get the data which is valid between the two valid times.
+                                 * tuple should have only two elements. First element considered as starting time
+                                   and second element considered as end time for a period of time.
+                                   Records will be retrieved which are valid between the two valid times.
+                                 * Both elements can be of date or datetime or string type. If you are using
+                                   string, make sure the string represents a valid date.
+                                 * Any element can be None.
+                                    * If first element is None and valid time dimension column is PERIOD_DATE type,
+                                      then it is considered as '0001-01-01'.
+                                    * If first element is None and valid time dimension column is PERIOD_TIMESTAMP type,
+                                      then it is considered as '0001-01-01 00:00:00.000000+00:00'.
+                                    * If second element is None and valid time dimension column is PERIOD_DATE type,
+                                      then it is considered as '9999-12-31'.
+                                    * If second element is None and valid time dimension column is PERIOD_TIMESTAMP type,
+                                      then it is considered as '9999-12-31 23:59:59.999999+00:00'.
+                            * None - to consider the DataFrame as regular DataFrame and retrieve all the records from
+                                     valid time dimension.
+                    Types: date or str or tuple or NoneType
+
+                include_valid_time_column:
+                    Optional Argument.
+                    Specifies whether to include the valid time dimension column in the resultant DataFrame.
+                    When set to True, valid time dimension column is included in resultant DataFrame.
+                    Otherwise, valid time dimension column is not included in resultant DataFrame.
+                    Note:
+                        Ignored when "valid_time" is either tuple or None.
+                    Default Value: False
+                    Types: bool
+
+                transaction_time:
+                    Optional Argument.
+                    Specifies the transaction time to retrieve data from DataFrame created on either
+                    TransactionTime or BiTemporal table/view.
+                    Notes:
+                         * Either "valid_time" or "transaction_time" must be provided.
+                         * Argument accepts below values.
+                            * "current" - to get the records which are valid at current time.
+                            * any string other than "current" is considered as timestamp and records which are
+                              valid at that of time.
+                            * datetime object - to get the records which are valid at that of time.
+                            * None - to consider the DataFrame as regular DataFrame and retrieve all the records
+                              from transaction time dimension.
+                    Types: datetime or str or NoneType
+
+                include_transaction_time_column:
+                    Optional Argument.
+                    Specifies whether to include the transaction time dimension column in the resultant DataFrame.
+                    When set to True, transaction time dimension column is included in resultant DataFrame.
+                    Otherwise, transaction time dimension column is not included in resultant DataFrame.
+                    Default Value: False
+                    Types: bool
+
+                additional_period:
+                    Optional Argument.
+                    Specifies the additional period to be kept in resultant DataFrame.
+                    Note:
+                        This is applicable only when "valid_time" is None.
+                    Types: tuple of date or str
+
+        RETURNS:
+            teradataml DataFrame
+
+        RAISES:
+            TeradatamlException.
+
+        EXAMPLES:
+            # Load the data to run the example.
+            >>> load_example_data("teradataml", "Employee_roles") # load valid time data.
+            >>> load_example_data("teradataml", "Employee_Address") # load transaction time data.
+            >>> load_example_data("teradataml", "Employee") # load bitemporal data.
+
+            >>> df1 = DataFrame("Employee_roles")
+                       EmployeeName Department  Salary      role_validity_period
+            EmployeeID
+            1              John Doe         IT   100.0  ('20/01/01', '24/12/31')
+            2            Jane Smith         DA   200.0  ('20/01/01', '99/12/31')
+            3                   Bob  Marketing   330.0  ('25/01/01', '99/12/31')
+            3                   Bob      Sales   300.0  ('24/01/01', '24/12/31')
+
+            # Example 1: Get the employee roles from DataFrame df1 which are valid at current time.
+            >>> df1.as_of(valid_time="current")
+                       EmployeeName Department  Salary
+            EmployeeID
+            2            Jane Smith         DA   200.0
+            3                   Bob  Marketing   330.0
+
+            # Example 2: Get the employee roles from DataFrame df1 which are valid at current time.
+            #            Also include valid time dimension column.
+            >>> df1.as_of(valid_time="current", include_valid_time_column=True)
+                       EmployeeName Department  Salary      role_validity_period
+            EmployeeID
+            2            Jane Smith         DA   200.0  ('20/01/01', '99/12/31')
+            3                   Bob  Marketing   330.0  ('25/01/01', '99/12/31')
+
+            # Example 3: Get the employee roles from DataFrame df1 which are valid at 31st Dec 2026.
+                         Include valid time dimension column.
+            >>> df1.as_of(valid_time="2026-12-31", include_valid_time_column=True)
+                       EmployeeName Department  Salary      role_validity_period
+            EmployeeID
+            2            Jane Smith         DA   200.0  ('20/01/01', '99/12/31')
+            3                   Bob  Marketing   330.0  ('25/01/01', '99/12/31')
+
+            # Example 4: Get the employee roles from DataFrame df1 which are valid at 31st Dec 2026.
+            #            Also include valid time dimension column. Use date object instead of string
+            #            to specify the date.
+            >>> from datetime import date
+            >>> d = date(2026, 12, 31)
+            >>> df1.as_of(valid_time=d, include_valid_time_column=True)
+                       EmployeeName Department  Salary      role_validity_period
+            EmployeeID
+            2            Jane Smith         DA   200.0  ('20/01/01', '99/12/31')
+            3                   Bob  Marketing   330.0  ('25/01/01', '99/12/31')
+
+            # Example 5: Get the employee roles which are valid between 20th Jan 2018 and 5th March 2024.
+            #            Include valid time dimension column.
+            >>> df1.as_of(valid_time=("2018-01-20", "2024-03-05"), include_valid_time_column=True)
+                       EmployeeName Department  Salary                 VALIDTIME
+            EmployeeID
+            2            Jane Smith         DA   200.0  ('20/01/01', '24/03/05')
+            1              John Doe         IT   100.0  ('20/01/01', '24/03/05')
+            3                   Bob      Sales   300.0  ('24/01/01', '24/03/05')
+
+            # Example 6: Get the employee roles which are valid between 20th Jan 2018 and 5th March 2024.
+            #            Then again get the records which are valid at 1st Jan 2023. Do not include
+            #            valid time dimension column since selecting valid time dimension column is ignored
+            #            when "valid_time" is a tuple.
+            >>> df1.as_of(valid_time=(date(2018, 1, 20), "2024-03-05")).as_of(valid_time=date(2023, 1, 1))
+                       EmployeeName Department  Salary
+            EmployeeID
+            2            Jane Smith         DA   200.0
+            1              John Doe         IT   100.0
+
+            # Example 7: Get the employee roles which are valid between 1st Jan 0001 and 1st Jun 2024.
+            >>> df1.as_of(valid_time=(None, date(2024, 3, 5)))
+                       EmployeeName Department  Salary                 VALIDTIME
+            EmployeeID
+            2            Jane Smith         DA   200.0  ('20/01/01', '24/03/05')
+            1              John Doe         IT   100.0  ('20/01/01', '24/03/05')
+            3                   Bob      Sales   300.0  ('24/01/01', '24/03/05')
+
+            # Example 8: Get the employee roles which are valid between 1st Jun 2024 and 31st Dec 9999.
+            >>> df1.as_of(valid_time=("2024-06-01", None))
+                       EmployeeName Department  Salary                 VALIDTIME
+            EmployeeID
+            1              John Doe         IT   100.0  ('24/06/01', '24/12/31')
+            2            Jane Smith         DA   200.0  ('24/06/01', '99/12/31')
+            3                   Bob  Marketing   330.0  ('25/01/01', '99/12/31')
+            3                   Bob      Sales   300.0  ('24/06/01', '24/12/31')
+
+            # Example 9: Consider df1 as regular DataFrame and retrieve all the records irrespective
+            #            whether records are valid or not.
+            >>> df1.as_of(valid_time=None)
+                       EmployeeName Department  Salary
+            EmployeeID
+            1              John Doe         IT   100.0
+            2            Jane Smith         DA   200.0
+            3                   Bob  Marketing   330.0
+            3                   Bob      Sales   300.0
+
+            # Example 10. Consider df1 as regular DataFrame and retrieve all the records irrespective
+            #              whether records are valid or not. Also include additional period and valid time
+            #              dimension column.
+            >>> df1.as_of(valid_time=None, additional_period=("2024-01-01", "2024-03-05"), include_valid_time_column=True)
+                       EmployeeName Department  Salary      role_validity_period                 VALIDTIME
+            EmployeeID
+            1              John Doe         IT   100.0  ('20/01/01', '24/12/31')  ('24/01/01', '24/03/05')
+            2            Jane Smith         DA   200.0  ('20/01/01', '99/12/31')  ('24/01/01', '24/03/05')
+            3                   Bob  Marketing   330.0  ('25/01/01', '99/12/31')  ('24/01/01', '24/03/05')
+            3                   Bob      Sales   300.0  ('24/01/01', '24/12/31')  ('24/01/01', '24/03/05')
+
+            >>> df2 = DataFrame("Employee_Address")
+                       EmployeeName      address                                                           validity_period
+            EmployeeID
+            2            Jane Smith   456 Elm St  ('2025-03-04 15:41:44.610000+00:00', '9999-12-31 23:59:59.999999+00:00')
+            1              John Doe  123 Main St  ('2025-03-04 15:41:44.610000+00:00', '9999-12-31 23:59:59.999999+00:00')
+            3           Bob Johnson   789 Oak St  ('2025-03-04 15:41:44.610001+00:00', '9999-12-31 23:59:59.999999+00:00')
+
+            # Example 11: Consider df2 as regular DataFrame and retrieve all the records including historic
+            #             records. Also include transaction time dimension column.
+            >>> df2.as_of(transaction_time=None, include_transaction_time_column=True)
+                       EmployeeName         address                                                           validity_period
+            EmployeeID
+            1              John Doe     123 Main St  ('2025-03-04 15:41:44.610000+00:00', '9999-12-31 23:59:59.999999+00:00')
+            2            Jane Smith      456 Elm St  ('2025-03-04 15:41:44.610000+00:00', '9999-12-31 23:59:59.999999+00:00')
+            3           Bob Johnson  789 Oak Street  ('2025-03-04 15:41:44.610000+00:00', '2025-03-04 15:41:44.610001+00:00')
+            3           Bob Johnson      789 Oak St  ('2025-03-04 15:41:44.610001+00:00', '9999-12-31 23:59:59.999999+00:00')
+
+            # Example 12: Get the employee address which are valid at current time from DataFrame df2.
+            #             Also include transaction time dimension column.
+            >>> df2.as_of(transaction_time="current", include_transaction_time_column=True)
+                       EmployeeName      address                                                           validity_period
+            EmployeeID
+            2            Jane Smith   456 Elm St  ('2025-03-04 15:41:44.610000+00:00', '9999-12-31 23:59:59.999999+00:00')
+            1              John Doe  123 Main St  ('2025-03-04 15:41:44.610000+00:00', '9999-12-31 23:59:59.999999+00:00')
+            3           Bob Johnson   789 Oak St  ('2025-03-04 15:41:44.610001+00:00', '9999-12-31 23:59:59.999999+00:00')
+
+            # Example 13: Get the employee address which are valid at current time from DataFrame df2.
+            #             Do not include transaction time dimension column.
+            >>> df2.as_of(transaction_time="current", include_transaction_time_column=False)
+                       EmployeeName      address
+            EmployeeID
+            2            Jane Smith   456 Elm St
+            1              John Doe  123 Main St
+            3           Bob Johnson   789 Oak St
+
+            # Example 14: Get the employee address which are valid at 2025-03-04 15:41:44.610000+00:00 from DataFrame df2.
+            #             Include transaction time dimension column.
+            >>> df2.as_of(transaction_time="2025-03-04 15:41:44.610000+00:00", include_transaction_time_column=True)
+                       EmployeeName         address                                                           validity_period
+            EmployeeID
+            2            Jane Smith      456 Elm St  ('2025-03-04 15:41:44.610000+00:00', '9999-12-31 23:59:59.999999+00:00')
+            1              John Doe     123 Main St  ('2025-03-04 15:41:44.610000+00:00', '9999-12-31 23:59:59.999999+00:00')
+            3           Bob Johnson  789 Oak Street  ('2025-03-04 15:41:44.610000+00:00', '2025-03-04 15:41:44.610001+00:00')
+
+            # Example 15: Get the employee address which are valid at 2025-03-04 15:41:44.610001+00:00 from DataFrame df2.
+            #             Include transaction time dimension column.
+            >>> from datetime import datetime, timezone, timedelta
+            >>> dt = datetime(2025, 3, 4, 15, 41, 44, 610001)
+            >>> dt_with_tz = dt.replace(tzinfo=timezone(timedelta(hours=0)))
+            >>> df2.as_of(transaction_time=dt_with_tz, include_transaction_time_column=True)
+                       EmployeeName      address                                                           validity_period
+            EmployeeID
+            2            Jane Smith   456 Elm St  ('2025-03-04 15:41:44.610000+00:00', '9999-12-31 23:59:59.999999+00:00')
+            1              John Doe  123 Main St  ('2025-03-04 15:41:44.610000+00:00', '9999-12-31 23:59:59.999999+00:00')
+            3           Bob Johnson   789 Oak St  ('2025-03-04 15:41:44.610001+00:00', '9999-12-31 23:59:59.999999+00:00')
+
+            >>> df3 = DataFrame("Employee")
+                       EmployeeName      address Department  Salary             role_validity                                                           validity_period
+            EmployeeID
+            1              John Doe  123 Main St         IT   100.0  ('20/01/01', '24/12/31')  ('2025-03-04 18:08:58.720000+00:00', '9999-12-31 23:59:59.999999+00:00')
+            2            Jane Smith   456 Elm St         DA   200.0  ('20/01/01', '99/12/31')  ('2025-03-04 18:08:58.720000+00:00', '9999-12-31 23:59:59.999999+00:00')
+            3                   Bob   789 OAK St  Marketing   330.0  ('25/01/01', '99/12/31')  ('2025-05-06 11:39:25.580000+00:00', '9999-12-31 23:59:59.999999+00:00')
+            3                   Bob   789 Oak St      Sales   300.0  ('24/01/01', '24/12/31')  ('2025-03-04 18:09:08.830000+00:00', '9999-12-31 23:59:59.999999+00:00')
+
+            # Example 16: Get all the records from DataFrame df3 by considering the DataFrame as
+            #             regular DataFrame. Include both valid time and transaction time dimension columns.
+            >>> df3.as_of(valid_time=None,
+            ...           transaction_time=None,
+            ...           include_valid_time_column=True,
+            ...           include_transaction_time_column=True
+            ...           )
+                       EmployeeName         address Department  Salary             role_validity                                                           validity_period
+            EmployeeID
+            3                   Bob  789 Oak Street      Sales   300.0  ('24/01/01', '24/12/31')  ('2025-03-04 18:08:58.720000+00:00', '2025-03-04 18:09:08.830000+00:00')
+            3                   Bob      789 Oak St  Marketing   330.0  ('25/01/01', '99/12/31')  ('2025-03-04 18:09:08.830000+00:00', '2025-05-06 11:39:25.580000+00:00')
+            1              John Doe     123 Main St         IT   100.0  ('20/01/01', '24/12/31')  ('2025-03-04 18:08:58.720000+00:00', '9999-12-31 23:59:59.999999+00:00')
+            2            Jane Smith      456 Elm St         DA   200.0  ('20/01/01', '99/12/31')  ('2025-03-04 18:08:58.720000+00:00', '9999-12-31 23:59:59.999999+00:00')
+            3                   Bob  789 Oak Street  Marketing   330.0  ('25/01/01', '99/12/31')  ('2025-03-04 18:08:58.720000+00:00', '2025-03-04 18:09:08.830000+00:00')
+            3                   Bob      789 OAK St  Marketing   330.0  ('25/01/01', '99/12/31')  ('2025-05-06 11:39:25.580000+00:00', '9999-12-31 23:59:59.999999+00:00')
+            3                   Bob      789 Oak St      Sales   300.0  ('24/01/01', '24/12/31')  ('2025-03-04 18:09:08.830000+00:00', '9999-12-31 23:59:59.999999+00:00')
+
+            # Example 17: Get the employee address from DataFrame df3 which are valid at 1st Jun 2024 from
+            #             valid time dimension and valid at '2025-03-04 18:09:08.720001+00:00' from transaction
+            #             time dimension. Include both valid time and transaction time dimension columns.
+            >>> df3.as_of(valid_time="2024-06-01",
+            ...           transaction_time="2025-03-04 18:09:08.720001+00:00",
+            ...           include_valid_time_column=True,
+            ...           include_transaction_time_column=True
+            ...           )
+                       EmployeeName         address Department  Salary             role_validity                                                           validity_period
+            EmployeeID
+            2            Jane Smith      456 Elm St         DA   200.0  ('20/01/01', '99/12/31')  ('2025-03-04 18:08:58.720000+00:00', '9999-12-31 23:59:59.999999+00:00')
+            1              John Doe     123 Main St         IT   100.0  ('20/01/01', '24/12/31')  ('2025-03-04 18:08:58.720000+00:00', '9999-12-31 23:59:59.999999+00:00')
+            3                   Bob  789 Oak Street      Sales   300.0  ('24/01/01', '24/12/31')  ('2025-03-04 18:08:58.720000+00:00', '2025-03-04 18:09:08.830000+00:00')
+
+            # Example 18: Get the employee address from DataFrame df3 which are valid at 25th Jan 2024
+            #             from valid time dimension and valid at current time from transaction time dimension.
+            #             Include only transaction time dimension column.
+            >>> df3.as_of(valid_time=date(2024, 1, 25),
+            ...           transaction_time="current",
+            ...           include_transaction_time_column=True)
+                       EmployeeName      address Department  Salary                                                           validity_period
+            EmployeeID
+            2            Jane Smith   456 Elm St         DA   200.0  ('2025-03-04 18:08:58.720000+00:00', '9999-12-31 23:59:59.999999+00:00')
+            1              John Doe  123 Main St         IT   100.0  ('2025-03-04 18:08:58.720000+00:00', '9999-12-31 23:59:59.999999+00:00')
+            3                   Bob   789 Oak St      Sales   300.0  ('2025-03-04 18:09:08.830000+00:00', '9999-12-31 23:59:59.999999+00:00')
+
+            # Example 19: Get the employee address from DataFrame df3 which are valid between 1st Jan 2025
+            #             and 30th June 2025 from valid time dimension and valid at
+            #             '2025-03-04 18:08:59.720000+00:00' from transaction time dimension.
+            #             Include both valid time and transaction time dimension columns.
+            >>> from datetime import datetime, timezone
+            >>>df3.as_of(valid_time=("2025-01-01", date(2025, 6, 30)),
+            ...          transaction_time=datetime(2025, 3, 4, 18, 8, 59, 720000).astimezone(timezone.utc),
+            ...          include_transaction_time_column=True)
+                       EmployeeName     address Department  Salary                                                           validity_period                 VALIDTIME
+            EmployeeID
+            2            Jane Smith  456 Elm St         DA   200.0  ('2025-03-04 18:08:58.720000+00:00', '9999-12-31 23:59:59.999999+00:00')  ('25/01/01', '25/06/30')
+            3                   Bob  789 Oak St  Marketing   330.0  ('2025-03-04 18:09:08.830000+00:00', '2025-05-06 11:39:25.580000+00:00')  ('25/01/01', '25/06/30')
+
+            # Example 20: Get the employee address from DataFrame df3 by considering the DataFrame as regular
+            #             DataFrame from valid time dimension and valid at current time from transaction time dimension.
+            #             Add additional period and include both valid time and transaction time dimension columns.
+            >>> df3.as_of(valid_time=None,
+            ...           transaction_time="current",
+            ...           additional_period=("2024-01-01", "2024-03-05"),
+            ...           include_valid_time_column=True,
+            ...           include_transaction_time_column=True
+            ...           )
+                       EmployeeName      address Department  Salary             role_validity                                                           validity_period                 VALIDTIME
+            EmployeeID
+            1              John Doe  123 Main St         IT   100.0  ('20/01/01', '24/12/31')  ('2025-03-04 18:08:58.720000+00:00', '9999-12-31 23:59:59.999999+00:00')  ('24/01/01', '24/03/05')
+            2            Jane Smith   456 Elm St         DA   200.0  ('20/01/01', '99/12/31')  ('2025-03-04 18:08:58.720000+00:00', '9999-12-31 23:59:59.999999+00:00')  ('24/01/01', '24/03/05')
+            3                   Bob   789 OAK St  Marketing   330.0  ('25/01/01', '99/12/31')  ('2025-05-06 11:39:25.580000+00:00', '9999-12-31 23:59:59.999999+00:00')  ('24/01/01', '24/03/05')
+            3                   Bob   789 Oak St      Sales   300.0  ('24/01/01', '24/12/31')  ('2025-03-04 18:09:08.830000+00:00', '9999-12-31 23:59:59.999999+00:00')  ('24/01/01', '24/03/05')
+        """
+
+        if "valid_time" not in kwargs and "transaction_time" not in kwargs:
+            _Validators._validate_mutually_exclusive_arguments(
+                None, "valid_time", None, "transaction_time")
+
+        # Validate argument types.
+        _validation = []
+        _validation.append(["valid_time", kwargs.get("valid_time"), True, (date, datetime, str, tuple, type(None))])
+        _validation.append(["transaction_time", kwargs.get("transaction_time"), True, (datetime, str, type(None))])
+        _validation.append(["additional_period", kwargs.get("additional_period"), True, (tuple, type(None))])
+        _validation.append(["include_valid_time_column", kwargs.get("include_valid_time_column"), True, bool])
+        _validation.append(["include_transaction_time_column", kwargs.get("include_transaction_time_column"), True, bool])
+
+        # Validate argument types
+        _Validators._validate_function_arguments(_validation)
+
+        # Validate temporal table type.
+        _Validators._validate_temporal_table_type(self.df_type)
+
+        # Extract valid_time and transaction_time from kwargs.
+        valid_time = kwargs.get("valid_time")
+        transaction_time = kwargs.get("transaction_time")
+        additional_period = kwargs.get("additional_period")
+        include_valid_time_column = kwargs.get("include_valid_time_column")
+        include_transaction_time_column = kwargs.get("include_transaction_time_column")
+
+        # Validate if user specifies valid_time for a transaction time table.
+        if "valid_time" in kwargs:
+            _Validators._validate_as_of_arguments(df_type=self.df_type)
+
+        # Validate if user specifies transaction_time for a valid time table.
+        if "transaction_time" in kwargs:
+            _Validators._validate_as_of_arguments(df_type=self.df_type, argument_name='transaction_time')
+
+        add_vt_period = False
+
+        # Generate the time qualifier clause.
+        if "valid_time" in kwargs and "transaction_time" not in kwargs:
+            clause = self.__get_valid_time_clause(valid_time, additional_period)
+        elif "transaction_time" in kwargs and "valid_time" not in kwargs:
+            clause = self.__get_transaction_time_clause(transaction_time)
+        else:
+            # Generate both clauses.
+            clause = "{} AND {}".format(self.__get_valid_time_clause(valid_time, additional_period),
+                                        self.__get_transaction_time_clause(transaction_time)
+                                        )
+
+        # Exclude the time dimension columns if user is not willing to see it in output DF.
+        columns_to_exclude = []
+        if not include_valid_time_column and self._valid_time_column:
+            columns_to_exclude.append(self._valid_time_column.name)
+
+        if not include_transaction_time_column and self._transaction_time_column:
+            columns_to_exclude.append(self._transaction_time_column.name)
+
+        columns = [col for col in self.columns if col not in columns_to_exclude]
+        col_names_types = df_utils._get_required_columns_types_from_metaexpr(self._metaexpr, columns)
+
+        # Notes:
+        #   * If valid_time is tuple, i.e., for valid time qualifier SEQUENCED VALIDTIME,
+        #     add additional column VALIDTIME. This column should not be present in SELECT statement.
+        #     Also, ValidTime dimension column should not be present in SELECT statement. VALIDTIME column
+        #     acts as validTime dimension column here.
+        #   * Time qualifier NONSEQUENCED VALIDTIME PERIOD clause also produces additional column VALIDTIME.
+        #     Hence, add additional column VALIDTIME also returned in the output DataFrame. However, valid time
+        #     column can exist in SELECT statement.
+        if isinstance(valid_time, tuple):
+            add_vt_period = True
+            columns = [col for col in columns if col != self._valid_time_column.name]
+            col_names_types = df_utils._get_required_columns_types_from_metaexpr(self._metaexpr, columns)
+            col_names_types["VALIDTIME"] = self._valid_time_column.type
+        elif (isinstance(valid_time, type(None)) and additional_period is not None):
+            col_names_types = df_utils._get_required_columns_types_from_metaexpr(self._metaexpr, columns)
+            col_names_types["VALIDTIME"] = self._valid_time_column.type
+
+        # SELECT Node.
+        column_expression = ", ".join(columns)
+        sel_nodeid = self._aed_utils._aed_select(self._nodeid, column_expression, timestamp_expr=clause)
+
+        # Constructing new Metadata (_metaexpr) without DB; using dummy select_nodeid and underlying table name.
+        new_metaexpr = UtilFuncs._get_metaexpr_using_columns(sel_nodeid, col_names_types.items())
+        df = self._create_dataframe_from_node(sel_nodeid, new_metaexpr, self._index_label)
+
+        # If time qualifier is SEQUENCED PERIOD, then add VALIDTIME column to DataFrame
+        # since it produces temporal dataset.
+        if add_vt_period:
+            df._valid_time_column = df['VALIDTIME']
+
+        return df
+
+    def __get_valid_time_clause(self, valid_time, additional_period=None):
+        """
+        DESCRIPTION:
+            Function to get valid time clause for temporal table.
+
+        PARAMETERS:
+            valid_time:
+                Required Argument.
+                Specifies the valid time dimension to represent temporal data when creating the DataFrame.
+                Types: date or str
+
+            additional_period:
+                Optional Argument.
+                Specifies the additional period to be kept in DataFrame.
+                Note:
+                    This is applicable only when "valid_time" is None.
+                Types: tuple of date or str
+
+        RETURNS:
+            str
+
+        RAISES:
+            None.
+        """
+        is_vt_dt_type = isinstance(self._valid_time_column.type, tdtypes.PERIOD_DATE)
+        if valid_time == "current":
+            return "CURRENT VALIDTIME"
+
+        if isinstance(valid_time, (str, date, datetime)):
+            # If valid_time is a string, then check what is the type of temporal column.
+            # ValidTime dimension allows both DATE and TIMESTAMP type for ValidTime dimension
+            # columns.
+            if is_vt_dt_type:
+                return "VALIDTIME AS OF DATE '{}'".format(valid_time)
+            return "VALIDTIME AS OF TIMESTAMP '{}'".format(valid_time)
+
+        # If valid_time is a tuple, then it is a period.
+        # User can specify start and/or end time. Derive missing value.
+        if isinstance(valid_time, tuple):
+            start = valid_time[0]
+            end = valid_time[1]
+            start = ("0001-01-01" if is_vt_dt_type else '0001-01-01 00:00:00.000000+00:00') if start is None else str(
+                start)
+            end = ("9999-12-31" if is_vt_dt_type else '9999-12-31 23:59:59.999999+00:00') if end is None else str(end)
+            return "SEQUENCED VALIDTIME PERIOD '({}, {})'".format(start, end)
+
+        if isinstance(valid_time, type(None)) and additional_period is not None:
+            return "NONSEQUENCED VALIDTIME PERIOD '({}, {})'".format(additional_period[0], additional_period[1])
+
+        return "NONSEQUENCED VALIDTIME"
+
+    def __get_transaction_time_clause(self, transaction_time):
+        """
+        DESCRIPTION:
+            Function to get transaction time clause for temporal table.
+
+        PARAMETERS:
+            transaction_time:
+                Required Argument.
+                Specifies the transaction time dimension to represent temporal data when creating the DataFrame.
+                Types: date or str
+
+        RETURNS:
+            str
+
+        RAISES:
+            None.
+        """
+        if transaction_time == "current":
+            return "CURRENT TRANSACTIONTIME"
+
+        if isinstance(transaction_time, type(None)):
+            return "NONSEQUENCED TRANSACTIONTIME"
+
+        return "TRANSACTIONTIME as of timestamp '{}'".format(transaction_time)
+
+    def _generate_temporal_dataframe(self, timestamp_expr, time_column):
+        """
+        DESCRIPTION:
+            Helper method to generate a temporal DataFrame based on the given timestamp expression.
+
+        PARAMETERS:
+            timestamp_expr:
+                Required Argument.
+                Specifies the timestamp expression to filter the temporal data.
+                Types: str
+
+            time_column:
+                Required Argument.
+                Specifies the temporal column (valid-time or transaction-time) to process.
+                Types: ColumnExpression
+
+        RAISES:
+            None.
+
+        RETURNS:
+            teradataml DataFrame
+        """
+        col_expr = "{} as {}".format(time_column.cast(time_column.type).compile(), time_column.name)
+        cols = [col.name if col.name != time_column.name else col_expr for col in self._metaexpr.c]
+        column_expression = ", ".join(cols)
+        sel_node_id = self._aed_utils._aed_select(self._nodeid, column_expression, timestamp_expr=timestamp_expr)
+        return self._create_dataframe_from_node(sel_node_id, self._metaexpr, self._index_label)
+
+    def historic_rows(self):
+        """
+        DESCRIPTION:
+            Retrieves historical rows from a DataFrame created on a valid-time
+            or bi-temporal table/view. Historical rows are defined as those where the
+            end of the valid-time period precedes the current time.
+
+        PARAMETERS:
+            None.
+
+        RETURNS:
+            teradataml DataFrame.
+
+        RAISES:
+            TeradataMLException.
+
+        EXAMPLES:
+            # Load the data to run the example.
+            >>> load_example_data("teradataml", "Employee_roles")
+
+            # Create a DataFrame on 'Employee_roles' table.
+            >>> df = DataFrame("Employee_roles")
+
+            # Retrieve historic rows from the DataFrame.
+            >>> df.historic_rows()
+            EmployeeID    EmployeeName    Department    Salary          role_validity_period
+                     1        John Doe            IT     100.0      ('20/01/01', '24/12/31')
+                     3             Bob         Sales     300.0      ('24/01/01', '24/12/31')
+        """
+
+        from teradataml.dataframe.functions import current_date, current_timestamp
+        # Validate temporal table type.
+        _Validators._validate_temporal_table_type(self.df_type)
+        valid_time_col = self._valid_time_column
+        df = self._generate_temporal_dataframe("NONSEQUENCED VALIDTIME", valid_time_col)
+        # Check the type of the ValidTime dimension column
+        if isinstance(valid_time_col.type, tdtypes.PERIOD_DATE):
+            # Filter records where the end of the ValidTime period is less than the current date
+            return df[valid_time_col.end() < current_date()]
+        return df[valid_time_col.end() < current_timestamp()]
+
+    def future_rows(self):
+        """
+        DESCRIPTION:
+            Retrieves future rows from a DataFrame created on a valid-
+            time or bi-temporal table/view. Future rows are defined as those where the
+            start of the valid-time period is greater than the current time.
+
+        PARAMETERS:
+            None.
+
+        RETURNS:
+            teradataml DataFrame.
+
+        RAISES:
+            TeradataMLException.
+
+        EXAMPLES:
+            # Load the data to run the example.
+            >>> load_example_data("teradataml", "Employee_roles")
+
+            # Create a DataFrame on 'Employee_roles' table.
+            >>> df = DataFrame("Employee_roles")
+
+            # Retrieve future rows from the DataFrame.
+            >>> df.future_rows()
+            EmployeeID   EmployeeName   Department   Salary         role_validity_period
+                     3            Bob    Marketing    330.0     ('29/01/01', '99/12/31')
+        """
+        from teradataml.dataframe.functions import current_date, current_timestamp
+        # Validate temporal table type.
+        _Validators._validate_temporal_table_type(self.df_type)
+        valid_time_col = self._valid_time_column
+        df = self._generate_temporal_dataframe("NONSEQUENCED VALIDTIME", valid_time_col)
+        # Check the type of the ValidTime dimension column
+        if isinstance(valid_time_col.type, tdtypes.PERIOD_DATE):
+            # Filter records where the start of the ValidTime period is greater than the current date
+            return df[valid_time_col.begin() > current_date()]
+        return df[valid_time_col.begin() > current_timestamp()]
+
+    def open_rows(self):
+        """
+        DESCRIPTION:
+            Retrieves open rows from a DataFrame created on a transaction-time
+            or bi-temporal table/view. Open rows are defined as those where the
+            end of the transaction-time period is greater than or equal to the current time.
+
+        PARAMETERS:
+            None.
+
+        RETURNS:
+            teradataml DataFrame.
+
+        RAISES:
+            TeradataMLException.
+
+        EXAMPLES:
+            # Load the data to run the example.
+            >>> load_example_data("teradataml", "Employee_address")
+
+            # Create a DataFrame on 'Employee_address' table.
+            >>> df = DataFrame("Employee_address")
+
+            # Retrieve open rows from the DataFrame.
+            >>> df.open_rows()
+            EmployeeID       EmployeeName        address                                                           validity_period
+                     1           John Doe    123 Main St  ('2025-03-04 15:41:44.610000+00:00', '9999-12-31 23:59:59.999999+00:00')
+                     2         Jane Smith     456 Elm St  ('2025-03-04 15:41:44.610000+00:00', '9999-12-31 23:59:59.999999+00:00')
+        """
+        from teradataml.dataframe.functions import current_timestamp
+        # Validate temporal table type.
+        _Validators._validate_temporal_table_type(self.df_type)
+        transaction_time_col = self._transaction_time_column
+        df = self._generate_temporal_dataframe("NONSEQUENCED TRANSACTIONTIME", transaction_time_col)
+        return df[transaction_time_col.end() >= current_timestamp()]
+
+    def closed_rows(self):
+        """
+        DESCRIPTION:
+            Retrieves closed rows from a DataFrame created on a transaction-time
+            or bi-temporal table/view. Closed rows are defined as those where the
+            end  of the transaction-time period is less than the current time.
+
+        PARAMETERS:
+            None.
+
+        RETURNS:
+            teradataml DataFrame.
+
+        RAISES:
+            TeradataMLException.
+
+        EXAMPLES:
+            # Load the data to run the example.
+            >>> load_example_data("teradataml", "Employee_address")
+
+            # Create a DataFrame on 'Employee_address' table.
+            >>> df = DataFrame("Employee_address")
+
+            # Retrieve closed rows from the DataFrame.
+            >>> df.closed_rows()
+            EmployeeID    EmployeeName      address                                                           validity_period
+                     1        John Doe  123 Main St  ('2025-03-04 15:41:44.610000+00:00', '2025-04-01 23:59:59.999999+00:00')
+        """
+        from teradataml.dataframe.functions import current_timestamp
+        # Validate temporal table type.
+        _Validators._validate_temporal_table_type(self.df_type)
+        transaction_time_col = self._transaction_time_column
+        df = self._generate_temporal_dataframe("NONSEQUENCED TRANSACTIONTIME", transaction_time_col)
+        return df[transaction_time_col.end() < current_timestamp()]
+
+    @collect_queryband(queryband="DF_create_view")
+    def create_view(self, view_name, schema_name=None):
+        """
+        Creates a view from the DataFrame object in the specified schema.
+        As teradataml creates views, internally for operations, which will be garbage
+        collected during remove_context(), this function helps the user to persist the
+        DataFrame as a view.
+        Note:
+            The persisted view can be used across sessions and can be accessed
+            using the view_name and schema_name.
+
+        PARAMETERS:
+            view_name:
+                Required Argument.
+                Specifies the name of the view to be persisted.
+                Types: str
+
+            schema_name:
+                Optional Argument.
+                Specifies the schema name where the view is to be persisted.
+                Note:
+                    If the schema_name is not provided, the current database will be used.
+                Types: str
+
+        RETURNS:
+            Persisted teradataml DataFrame.
+
+        RAISES:
+            TeradataMlException
+        
+        EXAMPLES:
+            # Load the data to run the example.
+            >>> load_example_data("antiselect", ["antiselect_input"])
+            >>> antiselect_input = DataFrame.from_table("antiselect_input")
+            >>> antiselect_input
+                    orderid orderdate       priority  quantity       sales  discount        shipmode            custname province   region     custsegment          prodcat
+            rowids
+            49          293  12/10/01           high        49  10123.0200      0.07  delivery truck        barry french  nunavut  nunavut        consumer  office supplies
+            97          613  11/06/17           high        12     93.5400      0.03     regular air        carl jackson  nunavut  nunavut       corporate  office supplies
+            85          515  10/08/28  not specified        19    394.2700      0.08     regular air      carlos soltero  nunavut  nunavut        consumer  office supplies
+            86          515  10/08/28  not specified        21    146.6900      0.05     regular air      carlos soltero  nunavut  nunavut        consumer        furniture
+            1             3  10/10/13            low         6    261.5400      0.04     regular air  muhammed macintyre  nunavut  nunavut  small business  office supplies
+            50          293  12/10/01           high        27    244.5700      0.01     regular air        barry french  nunavut  nunavut        consumer  office supplies
+            80          483  11/07/10           high        30   4965.7595      0.08     regular air       clay rozendal  nunavut  nunavut       corporate       technology
+
+            # Filter the data based on quantity.
+            >>> anti_df = antiselect_input[antiselect_input.quantity < 30]
+            >>> anti_df
+                    orderid orderdate       priority  quantity   sales  discount     shipmode            custname province   region     custsegment          prodcat
+            rowids
+            97          613  11/06/17           high        12   93.54      0.03  regular air        carl jackson  nunavut  nunavut       corporate  office supplies
+            86          515  10/08/28  not specified        21  146.69      0.05  regular air      carlos soltero  nunavut  nunavut        consumer        furniture
+            85          515  10/08/28  not specified        19  394.27      0.08  regular air      carlos soltero  nunavut  nunavut        consumer  office supplies
+            1             3  10/10/13            low         6  261.54      0.04  regular air  muhammed macintyre  nunavut  nunavut  small business  office supplies
+            50          293  12/10/01           high        27  244.57      0.01  regular air        barry french  nunavut  nunavut        consumer  office supplies
+
+            # Run Antiselect on filtered data. This will create temporary view which will be garbage collected.
+            >>> obj = Antiselect(data=anti_df, exclude=['rowids', 'orderdate', 'discount', 'province', 'custsegment'])
+            
+            # Get the view name that is internally created by teradataml to store the result of Antiselect.
+            >>> obj.result.db_object_name
+            '"<schema_name>"."ml__td_sqlmr_out__1752582812690000"'
+
+            # Check the output of Antiselect.
+            >>> obj.result
+            orderid       priority  quantity   sales     shipmode            custname   region          prodcat
+            0      613           high        12   93.54  regular air        carl jackson  nunavut  office supplies
+            1      515  not specified        21  146.69  regular air      carlos soltero  nunavut        furniture
+            2      515  not specified        19  394.27  regular air      carlos soltero  nunavut  office supplies
+            3      293           high        27  244.57  regular air        barry french  nunavut  office supplies
+            4        3            low         6  261.54  regular air  muhammed macintyre  nunavut  office supplies
+
+            # Describe the resultant DataFrame.
+            >>> df = obj.result.describe() # This will create a temporary view.
+            
+            # Get the view name.
+            >>> df.db_object_name
+            '"<schema_name>"."ml__td_sqlmr_out__1752585435339977"'
+
+            # Check the output of describe.
+            >>> df
+              ATTRIBUTE            StatName   StatValue
+            0   orderid             MAXIMUM  613.000000
+            1   orderid  STANDARD DEVIATION  245.016734
+            2   orderid     PERCENTILES(25)  293.000000
+            3   orderid     PERCENTILES(50)  515.000000
+            4  quantity               COUNT    5.000000
+            5  quantity             MINIMUM    6.000000
+            6  quantity             MAXIMUM   27.000000
+            7  quantity                MEAN   17.000000
+            8  quantity  STANDARD DEVIATION    8.154753
+            9  quantity     PERCENTILES(25)   12.000000
+
+            # Example 1: Persist the view which can be accessed across sessions.
+            >>> df_new = df.create_view(view_name="antiselect_describe_view")
+            >>> df_new
+              ATTRIBUTE            StatName   StatValue
+            0  quantity             MAXIMUM   27.000000
+            1  quantity  STANDARD DEVIATION    8.154753
+            2  quantity     PERCENTILES(25)   12.000000
+            3  quantity     PERCENTILES(50)   19.000000
+            4     sales               COUNT    5.000000
+            5     sales             MINIMUM   93.540000
+            6   orderid               COUNT    5.000000
+            7   orderid             MINIMUM    3.000000
+            8   orderid             MAXIMUM  613.000000
+            9   orderid                MEAN  387.800000
+
+            # Get the view name.
+            >>> df_new.db_object_name # "<schema_name>" is user connected database.
+            '"<schema_name>"."antiselect_describe_view"'
+
+        """
+        # Argument validation
+        arg_info_matrix = []
+        arg_info_matrix.append(["view_name", view_name, False, (str,), True])
+        arg_info_matrix.append(["schema_name", schema_name, True, (str,), True])
+        _Validators._validate_missing_required_arguments(arg_info_matrix)
+        _Validators._validate_function_arguments(arg_info_matrix)
+
+        # TODO: Investigate and identify issue when volatile tables replaces views in future.
+
+        visited = set()
+        to_persist = []
+        is_teradataml_temp_table = lambda x: x.startswith("ml__") or x.startswith("tdml_")
+        sql_bundle = SQLBundle()
+
+        def trace_views(table_name):
+            if table_name in visited:
+                return
+            visited.add(table_name)
+            base_name = UtilFuncs._extract_table_name(full_qualified_name=table_name)
+            if is_teradataml_temp_table(base_name):
+                to_persist.append(table_name)
+                # Try to get the SQL for the view
+                show_view_sql = sql_bundle._get_sql_query(SQLConstants.SQL_SHOW_VIEW).\
+                    format(table_name)
+                try:
+                    result = execute_sql(show_view_sql).fetchall()
+                    if result:
+                        view_sql = result[0][0].replace("\r", "").replace("\n", " ")\
+                            .replace("\t", " ").strip()
+
+                        # Extract all table names from the view SQL
+                        for tname in UtilFuncs.extract_table_names_from_query(view_sql):
+                            trace_views(tname)
+                except Exception as e:
+                    # Check if error is like 'not a view', then try SHOW TABLE
+                    err_msg = str(e).lower()
+                    if 'not a view' in err_msg:
+                        show_table_sql = sql_bundle._get_sql_query(SQLConstants.SQL_SHOW_TABLE).\
+                            format(table_name)
+                        try:
+                            result = execute_sql(show_table_sql).fetchall()
+                            if result:
+                                # Table found, nothing to trace further.
+                                # This table is persisted.
+                                return
+                        except Exception as e2:
+                            # If SHOW TABLE also fails, raise the exception
+                            raise e2
+                    else:
+                        # If error is not about 'not a view', re-raise
+                        raise e
+
+        # 1. Get the query for this DataFrame
+        query = self.show_query()
+        # 2. Extract all table names from the query
+        for tname in UtilFuncs.extract_table_names_from_query(query):
+            trace_views(tname)
+
+        # 3.. Persist the current DataFrame as a permanent object
+        # This CREATE VIEW AS SELECT ...
+        # Use object_name, schema_name as needed.
+        from teradataml.dbutils.dbutils import _get_quoted_object_name
+        target_name = _get_quoted_object_name(schema_name=schema_name, object_name=view_name)
+        
+        create_sql = sql_bundle._build_create_view(view_name=target_name,
+                                                    select_expression=query)
+    
+        # No try-except here, as we want to raise any error that occurs during execution.
+        execute_sql(create_sql)
+
+        # TODO: Add logger message that these views/tables persisted.
+        # if to_persist:
+        #     logger.info("to_persist: ", to_persist)
+
+        # Remove the tables/view from GC file as we need to persist them. Removing only after
+        # required object is created.
+        GarbageCollector._delete_object_entry(objects_to_delete=to_persist,
+                                              object_type=None,
+                                              remove_entry_from_gc_list=True)
+
+        # Return the teradataml DataFrame for the persisted object.
+        if schema_name is None:
+            schema_name = tdmlctx._get_current_databasename()
+        return DataFrame(in_schema(schema_name=schema_name, table_name=view_name))
+
+
 class DataFrameGroupBy(DataFrame):
     """
     This class integrate GroupBy clause with AED.
@@ -16382,8 +17501,8 @@ class DataFrameGroupBy(DataFrame):
             include_grouping_columns:
                 Optional Argument.
                 Specifies whether to include aggregations on the grouping column(s) or not.
-                When set to True, the resultant DataFrame will have the aggregations on the 
-                columns mentioned in "columns". Otherwise, resultant DataFrame will not have 
+                When set to True, the resultant DataFrame will have the aggregations on the
+                columns mentioned in "columns". Otherwise, resultant DataFrame will not have
                 aggregations on the columns mentioned in "columns".
                 Default Value: False
                 Types: bool
@@ -16483,7 +17602,8 @@ class DataFrameGroupBy(DataFrame):
 
         new_meta = UtilFuncs._get_metaexpr_using_columns(new_nodeid,
                                                          zip(new_column_names,
-                                                             new_column_types))
+                                                             new_column_types),
+                                                         datalake=self._metaexpr.datalake)
 
         return (new_meta, new_nodeid)