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

teradataml/dbutils/dbutils.py

@@ -20,22 +20,24 @@ from teradataml.common.messagecodes import MessageCodes
 from teradataml.common.exceptions import TeradataMlException
 from teradataml.common.constants import TeradataTableKindConstants
 from teradataml.common.sqlbundle import SQLBundle
-from teradataml.common.constants import SQLConstants
+from teradataml.common.constants import SQLConstants, SessionParamsSQL, SessionParamsPythonNames
 from teradataml.common.constants import TableOperatorConstants
 import teradataml.dataframe as tdmldf
 from teradataml.options.configure import configure
 from teradataml.utils.utils import execute_sql
 from teradataml.utils.validators import _Validators
+from teradataml.utils.internal_buffer import _InternalBuffer
 from teradatasql import OperationalError
 from teradatasqlalchemy.dialect import preparer, dialect as td_dialect
 from teradatasqlalchemy.dialect import TDCreateTablePost as post
-from teradatasqlalchemy.telemetry.queryband import collect_queryband
+from teradataml.telemetry_utils.queryband import collect_queryband
 from sqlalchemy import Table, Column, MetaData, CheckConstraint, \
     PrimaryKeyConstraint, ForeignKeyConstraint, UniqueConstraint
+from teradataml.utils.internal_buffer import _InternalBuffer
 
 
 @collect_queryband(queryband='DrpTbl')
-def db_drop_table(table_name, schema_name=None):
+def db_drop_table(table_name, schema_name=None, suppress_error=False):
     """
     DESCRIPTION:
         Drops the table from the given schema.
@@ -53,6 +55,12 @@ def db_drop_table(table_name, schema_name=None):
             Default Value: None
             Types: str
 
+        suppress_error:
+            Optional Argument
+            Specifies whether to raise error or not.
+            Default Value: False
+            Types: str
+
     RETURNS:
         True - if the operation is successful.
 
@@ -81,14 +89,18 @@ def db_drop_table(table_name, schema_name=None):
 
     try:
         return UtilFuncs._drop_table(table_name)
-    except TeradataMlException:
-        raise
-    except OperationalError:
-        raise
+    except (TeradataMlException, OperationalError):
+        if suppress_error:
+            pass
+        else:
+            raise
     except Exception as err:
-        raise TeradataMlException(Messages.get_message(MessageCodes.DROP_FAILED, "table",
-                                                       table_name),
-                                  MessageCodes.DROP_FAILED) from err
+        if suppress_error:
+            pass
+        else:
+            raise TeradataMlException(Messages.get_message(MessageCodes.DROP_FAILED, "table",
+                                                           table_name),
+                                      MessageCodes.DROP_FAILED) from err
 
 
 @collect_queryband(queryband='DrpVw')
@@ -171,6 +183,8 @@ def db_list_tables(schema_name=None, object_name=None, object_type='all'):
             a replacement for the percent.
             A '_' represents exactly one arbitrary character. Any single character is acceptable in the position in
             which the underscore character appears.
+            Note:
+                * If '%' is specified in 'object_name', then the '_' character is not evaluated for an arbitrary character.
             Default Value: None
             Types: str
             Example:
@@ -205,15 +219,15 @@ def db_list_tables(schema_name=None, object_name=None, object_type='all'):
         >>> execute_sql("create view temporary_view as (select 1 as dummy_col1, 2 as dummy_col2);")
         >>> db_list_tables(None , None, 'view')
 
-        # Example 3 - List all the object types in the default schema whose names begin with 'abc' followed by one
-        # arbitrary character and any number of characters in the end.
+        # Example 3 - List all the object types in the default schema whose names begin with 'abc' followed by any number
+        # of characters in the end.
         >>> execute_sql("create view abcd123 as (select 1 as dummy_col1, 2 as dummy_col2);")
-        >>> db_list_tables(None, 'abc_%', None)
+        >>> db_list_tables(None, 'abc%', None)
 
-        # Example 4 - List all the tables in the default schema whose names begin with 'adm_%' followed by one
-        # arbitrary character and any number of characters in the end.
+        # Example 4 - List all the tables in the default schema whose names begin with 'adm' followed by any number of
+        # characters and ends with 'train'.
         >>> load_example_data("dataframe", "admissions_train")
-        >>> db_list_tables(None, 'adm_%', 'table')
+        >>> db_list_tables(None, 'adm%train', 'table')
 
         # Example 5 - List all the views in the default schema whose names begin with any character but ends with 'abc'
         >>> execute_sql("create view view_abc as (select 1 as dummy_col1, 2 as dummy_col2);")
@@ -388,7 +402,7 @@ def _execute_transaction(queries):
             for query in queries:
                 cur.execute(query)
 
-            # Try committing the the transaction
+            # Try committing the transaction
             con.commit()
         except Exception:
             # Let's first rollback
@@ -400,6 +414,71 @@ def _execute_transaction(queries):
             cur.execute(auto_commit_on)
 
 
+def db_transaction(func):
+    """
+    DESCRIPTION:
+        Function to execute another function in a transaction.
+
+    PARAMETERS:
+        func:
+            Required Argument.
+            Specifies the function to be executed in a single transaction.
+            Types: function
+
+    RETURNS:
+        The object returned by "func".
+
+    RAISES:
+        TeradataMlException, OperationalError
+
+    EXAMPLES:
+        # Example: Declare a function to delete all the records from two tables
+        #          and execute the function in a transaction.
+        >>> @db_transaction
+        ... def insert_data(table1, table2):
+        ...     execute_sql("delete from {}".format(table1))
+        ...     execute_sql("delete from {}".format(table2))
+        ...     return True
+        >>> # Executing the above function in a transaction.
+        >>> insert_data("sales", "admissions_train")
+        True
+        >>>
+    """
+    def execute_transaction(*args, **kwargs):
+        auto_commit_off = "{fn teradata_nativesql}{fn teradata_autocommit_off}"
+        auto_commit_on = "{fn teradata_nativesql}{fn teradata_autocommit_on}"
+        con = None
+        cur = None
+
+        result = None
+        try:
+            con = tdmlctx.td_connection
+            if con is None:
+                raise TeradataMlException(Messages.get_message(MessageCodes.CONNECTION_FAILURE),
+                                          MessageCodes.CONNECTION_FAILURE)
+            con = con.connection
+            cur = con.cursor()
+            # Set auto_commit to OFF.
+            cur.execute(auto_commit_off)
+
+            # Execute function.
+            result = func(*args, **kwargs)
+
+            # Try committing the transaction.
+            con.commit()
+        except Exception:
+            # Let's first rollback.
+            con.rollback()
+            # Now, let's raise the error as is.
+            raise
+        finally:
+            # Finally, we must set auto_commit to ON.
+            cur.execute(auto_commit_on)
+
+        return result
+
+    return execute_transaction
+
 def _execute_stored_procedure(function_call, fetchWarnings=True, expect_none_result=False):
     """
     DESCRIPTION:
@@ -982,6 +1061,7 @@ def _create_table(table_name,
             pti = pti.no_primary_index()
 
         con_form=[]
+        foreign_constraints = []
         for c_name, parameters in kwargs.items():
             _Validators._validate_function_arguments([["constraint_type", c_name, True, str,
                                                        True, SQLConstants.CONSTRAINT.value]])
@@ -990,9 +1070,21 @@ def _create_table(table_name,
                 [con_form.append("{}('{}')".format("CheckConstraint", col)) for col in parameters]
             if c_name in 'foreign_key_constraint':
                 parameters = parameters if isinstance(parameters[0], tuple) else [tuple(parameters)]
-                for col in parameters:
-                    meta.reflect(bind=tdmlctx.get_context(), only=[col[2]])
-                    con_form.append("{}({},{})".format("ForeignKeyConstraint", col[0], col[1]))
+                # Every element in parameter is 3 elements.
+                # 1st element and 2nd element also a list. 3rd element is name of ForeignKey.
+                for fk_columns, fk_ref_columns, fk_name in parameters:
+                    fk_ref_column_objs = []
+
+                    # fk_ref_columns is in this format - table_name.column_name .
+                    # There is no provision for schema name here.
+                    # sqlalchemy is not accepting this notation here - schema_name.table_name.column_name
+                    # So, create Column Object and bind schema name and table name to it.
+                    for fk_ref_column in fk_ref_columns:
+                        ref_column_table, ref_column = fk_ref_column.split(".")
+                        t = Table(ref_column_table, MetaData(), Column(ref_column), schema=schema_name)
+                        fk_ref_column_objs.append(getattr(t, "c")[ref_column])
+                    foreign_constraints.append(ForeignKeyConstraint(fk_columns, fk_ref_column_objs, fk_name))
+
             if c_name in ['primary_key_constraint', 'unique_key_constraint']:
                 c_name = "UniqueConstraint" if c_name in 'unique_key_constraint' else 'PrimaryKeyConstraint'
                 parameters = UtilFuncs._as_list(parameters)
@@ -1006,6 +1098,8 @@ def _create_table(table_name,
                     "schema=schema_name)".format("" if con_form is None else ",".join(con_form))
 
         table=eval(table_str)
+        for foreign_constraint in foreign_constraints:
+            table.append_constraint(foreign_constraint)
         table.create(bind=tdmlctx.get_context())
 
     except Exception as err:
@@ -1013,30 +1107,357 @@ def _create_table(table_name,
         raise TeradataMlException(Messages.get_message(msg_code, "create table", str(err)), msg_code)
 
 
+def _create_database(schema_name, size='10e6', spool_size=None):
+    """
+    DESCRIPTION:
+        Internal function to create a database with the specified name and size.
+
+    PARAMETERS:
+        schema_name:
+            Required Argument.
+            Specifies the name of the database to create.
+            Types: str
+
+        size:
+            Optional Argument.
+            Specifies the number of bytes to allocate to new database.
+            Note:
+                Exponential notation can also be used.
+            Types: str or int
+
+        spool_size:
+            Optional Argument.
+            Specifies the number of bytes to allocate to new database
+            for spool space.
+            Note:
+                Exponential notation can also be used.
+            Types: str or int
+
+    RETURNS:
+        bool
+
+    RAISES:
+        TeradataMlException.
+
+    EXAMPLES:
+       >>> from teradataml.dbutils.dbutils import _create_database
+       >>> _create_database("db_name1", "10e5")
+    """
+    sql = "CREATE DATABASE {} FROM {} AS PERM = {}".format(
+        schema_name, tdmlctx._get_database_username(), size)
+
+    # If user pass spool size, create it with specified space.
+    if spool_size:
+        sql = "{} , SPOOL = {}".format(sql, spool_size)
+
+    execute_sql(sql)
+    return True
+
+
+def _update_data(update_columns_values, table_name, schema_name, datalake_name=None, update_conditions=None):
+    """
+    DESCRIPTION:
+        Internal function to update the data in a table.
+
+    PARAMETERS:
+        update_columns_values:
+            Required Argument.
+            Specifies the columns and it's values to update.
+            Types: dict
+
+        table_name:
+            Required Argument.
+            Specifies the name of the table to update.
+            Types: str
+
+        schema_name:
+            Required Argument.
+            Specifies the name of the database to update the data in the
+            table "table_name".
+            Types: str
+
+        datalake_name:
+            Optional Argument.
+            Specifies the name of the datalake to look for "schema_name".
+            Types: str
+
+        update_conditions:
+            Optional Argument.
+            Specifies the key columns and it's values which is used as condition
+            for updating the records.
+            Types: dict
+
+    RETURNS:
+        bool
+
+    RAISES:
+        TeradataMlException.
+
+    EXAMPLES:
+       >>> from teradataml.dbutils.dbutils import _update_data
+       >>> _update_data("db_name1", "tbl", update_conditions={"column1": "value1"})
+    """
+    # Prepare the update clause.
+    update_clause = ", ".join(("{} = ?".format(col) for col in update_columns_values))
+    update_values = tuple((_value for _value in update_columns_values.values()))
+
+    # If key_columns_values is passed, then prepare the SQL with where clause.
+    # Else, simply update every thing.
+    schema_name = "{}.{}".format(datalake_name, schema_name) if datalake_name else schema_name
+
+    get_str_ = lambda val: "'{}'".format(val) if isinstance(val, str) else val
+    if update_conditions:
+
+        # Prepare where clause.
+        where_ = []
+        for column, col_value in update_conditions.items():
+            if isinstance(col_value, list):
+                col_value = ", ".join(get_str_(val) for val in col_value)
+                col_value = "({})".format(col_value)
+                where_.append("{} IN {}".format(column, col_value))
+            else:
+                where_.append("{} = {}".format(column, col_value))
+
+        where_clause = " AND ".join(where_)
+
+        sql = f"""UPDATE {schema_name}.{table_name} SET {update_clause}
+                 WHERE {where_clause}
+            """
+
+        execute_sql(sql, (*update_values, ))
+
+    else:
+        sql = f"""UPDATE {schema_name}.{table_name} SET {update_clause}"""
+
+        execute_sql(sql, update_values)
+    return True
+
+
+def _insert_data(table_name, values, columns=None, schema_name=None, datalake_name=None):
+    """
+    DESCRIPTION:
+        Internal function to insert the data in a table.
+
+    PARAMETERS:
+        table_name:
+            Required Argument.
+            Specifies the name of the table to insert.
+            Types: str
+
+        values:
+            Required Argument.
+            Specifies the values to insert.
+            Types: tuple or list of tuple
+
+        columns:
+            Optional Argument.
+            Specifies the name of columns to be involved in insert.
+            Types: list
+
+        schema_name:
+            Optional Argument.
+            Specifies the name of the database to insert the data in the
+            table "table_name".
+            Types: str
+
+        datalake_name:
+            Optional Argument.
+            Specifies the name of the datalake to look for "schema_name".
+            Types: str
+
+    RETURNS:
+        bool
+
+    RAISES:
+        TeradataMlException.
+
+    EXAMPLES:
+       >>> from teradataml.dbutils.dbutils import _insert_data
+       >>> _insert_data("tbl", (1, 2, 3))
+    """
+    # Prepare the update clause.
+    if schema_name:
+        table_name = '"{}"."{}"'.format(schema_name, table_name)
+        if datalake_name:
+            table_name = '"{}"."{}"'.format(datalake_name, table_name)
+
+    values = UtilFuncs._as_list(values)
+
+    # Prepare columns clause.
+    if columns:
+        # Prepare question marks.
+        _q_marks = ["?"] * len(columns)
+        columns = "({})".format(", ".join(columns))
+    else:
+        columns = ""
+        _q_marks = ["?"] * (len(values[0]))
+
+    sql = "insert into {} {} values ({});".format(table_name, columns, ", ".join(_q_marks))
+    execute_sql(sql, values)
+
+    return True
+
+
+def _upsert_data(update_columns_values,
+                 insert_columns_values,
+                 upsert_conditions,
+                 table_name,
+                 schema_name,
+                 datalake_name=None):
+    """
+    DESCRIPTION:
+        Internal function to either insert or update the data to a table.
+
+    PARAMETERS:
+        update_columns_values:
+            Required Argument.
+            Specifies the columns and it's values to update.
+            Types: dict
+
+        insert_columns_values:
+            Required Argument.
+            Specifies the columns and it's values to insert.
+            Types: dict
+
+        upsert_conditions:
+            Required Argument.
+            Specifies the key columns and it's values which is used as condition
+            for updating the records.
+            Types: tuple
+
+        table_name:
+            Required Argument.
+            Specifies the name of the table to insert.
+            Types: str
+
+        schema_name:
+            Required Argument.
+            Specifies the name of the database to update the data in the
+            table "table_name".
+            Types: str
+
+        datalake_name:
+            Optional Argument.
+            Specifies the name of the datalake to look for "schema_name".
+            Types: str
+
+    RETURNS:
+        bool
+
+    RAISES:
+        TeradataMlException.
+
+    EXAMPLES:
+       >>> from teradataml.dbutils.dbutils import _upsert_data
+       >>> _upsert_data("db_name1",
+                        "tbl",
+                        update_columns_values={"column1": "value1"},
+                        insert_columns_values={"column1": "value2"},
+                        upsert_conditions={"key1": "val1"}
+                        )
+    """
+    # If user passes datalake name, then append the same to schema name.
+    if datalake_name:
+        schema_name = "{}.{}".format(datalake_name, schema_name)
+
+    # Prepare the update clause.
+    update_clause = ", ".join(("{} = ?".format(col) for col in update_columns_values))
+    update_values = tuple((_value for _value in update_columns_values.values()))
+
+    # Prepare the where clause and it's values.
+    where_clause = " AND ".join(("{} = ?".format(col) for col in upsert_conditions))
+    where_values = tuple((_value for _value in upsert_conditions.values()))
+
+    # Prepare the insert clause and it's values.
+    insert_values_clause = ", ".join(("?" for _ in range(len(insert_columns_values))))
+    insert_clause = "({}) values ({})".format(", ".join(insert_columns_values), insert_values_clause)
+    insert_values = tuple((_value for _value in insert_columns_values.values()))
+
+    sql = f"""UPDATE {schema_name}.{table_name} SET {update_clause}
+         WHERE {where_clause}
+       ELSE INSERT {schema_name}.{table_name} {insert_clause}
+    """
+    execute_sql(sql, (*update_values, *where_values, *insert_values))
+
+def _delete_data(table_name, schema_name=None, datalake_name=None, delete_conditions=None):
+    """
+    DESCRIPTION:
+        Internal function to delete the data in a table.
+
+    PARAMETERS:
+        table_name:
+            Required Argument.
+            Specifies the name of the table to delete.
+            Types: str
+
+        schema_name:
+            Optional Argument.
+            Specifies the name of the database to delete the data in the
+            table "table_name".
+            Types: str
+
+        datalake_name:
+            Optional Argument.
+            Specifies the name of the datalake to look for "schema_name".
+            Types: str
+
+        delete_conditions:
+            Optional Argument.
+            Specifies the ColumnExpression to use for removing the data.
+            Types: ColumnExpression
+
+    RETURNS:
+        int, specifies the number of records those are deleted.
+
+    RAISES:
+        TeradataMlException.
+
+    EXAMPLES:
+       >>> from teradataml.dbutils.dbutils import _delete_data
+       >>> _delete_data("tbl", "db_name1", delete_conditions={"column1": "value1"})
+    """
+    if schema_name:
+        table_name = '"{}"."{}"'.format(schema_name, table_name)
+
+    if datalake_name:
+        table_name = "{}.{}".format(datalake_name, table_name)
+
+    sqlbundle = SQLBundle()
+
+    sql = sqlbundle._get_sql_query(SQLConstants.SQL_DELETE_ALL_ROWS).format(table_name)
+
+    # If condition exist, the prepare where clause.
+    if delete_conditions:
+        where_clause = delete_conditions.compile()
+        sql = sqlbundle._get_sql_query(SQLConstants.SQL_DELETE_SPECIFIC_ROW).format(table_name, where_clause)
+
+    res = execute_sql(sql)
+    return res.rowcount
+
 @collect_queryband(queryband='LstKwrds')
 def list_td_reserved_keywords(key=None, raise_error=False):
     """
     DESCRIPTION:
-        Function validates if the specified string is Teradata reserved keyword or not.
-        If key is not specified, list all the Teradata reserved keywords.
+        Function validates if the specified string or the list of strings is Teradata reserved keyword or not.
+        If key is not specified or is a empty list, list all the Teradata reserved keywords.
 
     PARAMETERS:
         key:
             Optional Argument.
-            Specifies a string to validate for Teradata reserved keyword.
-            Types: string
+            Specifies a string or list of strings to validate for Teradata reserved keyword.
+            Types: string or list of strings
 
         raise_error:
             Optional Argument.
             Specifies whether to raise exception or not.
             When set to True, an exception is raised,
-            if specified "key" is a Teradata reserved keyword, otherwise not.
+            if specified "key" contains Teradata reserved keyword, otherwise not.
             Default Value: False
             Types: bool
 
     RETURNS:
-        teradataml DataFrame, if "key" is None.
-        True, if "key" is Teradata reserved keyword, False otherwise.
+        teradataml DataFrame, if "key" is None or a empty list.
+        True, if "key" contains Teradata reserved keyword, False otherwise.
 
     RAISES:
         TeradataMlException.
@@ -1065,21 +1486,38 @@ def list_td_reserved_keywords(key=None, raise_error=False):
 
        >>> # Example 3: Validate and raise exception if keyword "account" is a Teradata reserved keyword.
        >>> list_td_reserved_keywords("account", raise_error=True)
-       TeradataMlException: [Teradata][teradataml](TDML_2121) 'account' is a Teradata reserved keyword.
+       TeradataMlException: [Teradata][teradataml](TDML_2121) '['ACCOUNT']' is a Teradata reserved keyword.
+
+       >>> # Example 4: Validate if the list of keywords contains Teradata reserved keyword or not.
+       >>> list_td_reserved_keywords(["account", 'add', 'abc'])
+       True
+
+       >>> # Example 5: Validate and raise exception if the list of keywords contains Teradata reserved keyword.
+       >>> list_td_reserved_keywords(["account", 'add', 'abc'], raise_error=True)
+       TeradataMlException: [Teradata][teradataml](TDML_2121) '['ADD', 'ACCOUNT']' is a Teradata reserved keyword.
     """
+
     from teradataml.dataframe.dataframe import DataFrame, in_schema
     # Get the reserved keywords from the table
     reserved_keys = DataFrame(in_schema("SYSLIB", "SQLRestrictedWords"))
 
-    # If key is not passed, return the list of Teradata reserved keywords.
-    if key is None:
+    # If key is not passed or is a empty list, return the list of Teradata reserved keywords.
+    if key is None or len(key) == 0:
         return reserved_keys.select(['restricted_word'])
 
-    # Check if key is a Teradata reserved keyword or not.
-    num_rows = reserved_keys[reserved_keys.restricted_word == key.upper()].shape[0]
-    if num_rows > 0:
+    key = [key] if isinstance(key, str) else key
+
+    # Store the reserved keywords in buffer.
+    if _InternalBuffer.get("reservered_words") is None:
+        _InternalBuffer.add(reservered_words={word_[0] for word_ in reserved_keys.itertuples(name=None)})
+    reservered_words = _InternalBuffer.get("reservered_words")
+
+    # Check if key contains Teradata reserved keyword or not.
+    res_key = (k.upper() for k in key if k.upper() in reservered_words)
+    res_key = list(res_key)
+    if len(res_key)>0:
         if raise_error:
-            raise TeradataMlException(Messages.get_message(MessageCodes.RESERVED_KEYWORD, key),
+            raise TeradataMlException(Messages.get_message(MessageCodes.RESERVED_KEYWORD, res_key),
                                                           MessageCodes.RESERVED_KEYWORD)
         return True
     return False
@@ -1150,6 +1588,10 @@ def _execute_query_and_generate_pandas_df(query, index=None, **kwargs):
     if cur is not None:
         cur.close()
 
+    # Set coerce_float to True for Decimal type columns.
+    if 'coerce_float' not in kwargs:
+        kwargs['coerce_float'] = True
+
     try:
         pandas_df = pd.DataFrame.from_records(data=list(tuple(row) for row in rows),
                                               columns=columns,
@@ -1165,3 +1607,405 @@ def _execute_query_and_generate_pandas_df(query, index=None, **kwargs):
             MessageCodes.TDMLDF_SELECT_DF_FAIL)
 
     return pandas_df
+
+class _TDSessionParams:
+    """
+    A successfull connection through teradataml establishes a session with Vantage.
+    Every session will have default parameters. For example one can set Offset value
+    for parameter 'Session Time Zone'.
+    This is an internal utility to store all session related parameters.
+    """
+    def __init__(self, data):
+        """
+        Constructor to store columns and rows of session params.
+
+        PARAMETERS:
+            data:
+                Required Argument.
+                Specifies the Session parameters.
+                Types: dict
+        """
+        self.__session_params = data
+
+    def __getitem__(self, parameter):
+        """
+        Return the value of Session parameter.
+
+        PARAMETERS:
+            parameter:
+                Required Argument.
+                Specifies name of the session parameter.
+                Types: str
+        """
+        if parameter in self.__session_params:
+            return self.__session_params[parameter]
+        raise AttributeError("'TDSessionParams' object has no attribute '{}'".format(parameter))
+
+def set_session_param(name, value):
+    """
+    DESCRIPTION:
+        Function to set the session parameter.
+        Note:
+            * Look at Vantage documentation for session parameters.
+
+    PARAMETERS:
+        name:
+            Required Argument.
+            Specifies the name of the parameter to set.
+            Permitted Values: timezone, calendar, account, character_set_unicode,
+                              collation, constraint, database, dateform, debug_function,
+                              dot_notation, isolated_loading, function_trace, json_ignore_errors,
+                              searchuifdbpath, transaction_isolation_level, query_band, udfsearchpath
+            Types: str
+
+        value:
+            Required Argument.
+            Specifies the value for the parameter "name" to set.
+            Permitted Values:
+                1. timezone: timezone strings
+                2. calendar: Teradata, ISO, Compatible
+                3. character_set_unicode: ON, OFF
+                4. account: should be a list in which first item should be "account string" second should be
+                            either SESSION or REQUEST.
+                5. collation: ASCII, CHARSET_COLL, EBCDIC, HOST, JIS_COLL, MULTINATIONAL
+                6. constraint: row_level_security_constraint_name {( level_name | category_name [,...] | NULL )}
+                               where,
+                               row_level_security_constraint_name:
+                                   Name of an existing constraint.
+                                   The specified constraint_name must be currently assigned to the user.
+                                   User can specify a maximum of 6 hierarchical constraints and 2 non-hierarchical
+                                   constraints per SET SESSION CONSTRAINT statement.
+                               level_name:
+                                   Name of a hierarchical level, valid for the constraint_name, that is to replace the
+                                   default level.
+                                   The specified level_name must be currently assigned to the user. Otherwise, Vantage
+                                   returns an error to the requestor.
+                               category_name:
+                                   A set of one or more existing non-hierarchical category names valid for the
+                                   constraint_name.
+                                   Because all assigned category (non-hierarchical) constraint values assigned to a
+                                   user are automatically active, "set_session_param" is only useful to specify a
+                                   subset of the assigned categories for the constraint.
+                                   For example, assume that User BOB has 3 country codes, and wants to load a table
+                                   with data that is to be made available to User CARL who only has rights to see data
+                                   for his own country. User BOB can use "set_session_param" to specify only the
+                                   country code for User CARL when loading the data so Carl can access the data later.
+                7. database: Name of the new default database for the remainder of the current session.
+                8. dateform: ANSIDATE, INTEGERDATE
+                9. debug_function: should be a list in which first item should be "function_name" second should be
+                            either ON or OFF.
+                10. dot_notation: DEFAULT, LIST, NULL ERROR
+                11. isolated_loading: NO, '', CONCURRENT
+                12. function_trace: should be a list first item should be "mask_string" and second should be table name.
+                13. json_ignore_errors: ON, OFF
+                14. searchuifdbpath: string in format 'database_name, user_name'
+                15. transaction_isolation_level: READ UNCOMMITTED, RU, SERIALIZABLE, SR
+                16. query_band: should be a list first item should be "band_specification" and second should be either
+                                SESSION or TRANSACTION
+                17. udfsearchpath: should be a list first item should be "database_name" and second should be "udf_name"
+            Types: str or list of strings
+
+    Returns:
+        True, if session parameter is set successfully.
+
+    RAISES:
+        ValueError, teradatasql.OperationalError
+
+    EXAMPLES:
+        # Example 1: Set time zone offset for the session as the system default.
+        >>> set_session_param('timezone', "'LOCAL'")
+        True
+
+        # Example 2: Set time zone to "AMERICA PACIFIC".
+        >>> set_session_param('timezone', "'AMERICA PACIFIC'")
+        True
+
+        # Example 3: Set time zone to "-07:00".
+        >>> set_session_param('timezone', "'-07:00'")
+        True
+
+        # Example 4: Set time zone to 3 hours ahead of 'GMT'.
+        >>> set_session_param('timezone', "3")
+        True
+
+        # Example 6: Set calendar to 'COMPATIBLE'.
+        >>> set_session_param('calendar', "COMPATIBLE")
+        True
+
+        # Example 7: Dynamically changes your account to 'dbc' for the remainder of the session.
+        >>> set_session_param('account', ['dbc', 'SESSION'])
+        True
+
+        # Example 8: Enables Unicode Pass Through processing.
+        >>> set_session_param('character_set_unicode', 'ON')
+        True
+
+        # Example 9: Session set to ASCII collation.
+        >>> set_session_param('collation', 'ASCII')
+        True
+
+        # Example 10: The resulting session has a row-level security label consisting of an unclassified level
+        #             and nato category.
+        >>> set_session_param('constraint', 'classification_category (norway)')
+        True
+
+        # Example 11: Changes the default database for the session.
+        >>> set_session_param('database', 'alice')
+        True
+
+        # Example 12: Changes the  DATE format to 'INTEGERDATE'.
+        >>> set_session_param('dateform', 'INTEGERDATE')
+        True
+
+        # Example 13: Enable Debugging for the Session.
+        >>> set_session_param('debug_function', ['function_name', 'ON'])
+        True
+
+        # Example 14: Sets the session response for dot notation query result.
+        >>> set_session_param('dot_notation', 'DEFAULT')
+        True
+
+        # Example 15: DML operations are not performed as concurrent load isolated operations.
+        >>> set_session_param('isolated_loading', 'NO')
+        True
+
+        # Example 16: Enables function trace output for debugging external user-defined functions and
+        #             external SQL procedures for the current session.
+        >>> set_session_param('function_trace', ["'diag,3'", 'titanic'])
+        True
+
+        # Example 17: Enables the validation of JSON data on INSERT operations.
+        >>> set_session_param('json_ignore_errors', 'ON')
+        True
+
+        # Example 18: Sets the database search path for the SCRIPT execution in the SessionTbl.SearchUIFDBPath column.
+        >>> set_session_param('SEARCHUIFDBPATH', 'dbc, alice')
+        True
+
+        # Example 19: Sets the read-only locking severity for all SELECT requests made against nontemporal tables,
+        #             whether they are outer SELECT requests or subqueries, in the current session to READ regardless
+        #             of the setting for the DBS Control parameter AccessLockForUncomRead.
+        #             Note: SR and SERIALIZABLE are synonyms.
+        >>> set_session_param('TRANSACTION_ISOLATION_LEVEL', 'SR')
+        True
+
+        # Example 20: This example uses the PROXYROLE name:value pair in a query band to set the proxy
+        #             role in a trusted session to a specific role.
+        >>> set_session_param('query_band', ["'PROXYUSER=fred;PROXYROLE=administration;'", 'SESSION'])
+        True
+
+        # Example 21: Allows you to specify a custom UDF search path. When you execute a UDF,
+        #             Vantage searches this path first, before looking in the default Vantage
+        #             search path for the UDF.
+        >>> set_session_param('udfsearchpath', ["alice, SYSLIB, TD_SYSFNLIB", 'bitor'])
+        True
+    """
+    # Validate argument types
+    function_args = []
+    function_args.append(["name", name, True, str, True])
+    function_args.append(["value", value, True, (int, str, float, list), False])
+    _Validators._validate_function_arguments(function_args)
+
+    if not isinstance(value, list):
+        value = [value]
+
+    # Before setting the session, first extract the session parameters
+    # and store it in buffer. This helps while unsetting the parameter.
+    result = execute_sql('help session')
+    data = dict(zip(
+        [param[0] for param in result.description],
+        [value for value in next(result)]
+    ))
+    _InternalBuffer.add(session_params = _TDSessionParams(data))
+    # Store function name of 'DEBUG_FUNCTION' used.
+    _InternalBuffer.add(function_name = value[0] if name.upper() == 'DEBUG_FUNCTION' else '')
+
+    # Set the session parameter.
+    execute_sql(getattr(SessionParamsSQL, name.upper()).format(*value))
+
+    return True
+
+def unset_session_param(name):
+    """
+    DESCRIPTION:
+        Function to unset the session parameter.
+
+    PARAMETERS:
+        name:
+            Required Argument.
+            Specifies the parameter to unset for the session.
+            Permitted Values: timezone, account, calendar, collation,
+                              database, dataform, character_set_unicode,
+                              debug_function, isolated_loading, function_trace,
+                              json_ignore_errors, query_band
+            Type: str
+
+    Returns:
+        True, if successfully unsets the session parameter.
+
+    RAISES:
+    ValueError, teradatasql.OperationalError
+
+    EXAMPLES:
+        # Example 1: unset session to previous time zone.
+        >>> set_session_param('timezone', "'GMT+1'")
+        True
+        >>> unset_session_param("timezone")
+        True
+
+    """
+    # Validate argument types
+    function_args = []
+    function_args.append(["name", name, True, str, True])
+    _Validators._validate_function_arguments(function_args)
+
+    # Check whether session param is set or not first.
+    session_params = _InternalBuffer.get('session_params')
+    if session_params is None:
+        msg_code = MessageCodes.FUNC_EXECUTION_FAILED
+        error_msg = Messages.get_message(msg_code, "unset_session_param", "Set the parameter before unsetting it.")
+        raise TeradataMlException(error_msg, msg_code)
+    # unset_values stores params which are not available in _InternalBuffer, to unset create a dictionary
+    # with param as key and unset param as value
+    unset_values = {"CHARACTER_SET_UNICODE": "OFF", "DEBUG_FUNCTION": [_InternalBuffer.get('function_name'), "OFF"],
+                    "ISOLATED_LOADING":"NO", "FUNCTION_TRACE":"SET SESSION FUNCTION TRACE OFF",
+                    "JSON_IGNORE_ERRORS": "OFF", "QUERY_BAND": ["", "SESSION"]}
+
+    # If 'name' in unset_values unset the params
+    if name.upper() in unset_values:
+        # When name is 'FUNCTION_TRACE' unset_values already have query for that, use execute_sql on that.
+        if name.upper() == "FUNCTION_TRACE":
+            execute_sql(unset_values[name.upper()])
+        # When name is other than 'FUNCTION_TRACE' use value and key of unset_values to unset param.
+        else:
+            set_session_param(name, unset_values[name.upper()])
+        return True
+
+    previous_value = "{}".format(session_params[getattr(SessionParamsPythonNames, name.upper())]) \
+        if name.upper() != 'TIMEZONE' else "'{}'".format(session_params[getattr(SessionParamsPythonNames, name.upper())])
+    
+    if name.upper() == "ACCOUNT":
+        previous_value = [previous_value, 'SESSION']
+    set_session_param(name, previous_value)
+
+    return True
+
+class _Authorize:
+    """ Parent class to either provide or revoke access on table(s). """
+    _property = None
+
+    def __init__(self, objects):
+        """
+        DESCRIPTION:
+            Constructor for creating Authorize object.
+
+        PARAMETERS:
+            objects:
+                Required Argument.
+                Specifies the name(s) of the database objects to be authorized.
+                Types: str OR list of str.
+
+        RETURNS:
+            Object of _Authorize.
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            >>> auth = _Authorize('vfs_v1')
+        """
+        # Store the objects here. Then use this where ever required.
+        self._objects = objects
+        self._access_method = self.__class__.__name__.upper()
+
+    def read(self, user):
+        """
+        DESCRIPTION:
+            Authorize the read access.
+            Note:
+                One must have admin access to give read access to other "user".
+
+        PARAMETERS:
+            user:
+                Required Argument.
+                Specifies the name of the user to have read only access.
+                Types: str
+
+        RETURNS:
+            bool.
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            >>> _Authorize('repo').read('BoB')
+        """
+        for object in self._objects:
+            sql = "{} SELECT ON {} {} {}".format(self._access_method, object, self._property, user)
+            execute_sql(sql)
+
+        return True
+
+    def write(self, user):
+        """
+        DESCRIPTION:
+            Authorize the write access.
+            Note:
+                One must have admin access to give write access to other "user".
+
+        PARAMETERS:
+            user:
+                Required Argument.
+                Specifies the name of the user to have write only access.
+                Types: str
+
+        RETURNS:
+            bool.
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            >>> _Authorize('repo').write('BoB')
+        """
+        for access_type in ["INSERT", "UPDATE", "DELETE"]:
+            for object in self._objects:
+                sql = "{} {} ON {} {} {}".format(self._access_method, access_type, object, self._property, user)
+                execute_sql(sql)
+
+        return True
+
+    def read_write(self, user):
+        """
+        DESCRIPTION:
+            Authorize the read and write access.
+            Note:
+                One must have admin access to give read and write access to other "user".
+
+        PARAMETERS:
+            user:
+                Required Argument.
+                Specifies the name of the user to have read and write access.
+                Types: str
+
+        RETURNS:
+            bool.
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            >>> _Authorize('repo').read_write('BoB')
+        """
+        self.read(user)
+        return self.write(user)
+
+
+class Grant(_Authorize):
+    """ Class to grant access to tables."""
+    _property = "TO"
+
+
+class Revoke(_Authorize):
+    """ Class to revoke access from tables."""
+    _property = "FROM"