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

teradataml/dataframe/dataframe.py

@@ -12,63 +12,74 @@ This file implements the teradataml dataframe.
 A teradataml dataframe maps virtually to teradata tables and views.
 """
 import decimal
-import inspect, itertools
+import inspect
+import itertools
 import json
 import numbers
-import pandas as pd
 import re
-import sqlalchemy
 import sys
 import urllib.parse
+from collections import OrderedDict
+from collections.abc import Iterator
 
+import numpy as np
+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,
+                                      PERIOD_TIMESTAMP, SMALLINT, _TDType)
 
 import teradataml.context.context as tdmlctx
-
-from collections import OrderedDict, namedtuple
-from sqlalchemy.sql import ClauseElement
-from teradataml import execute_sql
-from teradataml import GarbageCollector
-from teradataml.dataframe.sql import _MetaExpression
-from teradataml.dataframe.sql_interfaces import ColumnExpression
-from teradataml.dataframe.sql_functions import case
-from teradataml.series.series import Series
-from teradatasqlalchemy.types import _TDType, BIGINT, INTEGER, PERIOD_TIMESTAMP, SMALLINT, BYTEINT, FLOAT, DECIMAL
-from teradataml.common.deprecations import argument_deprecation
-from teradataml.common.utils import UtilFuncs
+from teradataml import GarbageCollector, execute_sql
+from teradataml.common.bulk_exposed_utils import \
+    _validate_unimplemented_function
+from teradataml.common.constants import (AEDConstants, DataFrameTypes, OutputStyle,
+                                         PTITableConstants, PythonTypes,
+                                         SourceType, SQLConstants,
+                                         SQLFunctionConstants,
+                                         TableOperatorConstants,
+                                         TeradataConstants, TeradataTypes)
 from teradataml.common.exceptions import TeradataMlException
-from teradataml.common.messages import Messages
 from teradataml.common.messagecodes import MessageCodes
-from teradataml.common.constants import AEDConstants
-from teradataml.common.constants import SourceType, PythonTypes, TeradataConstants, \
-    TeradataTypes, PTITableConstants, TableOperatorConstants, SQLFunctionConstants
-from teradataml.dataframe.dataframe_utils import DataFrameUtils as df_utils, DataFrameUtils
-from teradataml.dataframe.indexer import _LocationIndexer
-from teradataml.common.aed_utils import AedUtils
-from teradataml.options.display import display
-from teradataml.options.configure import configure
+from teradataml.common.messages import Messages
+from teradataml.common.sqlbundle import SQLBundle
+from teradataml.common.utils import UtilFuncs
 from teradataml.dataframe.copy_to import copy_to_sql
+from teradataml.dataframe.data_transfer import _DataTransferUtils
+from teradataml.dataframe.dataframe_utils import DataFrameUtils
+from teradataml.dataframe.dataframe_utils import DataFrameUtils as df_utils
+from teradataml.dataframe.indexer import _LocationIndexer
 from teradataml.dataframe.row import _Row
 from teradataml.dataframe.setop import concat
+from teradataml.dataframe.sql import _MetaExpression
+from teradataml.dataframe.sql_functions import case
+from teradataml.dataframe.sql_interfaces import ColumnExpression
+from teradataml.dataframe.window import Window
 from teradataml.dbutils.dbutils import list_td_reserved_keywords
+from teradataml.options.configure import configure
+from teradataml.options.display import display
 from teradataml.plot.plot import _Plot
 from teradataml.scriptmgmt.UserEnv import UserEnv
-from teradataml.utils.dtypes import _Dtypes, _ListOf, _TupleOf
-from teradataml.utils.validators import _Validators
+from teradataml.series.series import Series
 from teradataml.table_operators.table_operator_util import _TableOperatorUtils
-from teradatasqlalchemy.dialect import preparer, dialect as td_dialect
-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 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
+from teradataml.utils.dtypes import _Dtypes, _ListOf, _TupleOf
+from teradataml.utils.validators import _Validators
+
+# Adding imports at the end to avoid circular imports.
+from teradataml.common.aed_utils import AedUtils
 
 # TODO use logger when available on master branch
 # logger = teradatapylog.getLogger()
 
+
 class in_schema:
     """
     Class takes a schema name, a table name and datalake name attributes
@@ -149,26 +160,37 @@ class DataFrame():
     on tables, views, and queries on Teradata Vantage.
     """
 
-    def __init__(self, table_name=None, index=True, index_label=None, query=None, materialize=False):
+    def __init__(self, data=None, index=True, index_label=None, query=None, materialize=False, **kwargs):
         """
         Constructor for teradataml DataFrame.
 
         PARAMETERS:
-            table_name:
+            data:
                 Optional Argument.
-                The table name or view name in Teradata Vantage referenced by this DataFrame.
-                Types: str
+                Specifies the input data to create a teradataml DataFrame.
+                Notes:
+                    If a dictionary is provided, it must follow the below requirements:
+                        * Keys must be strings (column names).
+                        * Values must be lists of equal length (column data).
+                        * Nested dictionaries are not supported.
+                Types: str OR pandas DataFrame OR in_schema OR numpy array OR list OR dictionary
 
             index:
                 Optional Argument.
-                True if using index column for sorting, otherwise False.
+                If "data" is a string, then the argument specifies whether to use the index column
+                for sorting or not.
+                If "data" is a pandas DataFrame, then this argument specifies whether to
+                save Pandas DataFrame index as a column or not.
                 Default Value: True
                 Types: bool
 
             index_label:
                 Optional Argument.
-                Column/s used for sorting.
-                Types: str OR list of Strings (str)
+                If "data" is a string, then the argument specifies column(s) used for sorting.
+                If "data" is a pandas DataFrame, then the default behavior is applied.
+                Note:
+                    * Refer to the "index_label" parameter of copy_to_sql() for details on the default behaviour.
+                Types: str OR list of str
 
             query:
                 Optional Argument.
@@ -187,29 +209,136 @@ class DataFrame():
                 Default Value: False (No materialization)
                 Types: bool
 
+            kwargs:
+                table_name:
+                    Optional Argument.
+                    The table name or view name in Teradata Vantage referenced by this DataFrame.
+                    Note:
+                        * If "data" and "table_name" are both specified, then the "table_name" argument is ignored.
+                    Types: str or in_schema
+
+                primary_index:
+                    Optional Argument.
+                    Specifies which column(s) to use as primary index for the teradataml DataFrame.
+                    Note:
+                        * This argument is only applicable when creating a DataFrame from a pandas DataFrame.
+                    Types: str OR list of str
+
+                types:
+                    Optional Argument.
+                    Specifies required data types for requested columns to be saved in Teradata Vantage.
+                    Notes:
+                        * This argument is not applicable when "data" argument is of type str or in_schema.
+                        * Refer to the "types" parameter of copy_to_sql() for more details.
+                    Types: dict
+
+                columns:
+                    Optional Argument.
+                    Specifies the names of the columns to be used in the DataFrame.
+                    Notes:
+                        * This argument is not applicable when "data" argument is of type str or in_schema.
+                        * If "data" is a dictionary and this argument is specified, only the specified columns will be
+                          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
+            >>> from teradataml.dataframe.dataframe import DataFrame
+            >>> import pandas as pd
 
-            # Example 1: The following example creates a DataFrame from the 'table_name'
-            #            or 'view_name'.
-            # Created DataFrame using table name.
-            df = DataFrame("mytab")
+            # Example 1: Create a teradataml DataFrame from table name.
+            >>> df = DataFrame("mytab")
 
-            # Created DataFrame using view name.
-            df = DataFrame("myview")
+            # Example 2: Create a teradataml DataFrame from view name.
+            >>> df = DataFrame("myview")
 
-            # Created DataFrame using view name without using index column for sorting.
-            df = DataFrame("myview", False)
+            # Example 3: Create a teradataml DataFrame using view name without using index column for sorting.
+            >>> df = DataFrame("myview", False)
 
-            # Created DataFrame using table name and sorted using Col1 and Col2
-            df = DataFrame("mytab", True, "Col1, Col2")
+            # Example 4: Create a teradataml DataFrame using table name and consider columns Col1 and Col2
+            #            while running DataFrame.head() or DataFrame.tail() methods.
+            >>> df = DataFrame("mytab", True, ["Col1", "Col2"])
 
+            # Example 5: Create a teradataml DataFrame from the existing Vantage table "dbcinfo"
+            #            in the non-default database "dbc" using the in_schema() object.
+            >>> from teradataml.dataframe.dataframe import in_schema
+            >>> df = DataFrame(in_schema("dbc", "dbcinfo"))
 
-            # Example 2: The following example creates a DataFrame from the existing Vantage
-            #            table "dbcinfo" in the non-default database "dbc" using the
-            #            in_schema() function.
-            from teradataml.dataframe.dataframe import in_schema
-            df = DataFrame(in_schema("dbc", "dbcinfo"))
+            # Example 6: Create a teradataml DataFrame from a pandas DataFrame.
+            >>> pdf = pd.DataFrame({"col1": [1, 2, 3], "col2": [4, 5, 6]})
+            >>> df = DataFrame(pdf)
+            >>> df
+               col1  col2  index_label
+            0     3     6            2
+            1     2     5            1
+            2     1     4            0
+
+            # Example 7: Create a teradataml DataFrame from a pandas DataFrame without index column.
+            >>> pdf = pd.DataFrame({"col1": [1, 2, 3], "col2": [4, 5, 6]})
+            >>> df = DataFrame(data=pdf, index=False)
+            >>> df
+               col1  col2
+            0     3     6
+            1     2     5
+            2     1     4
+
+            # Example 8: Create a teradataml DataFrame from a pandas DataFrame with
+            #            index label and primary index as 'id'.
+            >>> pdf = pd.DataFrame({"col1": [1, 2, 3], "col2": [4, 5, 6]})
+            >>> df = DataFrame(pdf, index=True, index_label='id', primary_index='id')
+            >>> df
+                col1  col2
+            id
+            2      3     6
+            1      2     5
+            0      1     4
+
+            # Example 9: Create a teradataml DataFrame from list of lists.
+            >>> df = DataFrame([[1, 2], [3, 4]])
+            >>> df
+               col_0  col_1  index_label
+            0      3      4            1
+            1      1      2            0
+
+            # Example 10: Create a teradataml DataFrame from numpy array.
+            >>> import numpy as np
+            >>> df = DataFrame(np.array([[1, 2], [3, 4]]), index=True, index_label="id")
+            >>> df
+                col_0  col_1
+            id
+            1       3      4
+            0       1      2
+
+            # Example 11: Create a teradataml DataFrame from a dictionary.
+            >>> df = DataFrame({"col1": [1, 2], "col2": [3, 4]}, index=True, index_label="id")
+            >>> df
+                col1  col2
+            id
+            1      2     4
+            0      1     3
+
+            # Example 12: Create a teradataml DataFrame from list of dictionaries.
+            >>> df = DataFrame([{"col1": 1, "col2": 2}, {"col1": 3, "col2": 4}], index=False)
+            >>> df
+                col1  col2
+            0      3     4
+            1      1     2
+
+            # Example 13: Create a teradataml DataFrame from list of tuples.
+            >>> df = DataFrame([("Alice", 1), ("Bob", 2)])
+            >>> df
+                  col_0  col_1  index_label
+            0     Alice      1            1
+            1       Bob      2            0
 
         RAISES:
             TeradataMlException - TDMLDF_CREATE_FAIL
@@ -248,17 +377,39 @@ 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
-
-        if isinstance(table_name, in_schema):
-            self._table = table_name.table_name
-            self._datalake = table_name.datalake_name
-            self._database = table_name.schema_name
+        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,
+        # datalake_name and schema_name to the DataFrame object.
+        schema_obj = data if isinstance(data, in_schema) else (
+                     table_name if data is None and isinstance(table_name, in_schema) else None)
+
+        if schema_obj:
+            self._table = schema_obj.table_name
+            self._datalake = schema_obj.datalake_name
+            self._database = schema_obj.schema_name
             self._otf = True if self._datalake else False
 
+        # Convert schema objects to strings.
+        data = str(data) if isinstance(data, in_schema) else data
         table_name = str(table_name) if isinstance(table_name, in_schema) else table_name
 
         # Below matrix is list of list, where in each row contains following elements:
@@ -277,18 +428,51 @@ class DataFrame():
         #   6. element6 --> A list of permitted values, an argument can accept.
         #                   If not specified, it is as good as passing None. If a list is passed, validation will be
         #                   performed for permitted values.
+
         awu_matrix = []
-        awu_matrix.append(["table_name", table_name, True, (str), True])
+        dtypes = (list, tuple, dict)
+        awu_matrix.append(["data", data, True, (str, pd.DataFrame, np.ndarray, dict, _ListOf(dtypes)), True])
         awu_matrix.append(["index", index, True, (bool)])
         awu_matrix.append(["index_label", index_label, True, (str, list)])
         awu_matrix.append(["query", query, True, (str), True])
         awu_matrix.append(["materialize", materialize, True, (bool)])
+        awu_matrix.append(["table_name", table_name, True, (str), True])
+        awu_matrix.append(["primary_index", primary_index, True, (str, list)])
+        awu_matrix.append(["types", types, True, (dict)])
+        awu_matrix.append(["columns", columns, True, (str, list), True])
 
         # Validate argument types
         _Validators._validate_function_arguments(awu_matrix)
 
+        # Convert columns to list if it is a string.
+        if isinstance(columns, str):
+            columns = [columns]
+
         try:
-            if table_name is not None:
+            if table_name is not None or data is not None:
+
+                #   If data is list or numpy array or dictionary, then convert it to a pandas DataFrame.
+                if isinstance(data, (list, np.ndarray, dict)):
+                    data = pd.DataFrame(data, columns=columns)
+                # If the data is a pandas DataFrame, then store the data in a temporary table in Vantage.
+                if isinstance(data, pd.DataFrame):
+                    # Create a copy of the pandas DataFrame to avoid modifying the original,
+                    # because column names will be changed if they are integers.
+                    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,
+                                                                gc_on_quit=not(persist))
+
+                    copy_to_sql(pd_data, table_name, index=index, index_label=index_label, primary_index=primary_index,
+                                types=types)
+                # If the data is a string, then set the table_name to the data.
+                elif isinstance(data, str):
+                    table_name = data
+
                 self._table_name = UtilFuncs._quote_table_names(table_name)
                 self._source_type = SourceType.TABLE.value
                 self._nodeid = self._aed_utils._aed_table(self._table_name)
@@ -329,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)
@@ -342,6 +528,12 @@ class DataFrame():
                     elif "[Error 3706] Syntax error" in str(oe):
                         raise ValueError(Messages.get_message(
                             MessageCodes.FROM_QUERY_SELECT_SUPPORTED).format("Check the syntax."))
+                    elif "[Error 7825]" in str(oe):
+                        # The UDF/XSP/UDM routine has thrown an SQLException
+                        # with an SQL state in the range of 38001-38999 which
+                        # is not a syntax error. Hence not a ValueError wrt query string.
+                        # Expected when OTF snapshot related query is executed.
+                        raise
                     raise ValueError(Messages.get_message(
                         MessageCodes.FROM_QUERY_SELECT_SUPPORTED))
 
@@ -351,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)
@@ -503,7 +696,7 @@ class DataFrame():
                 Types: str
 
         EXAMPLES:
-            >>> from teradataml.dataframe.dataframe import DataFrame
+            >>> from teradataml import DataFrame
 
             # Example 1: The following example creates a DataFrame from a table or
                          a view.
@@ -543,13 +736,13 @@ class DataFrame():
 
         """
         if schema_name:
-            return cls(in_schema(schema_name, table_name, datalake_name))
-
-        return cls(table_name, index, index_label)
+            return cls(table_name=in_schema(schema_name, table_name, datalake_name),
+                       index=index, index_label=index_label)
+        return cls(table_name=table_name, index=index, index_label=index_label)
 
     @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.
 
@@ -647,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.
@@ -692,6 +886,322 @@ class DataFrame():
             df.__setattr__(arg, arg_value)
         return df
 
+    @classmethod
+    @collect_queryband(queryband="DF_fromPandas")
+    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.
+
+        PARAMETERS:
+            pandas_df:
+                Required Argument.
+                Specifies the pandas DataFrame to be converted to teradataml DataFrame.
+                Types: pandas DataFrame
+
+            index:
+                Optional Argument.
+                Specifies whether to save Pandas DataFrame index as a column or not.
+                Default Value: True
+                Types: bool
+
+            index_label:
+                Optional Argument.
+                Specifies the column label(s) for Pandas DataFrame index column(s).
+                Note:
+                    * Refer to the "index_label" parameter of copy_to_sql() for more details.
+                Default Value: None
+                Types: str OR list of str
+
+            primary_index:
+                Optional Argument.
+                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
+
+        RAISES:
+            TeradataMlException
+
+        EXAMPLES:
+            >>> import pandas as pd
+            >>> from teradataml import DataFrame
+            >>> pdf = pd.DataFrame({"col1": [1, 2, 3], "col2": [4, 5, 6]})
+            >>> pdf1 = pd.DataFrame([[1, 2], [3, 4]])
+
+            # Example 1: Create a teradataml DataFrame from a pandas DataFrame.
+            >>> df = DataFrame.from_pandas(pdf)
+            >>> df
+               col1  col2  index_label
+            0     3     6            2
+            1     2     5            1
+            2     1     4            0
+
+            # Example 2: Create a teradataml DataFrame from a pandas DataFrame
+            #            and do not save the index as a column.
+            >>> df = DataFrame.from_pandas(pdf, index=False)
+            >>> df
+               col1  col2
+            0     3     6
+            1     2     5
+            2     1     4
+
+            # Example 3: Create a teradataml DataFrame from a pandas DataFrame
+            #            with index label as 'id' and set it as primary index.
+            >>> df = DataFrame.from_pandas(pdf, index=True, index_label='id', primary_index='id')
+            >>> df
+                col1  col2
+            id
+            2      3     6
+            1      2     5
+            0      1     4
+
+            # Example 4: Create a teradataml DataFrame from a pandas DataFrame where
+            #            columns are not explicitly defined in the pandas DataFrame.
+            >>> df = DataFrame.from_pandas(pdf1)
+            >>> df
+               col_0  col_1  index_label
+            0      3      4            1
+            1      1      2            0
+        """
+        # 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, persist=persist)
+
+    @classmethod
+    @collect_queryband(queryband="DF_fromDict")
+    def from_dict(cls, data, columns=None, persist=False):
+        """
+        DESCRIPTION:
+            Creates a DataFrame from a dictionary containing values as lists or numpy arrays.
+
+        PARAMETERS:
+            data:
+                Required Argument.
+                Specifies the Python dictionary to create a teradataml DataFrame.
+                Notes:
+                    * Keys of the dictionary are used as column names.
+                    * Values of the dictionary should be lists or numpy arrays.
+                    * Nested dictionaries are not supported.
+                Types: dict
+
+            columns:
+                Optional Argument.
+                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
+
+        RAISES:
+            TeradataMlException
+
+        EXAMPLES:
+            >>> from teradataml import DataFrame
+            >>> data_dict = {"name": ["Alice", "Bob", "Charlie"], "age": [25, 30, 28]}
+
+            # Example 1: Create a teradataml DataFrame from a dictionary where
+            #            keys are column names and values are lists of column data.
+            >>> df = DataFrame.from_dict(data_dict)
+            >>> df
+                  name  age
+            0  Charlie   28
+            1      Bob   30
+            2    Alice   25
+
+            # Example 2: Create a teradataml DataFrame from a dictionary where
+            #            keys are column names and values are numpy arrays.
+            >>> import numpy as np
+            >>> data_dict = {"col1": np.array([1, 2, 3]), "col2": np.array([4, 5, 6])}
+            >>> df = DataFrame.from_dict(data_dict)
+            >>> df
+               col1  col2
+            0     3     6
+            1     2     5
+            2     1     4
+        """
+        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, persist=persist)
+
+    @classmethod
+    @collect_queryband(queryband="DF_fromRecords")
+    def from_records(cls, data, columns=None, **kwargs):
+        """
+        DESCRIPTION:
+            Create a DataFrame from a list of lists/tuples/dictionaries/numpy arrays.
+
+        PARAMETERS:
+            data:
+                Required Argument.
+                Specifies the iterator of data or the list of lists/tuples/dictionaries/numpy arrays to
+                be converted to teradataml DataFrame.
+                Note:
+                    * Nested lists or tuples or dictionaries are not supported.
+                Types: Iterator, list
+
+            columns:
+                Optional Argument.
+                Specifies the column names for the DataFrame.
+                Note:
+                    * If the data is a list of lists/tuples/numpy arrays and this argument
+                      is not specified, column names will be auto-generated as 'col_0', 'col_1', etc.
+                Types: str OR list of str
+
+            kwargs:
+                exclude:
+                    Optional Argument.
+                    Specifies the columns to be excluded from the DataFrame.
+                    Types: list OR tuple
+
+                coerce_float:
+                    Optional Argument.
+                    Specifies whether to convert values of non-string, non-numeric objects (like decimal.Decimal)
+                    to floating point, useful for SQL result sets.
+                    Default Value: True
+                    Types: bool
+
+                nrows:
+                    Optional Argument.
+                    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
+
+        RAISES:
+            TeradataMlException
+
+        EXAMPLES:
+            >>> from teradataml import DataFrame
+
+            # Example 1: Create a teradataml DataFrame from a list of lists.
+            >>> df = DataFrame.from_records([['Alice', 1], ['Bob', 2]], columns=['name', 'age'])
+            >>> df
+                name  age
+            0    Bob    2
+            1  Alice    1
+
+            # Example 2: Create a teradataml DataFrame from a list of tuples.
+            >>> df = DataFrame.from_records([('Alice', 1), ('Bob', 3)], columns=['name', 'age'])
+            >>> df
+                name  age
+            0    Bob    3
+            1  Alice    1
+
+            # Example 3: Create a teradataml DataFrame from a list of dictionaries.
+            >>> df = DataFrame.from_records([{'name': 'Alice', 'age': 4}, {'name': 'Bob', 'age': 2}])
+            >>> df
+                name  age
+            0    Bob    2
+            1  Alice    4
+
+            # Example 4: Create a teradataml DataFrame from a list where columns
+            #            are not explicitly defined.
+            >>> df = DataFrame.from_records([['Alice', 1], ['Bob', 2]])
+            >>> df
+               col_0  col_1
+            0    Bob      2
+            1  Alice      1
+
+            # Example 5: Create a teradataml DataFrame from a list by excluding 'grade' column.
+            >>> df = DataFrame.from_records([['Alice', 1, 'A'], ['Bob', 2, 'B']],
+            ...                               columns=['name', 'age', 'grade'],
+            ...                               exclude=['grade'])
+            >>> df
+                name  age
+            0    Bob    2
+            1  Alice    1
+
+            # Example 6: Create a teradataml DataFrame from a list of lists
+            #            with "coerce_float" set to False.
+            >>> df = DataFrame.from_records([[1, Decimal('2.5')], [3, Decimal('4.0')]],
+            ...                              columns=['col1', 'col2'], coerce_float=False)
+            >>> df
+                col1  col2
+            0      3   4.0
+            1      1   2.5
+            >>> df.tdtypes
+            col1                                          BIGINT()
+            col2           VARCHAR(length=1024, charset='UNICODE')
+
+            # Example 7: Create a teradataml DataFrame from a list of lists
+            #            with "coerce_float" set to True.
+            >>> from decimal import Decimal
+            >>> df = DataFrame.from_records([[1, Decimal('2.5')], [3, Decimal('4.0')]],
+            ...                              columns=['col1', 'col2'], coerce_float=True)
+            >>> df
+               col1  col2
+            0     3   4.0
+            1     1   2.5
+            >>> df.tdtypes
+            col1           BIGINT()
+            col2            FLOAT()
+
+            # Example 8: Create a teradataml DataFrame from an iterator with "nrows" set to 2.
+            >>> def data_gen():
+            ...     yield ['Alice', 1]
+            ...     yield ['Bob', 2]
+            ...     yield ['Charlie', 3]
+            >>> df = DataFrame.from_records(data_gen(), columns=['name', 'age'], nrows=2)
+            >>> df
+                name  age
+            0    Bob    2
+            1  Alice    1
+        """
+
+        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)
+        arg_type_matrix.append(["data", data, False, (Iterator, _ListOf(dtypes)), True])
+        arg_type_matrix.append(["columns", columns, True, (str, _ListOf(str)), True])
+        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)
+
+        if isinstance(columns, str):
+            columns = [columns]
+
+        df = pd.DataFrame.from_records(data, columns=columns, exclude=exclude,
+                                       coerce_float=coerce_float, nrows=nrows)
+        return cls(df, index=False, persist=persist)
+
     def create_temp_view(self, name):
         """
         DESCRIPTION:
@@ -1084,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.
@@ -1136,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)
@@ -1149,12 +1711,22 @@ class DataFrame():
                                                    datalake=self._datalake)
 
         # Extract column names and corresponding teradatasqlalchemy types.
-        col_names, col_types = df_utils._get_datalake_table_columns_info(self._database,
-                                                                          self._table,
-                                                                          self._datalake)
+        try:
+            # For latest OTF help table query results.
+            col_names, col_types = df_utils._get_datalake_table_columns_info(self._database,
+                                                                             self._table,
+                                                                             self._datalake,
+                                                                             use_dialect=True)
+        except NoSuchColumnError:
+            # For older OTF help table query result.
+            col_names, col_types = df_utils._get_datalake_table_columns_info(self._database,
+                                                                             self._table,
+                                                                             self._datalake)
+
+        # 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):
         """
@@ -1693,8 +2265,150 @@ class DataFrame():
         td_metadata = [(column.name, repr(column.type)) for column in self._metaexpr.c]
         return MetaData(td_metadata)
 
-    @collect_queryband(queryband="DF_info")
-    def info(self, verbose=True, buf=None, max_cols=None, null_counts=False):
+    @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):
         """
         DESCRIPTION:
             Print a summary of the DataFrame.
@@ -5888,8 +6602,11 @@ class DataFrame():
                         groupby_col_names.append(col)
                         groupby_col_types.append(self[col].type)
 
-                        if col in col_names:
-                            # If group by column is not specified in the columns argument,
+                        include_grouping_columns = True if isinstance(self, DataFrameGroupBy) and \
+                                                           self._include_grouping_columns else False
+                        if not include_grouping_columns and col in col_names:
+                            # If 'include_grouping_columns' argument is set to True and,
+                            # group by column is not specified in the columns argument,
                             # then, we should ignore this processing, otherwise we
                             # should process it in the same way to remove the reference
                             # for grouping column from aggregation list.
@@ -5933,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)
 
@@ -6352,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:
@@ -7302,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)
@@ -8675,7 +9395,6 @@ class DataFrame():
 
         return df
 
-
     @collect_queryband(queryband="DF_get")
     def get(self, key):
         """
@@ -8785,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
@@ -8998,6 +9717,15 @@ class DataFrame():
                     Permitted Values: "CUBE", "ROLLUP", None
                     Types: str or NoneType
 
+                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
+                    aggregations on the columns mentioned in "columns_expr".
+                    Default Value: False
+                    Types: bool
+
         NOTES:
             1. Users can still apply teradataml DataFrame methods (filters/sort/etc) on top of the result.
             2. Consecutive operations of grouping, i.e., groupby_time(), resample() and groupby() are not permitted.
@@ -9014,14 +9742,54 @@ class DataFrame():
             TeradataMlException
 
         EXAMPLES:
+            # Load the data to run the example.
             >>> load_example_data("dataframe","admissions_train")
+
+            # Create a DataFrame on 'admissions_train' table.
             >>> df = DataFrame("admissions_train")
+            >>> df
+               masters   gpa     stats programming  admitted
+            id
+            15     yes  4.00  Advanced    Advanced         1
+            34     yes  3.85  Advanced    Beginner         0
+            13      no  4.00  Advanced      Novice         1
+            38     yes  2.65  Advanced    Beginner         1
+            5       no  3.44    Novice      Novice         0
+            40     yes  3.95    Novice    Beginner         0
+            7      yes  2.33    Novice      Novice         1
+            22     yes  3.46    Novice    Beginner         0
+            26     yes  3.57  Advanced    Advanced         1
+            17      no  3.83  Advanced    Advanced         1
+
+            # Example 1: Find the minimum value of all valid columns by
+            #            grouping the DataFrame with column 'masters'.
             >>> df1 = df.groupby(["masters"])
             >>> df1.min()
               masters min_id  min_gpa min_stats min_programming min_admitted
             0      no      3     1.87  Advanced        Advanced            0
             1     yes      1     1.98  Advanced        Advanced            0
 
+            # Example 2: Find the sum of all valid columns by grouping the DataFrame
+            #            with columns 'masters' and 'admitted'. Include grouping columns
+            #            in aggregate function 'sum'.
+            >>> df1 = df.groupby(["masters", "admitted"], include_grouping_columns=True)
+            >>> df1.sum()
+              masters  admitted  sum_id  sum_gpa  sum_admitted
+            0     yes         1     188    34.35            10
+            1     yes         0     289    43.36             0
+            2      no         0      41     6.44             0
+            3      no         1     302    57.52            16
+
+            # 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'.
+            >>> df1 = df.groupby(["masters", "admitted"], include_grouping_columns=False)
+            >>> df1.sum()
+              masters  admitted  sum_id  sum_gpa
+            0     yes         0     289    43.36
+            1      no         0      41     6.44
+            2      no         1     302    57.52
+            3     yes         1     188    34.35
         """
         # Argument validations
         arg_info_matrix = []
@@ -9029,6 +9797,8 @@ class DataFrame():
         option = kwargs.get("option", None)
         arg_info_matrix.append(["option", option, True, (str, type(None)), True,
                                 ["CUBE", "ROLLUP", None]])
+        include_grouping_columns = kwargs.get("include_grouping_columns", False)
+        arg_info_matrix.append(["include_grouping_columns", include_grouping_columns, True, (bool)])
 
         # Validate argument types
         _Validators._validate_function_arguments(arg_info_matrix)
@@ -9073,7 +9843,8 @@ class DataFrame():
 
             groupbyexpr = ', '.join(UtilFuncs._teradata_quote_arg(col, "\"", False) for col in column_list)
             groupbyObj = DataFrameGroupBy(self._nodeid, self._metaexpr, self._column_names_and_types, self.columns,
-                                          groupbyexpr, column_list, option)
+                                          groupbyexpr, column_list, option, include_grouping_columns)
+
             return groupbyObj
         except TeradataMlException:
             raise
@@ -11437,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.
@@ -12872,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:
@@ -13150,12 +13922,14 @@ class DataFrame():
                                                              False)
             column_names = list(dict.fromkeys(column_names))
 
-        if list_td_reserved_keywords(column_names) or UtilFuncs._is_ascii(column_names):
+        if list_td_reserved_keywords(column_names) or UtilFuncs._is_non_ascii(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)
-        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")
@@ -15336,7 +16110,7 @@ class DataFrame():
         return self.assign(**new_columns, drop_columns=True).select(self.columns)
 
     @collect_queryband(queryband="DF_cube")
-    def cube(self, columns):
+    def cube(self, columns, include_grouping_columns=False):
         """
         DESCRIPTION:
             cube() function creates a multi-dimensional cube for the DataFrame
@@ -15350,6 +16124,15 @@ class DataFrame():
                 Specifies the name(s) of input teradataml DataFrame column(s).
                 Types: str OR list of str(s)
 
+            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
+                aggregations on the columns mentioned in "columns".
+                Default Value: False
+                Types: bool
+
         RETURNS:
             teradataml DataFrameGroupBy
 
@@ -15357,9 +16140,27 @@ class DataFrame():
             TeradataMlException
 
         EXAMPLES :
-            # Example 1: Analyzes the data by grouping into masters and stats dimensions.
+            # Load the data to run the example.
             >>> load_example_data("dataframe","admissions_train")
+
+            # Create a DataFrame on 'admissions_train' table.
             >>> df = DataFrame("admissions_train")
+            >>> df
+               masters   gpa     stats programming  admitted
+            id
+            15     yes  4.00  Advanced    Advanced         1
+            34     yes  3.85  Advanced    Beginner         0
+            13      no  4.00  Advanced      Novice         1
+            38     yes  2.65  Advanced    Beginner         1
+            5       no  3.44    Novice      Novice         0
+            40     yes  3.95    Novice    Beginner         0
+            7      yes  2.33    Novice      Novice         1
+            22     yes  3.46    Novice    Beginner         0
+            26     yes  3.57  Advanced    Advanced         1
+            17      no  3.83  Advanced    Advanced         1
+
+            # Example 1: Find the sum of all valid columns by grouping the
+            #            DataFrame columns with 'masters' and 'stats'.
             >>> df1 = df.cube(["masters", "stats"]).sum()
             >>> df1
               masters     stats  sum_id  sum_gpa  sum_admitted
@@ -15374,10 +16175,42 @@ class DataFrame():
             8      no  Advanced     189    34.95             9
             9     yes    Novice      98    13.74             1
 
+            # 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'.
+            >>> df1 = df.cube(["masters", "admitted"], include_grouping_columns=True).avg()
+            >>> df1
+              masters  admitted     avg_id   avg_gpa  avg_admitted
+            0     yes       NaN  21.681818  3.532273      0.454545
+            1    None       1.0  18.846154  3.533462      1.000000
+            2      no       NaN  19.055556  3.553333      0.888889
+            3     yes       0.0  24.083333  3.613333      0.000000
+            4    None       NaN  20.500000  3.541750      0.650000
+            5    None       0.0  23.571429  3.557143      0.000000
+            6     yes       1.0  18.800000  3.435000      1.000000
+            7      no       1.0  18.875000  3.595000      1.000000
+            8      no       0.0  20.500000  3.220000      0.000000
+
+            # 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'.
+            >>> df1 = df.cube(["masters", "admitted"], include_grouping_columns=False).avg()
+            >>> df1
+              masters  admitted     avg_id   avg_gpa
+            0      no       0.0  20.500000  3.220000
+            1    None       1.0  18.846154  3.533462
+            2      no       NaN  19.055556  3.553333
+            3     yes       0.0  24.083333  3.613333
+            4    None       NaN  20.500000  3.541750
+            5    None       0.0  23.571429  3.557143
+            6     yes       1.0  18.800000  3.435000
+            7     yes       NaN  21.681818  3.532273
+            8      no       1.0  18.875000  3.595000
         """
         # Validate columns argument.
         arg_info_matrix = []
         arg_info_matrix.append(["columns", columns, False, (str, list), True])
+        arg_info_matrix.append(["include_grouping_columns", include_grouping_columns, False, bool])
 
         # Validate argument types
         _Validators._validate_function_arguments(arg_info_matrix)
@@ -15387,10 +16220,10 @@ class DataFrame():
 
         # Query generation of cube API is same as the group by.
         # Only 'cube' is concatenated with 'group by' clause.
-        return self.groupby(columns, option="cube")
+        return self.groupby(columns, option="cube", include_grouping_columns=include_grouping_columns)
 
     @collect_queryband(queryband="DF_rollup")
-    def rollup(self, columns):
+    def rollup(self, columns, include_grouping_columns=False):
         """
         DESCRIPTION:
             rollup() function creates a multi-dimensional rollup for the DataFrame
@@ -15404,6 +16237,15 @@ class DataFrame():
                 Specifies the name(s) of input teradataml DataFrame column(s).
                 Types: str OR list of str(s)
 
+            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
+                aggregations on the columns mentioned in "columns".
+                Default Value: False
+                Types: bool
+
         RETURNS:
             teradataml DataFrameGroupBy
 
@@ -15411,9 +16253,27 @@ class DataFrame():
             TeradataMlException
 
         EXAMPLES :
-            # Example 1: Analyzes the data by grouping into masters and stats dimensions.
+            # Load the data to run the example.
             >>> load_example_data("dataframe","admissions_train")
+
+            # Create a DataFrame on 'admissions_train' table.
             >>> df = DataFrame("admissions_train")
+            >>> df
+               masters   gpa     stats programming  admitted
+            id
+            15     yes  4.00  Advanced    Advanced         1
+            34     yes  3.85  Advanced    Beginner         0
+            13      no  4.00  Advanced      Novice         1
+            38     yes  2.65  Advanced    Beginner         1
+            5       no  3.44    Novice      Novice         0
+            40     yes  3.95    Novice    Beginner         0
+            7      yes  2.33    Novice      Novice         1
+            22     yes  3.46    Novice    Beginner         0
+            26     yes  3.57  Advanced    Advanced         1
+            17      no  3.83  Advanced    Advanced         1
+
+            # Example 1: Find the sum of all valid columns by grouping the
+            #            DataFrame columns with 'masters' and 'stats'.
             >>> df1 = df.rollup(["masters", "stats"]).sum()
             >>> df1
               masters     stats  sum_id  sum_gpa  sum_admitted
@@ -15427,10 +16287,38 @@ class DataFrame():
             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'.
+            >>> df1 = df.rollup(["masters", "admitted"], include_grouping_columns=True).avg()
+            >>> df1
+              masters  admitted     avg_id   avg_gpa  avg_admitted
+            0      no       NaN  19.055556  3.553333      0.888889
+            1     yes       NaN  21.681818  3.532273      0.454545
+            2    None       NaN  20.500000  3.541750      0.650000
+            3     yes       0.0  24.083333  3.613333      0.000000
+            4      no       1.0  18.875000  3.595000      1.000000
+            5     yes       1.0  18.800000  3.435000      1.000000
+            6      no       0.0  20.500000  3.220000      0.000000
+
+            # 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'.
+            >>> df1 = df.rollup(["masters", "admitted"], include_grouping_columns=False).avg()
+            >>> df1
+              masters  admitted     avg_id   avg_gpa
+            0      no       NaN  19.055556  3.553333
+            1     yes       NaN  21.681818  3.532273
+            2      no       0.0  20.500000  3.220000
+            3     yes       0.0  24.083333  3.613333
+            4      no       1.0  18.875000  3.595000
+            5     yes       1.0  18.800000  3.435000
+            6    None       NaN  20.500000  3.541750
         """
         # Validate columns argument.
         arg_info_matrix = []
         arg_info_matrix.append(["columns", columns, False, (str, list), True])
+        arg_info_matrix.append(["include_grouping_columns", include_grouping_columns, False, bool])
 
         # Validate argument types
         _Validators._validate_function_arguments(arg_info_matrix)
@@ -15440,7 +16328,1126 @@ class DataFrame():
 
         # Query generation of cube API is same as the group by.
         # Only 'rollup' is concatenated with 'group by' clause.
-        return self.groupby(columns, option="rollup")
+        return self.groupby(columns, option="rollup", include_grouping_columns=include_grouping_columns)
+
+    # Metadata functions for DataFrame created on datalake/OTF table.
+    @property
+    @collect_queryband(queryband="DF_snpsht")
+    @df_utils.check_otf_dataframe()
+    def snapshots(self):
+        """
+        DESCRIPTION:
+            Gets snapshot information for a DataLake table.
+
+        PARAMETERS:
+            None
+
+        RETURNS:
+            teradataml DataFrame.
+
+        RAISES:
+            TeradataMLException.
+
+        EXAMPLES :
+            # Example 1: Get the snapshot information for datalake table.
+            >>> from teradataml.dataframe.dataframe import in_schema
+            >>> in_schema_tbl = in_schema(schema_name="datalake_db",
+            ...                           table_name="datalake_table",
+            ...                           datalake_name="datalake")
+            >>> datalake_df = DataFrame(in_schema_tbl)
+            >>> datalake_df.snapshots
+                         snapshotId	  snapshotTimestamp	timestampMSecs	                                     manifestList	  summary
+            0	6373759902296319074	2023-06-15 00:07:47	1686787667420	s3://vim-iceberg-v1/glue/metadata/snap-6373759...	{"added-data-files":"1","added-records":"5","a...}
+            1	4768076782814510171	2023-06-15 00:09:01	1686787741964	s3://vim-iceberg-v1/glue/metadata/snap-4768076...	{"added-data-files":"1","added-records":"2","a...}
+            2	7771482207931850214	2024-05-29 04:59:09	1716958749946	s3://vim-iceberg-v1/glue/metadata/snap-7771482...	{"deleted-data-files":"2","deleted-records":"7...}
+            3	1545363077953282623	2024-05-29 05:13:39	1716959619455	s3://vim-iceberg-v1/glue/metadata/snap-1545363...	{"changed-partition-count":"0","total-records"...}
+            4	2166707884289108360	2024-05-29 05:17:49	1716959869075	s3://vim-iceberg-v1/glue/metadata/snap-2166707...	{"changed-partition-count":"0","total-records"...}
+            5	8934190131471882700	2024-05-29 05:21:32	1716960092422	s3://vim-iceberg-v1/glue/metadata/snap-8934190...	{"changed-partition-count":"0","total-records"...}
+            6	3086605171258231948	2024-05-29 05:34:43	1716960883786	s3://vim-iceberg-v1/glue/metadata/snap-3086605...	{"changed-partition-count":"0","total-records"...}
+            7	7592503716012384122	2024-05-29 06:04:48	1716962688047	s3://vim-iceberg-v1/glue/metadata/snap-7592503...	{"changed-partition-count":"0","total-records"...}
+            8	2831061717890032890	2024-06-04 17:21:01	1717521661689	s3://vim-iceberg-v1/glue/metadata/snap-2831061...	{"added-data-files":"2","added-records":"7","a...}
+            9	8810491341502972715	2024-10-22 23:47:22	1729640842067	s3://vim-iceberg-v1/glue/metadata/snap-8810491...	{"added-data-files":"1","added-records":"1","a...}
+            10	3953136136558551163	2024-12-03 04:40:48	1733200848733	s3://vim-iceberg-v1/glue/metadata/snap-3953136...	{"added-data-files":"1","added-records":"4","a...}
+            11	6034775168901969481	2024-12-03 04:40:49	1733200849966	s3://vim-iceberg-v1/glue/metadata/snap-6034775...	{"deleted-data-files":"1","deleted-records":"5...}
+        """
+        return self._execute_metadata_query_and_generate_dataframe("TD_SNAPSHOTS")
+
+    @property
+    @collect_queryband(queryband="DF_prttns")
+    @df_utils.check_otf_dataframe()
+    def partitions(self):
+        """
+        DESCRIPTION:
+            Gets partition information for a DataLake table.
+
+        PARAMETERS:
+            None
+
+        RETURNS:
+            teradataml DataFrame.
+
+        RAISES:
+            TeradataMLException.
+
+        EXAMPLES :
+            # Example 1: Get the partition information for datalake table.
+            >>> from teradataml.dataframe.dataframe import in_schema
+            >>> in_schema_tbl = in_schema(schema_name="datalake_db",
+            ...                           table_name="datalake_table",
+            ...                           datalake_name="datalake")
+            >>> datalake_df = DataFrame(in_schema_tbl)
+            >>> datalake_df.partitions
+                  id	name
+            0   1000	  c2
+            1   1001	  c3
+
+
+        """
+        return self._execute_metadata_query_and_generate_dataframe("TD_PARTITIONS")
+
+    @property
+    @collect_queryband(queryband="DF_mnfsts")
+    @df_utils.check_otf_dataframe()
+    def manifests(self):
+        """
+        DESCRIPTION:
+            Gets manifest information for a DataLake table.
+
+        PARAMETERS:
+            None
+
+        RETURNS:
+            teradataml DataFrame.
+
+        RAISES:
+            TeradataMLException.
+
+        EXAMPLES :
+            # Example 1: Get the manifest information for datalake table.
+            >>> from teradataml.dataframe.dataframe import in_schema
+            >>> in_schema_tbl = in_schema(schema_name="datalake_db",
+            ...                           table_name="datalake_table",
+            ...                           datalake_name="datalake")
+            >>> datalake_df = DataFrame(in_schema_tbl)
+            >>> datalake_df.manifests
+                         snapshotId	    snapshotTimestamp	                              manifestList	                              manifestFile	manifestFileLength	datafilecount	totalrowcount
+            0	8068130797628952520	  2025-05-02 11:45:26	s3://vim-iceberg-v1/otftestdb/nt_sales/...	s3://vim-iceberg-v1/otftestdb/nt_sales/...	              7158	            6	            6
+        """
+        return self._execute_metadata_query_and_generate_dataframe("TD_MANIFESTS")
+
+    @property
+    @collect_queryband(queryband="DF_hstry")
+    @df_utils.check_otf_dataframe()
+    def history(self):
+        """
+        DESCRIPTION:
+            Gets the snapshot history related to a DataLake table.
+
+        PARAMETERS:
+            None
+
+        RETURNS:
+            teradataml DataFrame.
+
+        RAISES:
+            TeradataMLException.
+
+        EXAMPLES :
+            # Example 1: Get the partition information for datalake table.
+            >>> from teradataml.dataframe.dataframe import in_schema
+            >>> in_schema_tbl = in_schema(schema_name="datalake_db",
+            ...                           table_name="datalake_table",
+            ...                           datalake_name="datalake")
+            >>> datalake_df = DataFrame(in_schema_tbl)
+            >>> datalake_df.history
+                                 id	              timestamp
+            0	8068130797628952520	    2025-05-02 11:45:26
+        """
+        return self._execute_metadata_query_and_generate_dataframe("TD_HISTORY")
+
+    def _execute_metadata_query_and_generate_dataframe(self, func_name):
+        """Function executes OTF metadata query and return result in DataFrame format"""
+        query = SQLBundle()._get_sql_query(SQLConstants.SQL_TD_OTF_METADATA).format(func_name,
+                                                                                    self._table_name)
+        return DataFrame.from_query(query)
+
+    @collect_queryband(queryband="DF_gt_snpsht")
+    @df_utils.check_otf_dataframe()
+    def get_snapshot(self, as_of):
+        """
+        DESCRIPTION:
+            Gets the data from a DataLake table for the given snapshot id or timestamp string.
+            Notes:
+                * The snapshot id can be obtained from the 'snapshots' property of the DataFrame.
+                * The time travel value represented by 'as_of' should be in the format "YYYY-MM-DD HH:MM:SS.FFFFFFF"
+                  for TIMESTAMP string or "YYYY-MM-DD" for DATE string.
+
+        PARAMETERS:
+            as_of:
+                Required Argument.
+                Specifies the snapshot id or timestamp information for which the snapshot is to be fetched.
+                Types: str or int
+
+        RETURNS:
+            teradataml DataFrame.
+
+        RAISES:
+            TeradataMLException.
+
+        EXAMPLES:
+            # DataFrame creation on OTF table.
+            >>> from teradataml.dataframe.dataframe import in_schema
+            >>> in_schema_tbl = in_schema(schema_name="datalake_db",
+            ...                           table_name="datalake_table",
+            ...                           datalake_name="datalake")
+            >>> datalake_df = DataFrame(in_schema_tbl)
+
+            # List snapshots first.
+            >>> datalake_df.snapshots
+                        snapshotId	  snapshotTimestamp	 timestampMSecs	                                     manifestList	  summary
+               2046682612111137809	2025-06-03 13:26:15	  1748957175692	 s3://vim-iceberg-v1/datalake_db/datalake_table/metadata/snap-204...	{"added-data-files":"Red Inc","added-records"...}
+                282293708812257203	2025-06-03 05:53:19	  1748929999245	 s3://vim-iceberg-v1/datalake_db/datalake_table/metadata/snap-282...    {"added-data-files":"Blue Inc","added-records"...}
+
+            # Example 1: Get the snapshot using snapshot id.
+            >>> datalake_df.get_snapshot(2046682612111137809)
+                          Feb    Jan    Mar    Apr    datetime
+            accounts
+            Blue Inc     90.0   50.0   95.0  101.0  04/01/2017
+            Alpha Co    210.0  200.0  215.0  250.0  04/01/2017
+            Jones LLC   200.0  150.0  140.0  180.0  04/01/2017
+            Yellow Inc   90.0    NaN    NaN    NaN  04/01/2017
+            Orange Inc  210.0    NaN    NaN  250.0  04/01/2017
+            Red Inc     200.0  150.0  140.0    NaN  04/01/2017
+
+            # Example 2: Get the snapshot using snapshot id in string format.
+            >>> datalake_df.get_snapshot("2046682612111137809")
+                          Feb    Jan    Mar    Apr    datetime
+            accounts
+            Blue Inc     90.0   50.0   95.0  101.0  04/01/2017
+            Alpha Co    210.0  200.0  215.0  250.0  04/01/2017
+            Jones LLC   200.0  150.0  140.0  180.0  04/01/2017
+            Yellow Inc   90.0    NaN    NaN    NaN  04/01/2017
+            Orange Inc  210.0    NaN    NaN  250.0  04/01/2017
+            Red Inc     200.0  150.0  140.0    NaN  04/01/2017
+
+            # Example 3: Get the snapshot using timestamp string.
+            >>> datalake_df.get_snapshot("2025-06-03 13:26:16")
+                          Feb    Jan    Mar    Apr    datetime
+            accounts
+            Blue Inc     90.0   50.0   95.0  101.0  04/01/2017
+            Alpha Co    210.0  200.0  215.0  250.0  04/01/2017
+            Jones LLC   200.0  150.0  140.0  180.0  04/01/2017
+            Yellow Inc   90.0    NaN    NaN    NaN  04/01/2017
+            Orange Inc  210.0    NaN    NaN  250.0  04/01/2017
+            Red Inc     200.0  150.0  140.0    NaN  04/01/2017
+
+            # Example 4: Get the snapshot using date string.
+            >>> datalake_df.get_snapshot("2025-06-04")
+                          Feb    Jan    Mar    Apr    datetime
+            accounts
+            Blue Inc     90.0   50.0   95.0  101.0  04/01/2017
+            Alpha Co    210.0  200.0  215.0  250.0  04/01/2017
+            Jones LLC   200.0  150.0  140.0  180.0  04/01/2017
+            Yellow Inc   90.0    NaN    NaN    NaN  04/01/2017
+            Orange Inc  210.0    NaN    NaN  250.0  04/01/2017
+            Red Inc     200.0  150.0  140.0    NaN  04/01/2017
+
+        """
+        _Validators._validate_function_arguments([["as_of", as_of, False, (int, str)]])
+
+        # If already int or string representation of int, return by quoting it
+        if isinstance(as_of, int) or (isinstance(as_of, str) and as_of.isdigit()):
+            snapshot_on = "'{}'".format(as_of)
+        else:
+            try:
+                snapshot_on = UtilFuncs._get_time_formatted_string(as_of)
+            except ValueError as e:
+                raise TeradataMlException(Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED,
+                                                               "get_snapshot", "Invalid value for 'as_of' argument: {}. "
+                                                               "Use valid format [\"YYYY-MM-DD HH:MM:SS.FFFFFFF\", \"YYYY-MM-DD HH:MM:SS\","
+                                                               "\"YYYY-MM-DD\"]".format(as_of)),
+                                          MessageCodes.FUNC_EXECUTION_FAILED)
+
+        query = SQLBundle()._get_sql_query(SQLConstants.SQL_TD_OTF_SNAPSHOT).format(self._table_name, snapshot_on)
+
+        try:
+            return DataFrame.from_query(query)
+        except TeradataMlException as e:
+            raise TeradataMlException(Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED,
+                                                           "get_snapshot()", "Invalid value for 'as_of' argument: {}. "
+                                                           "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):
@@ -15450,7 +17457,7 @@ class DataFrameGroupBy(DataFrame):
 
     """
 
-    def __init__(self, nodeid, metaexpr, column_names_and_types, columns, groupbyexpr, column_list, option=None):
+    def __init__(self, nodeid, metaexpr, column_names_and_types, columns, groupbyexpr, column_list, option=None, include_grouping_columns=False):
         """
         init() method for DataFrameGroupBy.
 
@@ -15491,6 +17498,15 @@ class DataFrameGroupBy(DataFrame):
                 Permitted Values: "CUBE", "ROLLUP", None
                 Types: str or NoneType
 
+            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
+                aggregations on the columns mentioned in "columns".
+                Default Value: False
+                Types: bool
+
         RETURNS:
             teradataml DataFrameGroupBy instance
         """
@@ -15500,6 +17516,7 @@ class DataFrameGroupBy(DataFrame):
         self._column_names_and_types = column_names_and_types
         self._columns = columns
         self.groupby_column_list = column_list
+        self._include_grouping_columns = include_grouping_columns
 
     def _get_assign_allowed_types(self):
         """
@@ -15585,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)