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

teradataml/dbutils/dbutils.py

@@ -10,12 +10,14 @@ teradataml db utilities
 A teradataml database utility functions provide interface to Teradata Vantage common tasks such as drop_table, drop_view, create_table etc.
 """
 import concurrent.futures
+import enum
 import json
 import os
 import re
 import shutil
 import tempfile
 from datetime import datetime
+import functools
 
 import pandas as pd
 from sqlalchemy import (CheckConstraint, Column, ForeignKeyConstraint,
@@ -69,7 +71,7 @@ def db_drop_table(table_name, schema_name=None, suppress_error=False,
             Optional Argument
             Specifies whether to raise error or not.
             Default Value: False
-            Types: str
+            Types: bool
 
         datalake_name:
             Optional Argument
@@ -113,6 +115,7 @@ def db_drop_table(table_name, schema_name=None, suppress_error=False,
     awu_matrix.append(["table_name", table_name, False, (str), True])
     awu_matrix.append(["datalake_name", datalake_name, True, (str), True])
     awu_matrix.append(["purge", purge, True, (bool, type(None)), True])
+    awu_matrix.append(["suppress_error", suppress_error, True, (bool)])
     # Validate argument types
     _Validators._validate_function_arguments(awu_matrix)
 
@@ -149,7 +152,7 @@ def db_drop_table(table_name, schema_name=None, suppress_error=False,
 
 
 @collect_queryband(queryband='DrpVw')
-def db_drop_view(view_name, schema_name=None):
+def db_drop_view(view_name, schema_name=None, suppress_error=False):
     """
     DESCRIPTION:
         Drops the view from the given schema.
@@ -167,6 +170,12 @@ def db_drop_view(view_name, schema_name=None):
             Default Value: None
             Types: str
 
+        suppress_error:
+            Optional Argument
+            Specifies whether to raise error or not.
+            Default Value: False
+            Types: bool
+
     RETURNS:
         True - if the operation is successful.
 
@@ -174,19 +183,23 @@ def db_drop_view(view_name, schema_name=None):
         TeradataMlException - If the view doesn't exist.
 
     EXAMPLES:
-        # Create a view
+        # Create a view.
         >>> execute_sql("create view temporary_view as (select 1 as dummy_col1, 2 as dummy_col2);")
 
-        # Drop view in current schema
+        # Drop view in current schema.
         >>> db_drop_view(view_name = 'temporary_view')
 
-        # Drop view from the given schema
+        # Drop view from the given schema.
         >>> db_drop_view(view_name = 'temporary_view', schema_name = 'alice')
+
+        # Drop view by suppressing errors.
+        >>> db_drop_view(view_name = 'temporary_view', suppress_error = True)
     """
     # Argument validations
     awu_matrix = []
     awu_matrix.append(["schema_name", schema_name, True, (str), True])
     awu_matrix.append(["view_name", view_name, False, (str), True])
+    awu_matrix.append(["suppress_error", suppress_error, True, (bool)])
 
     # Validate argument types
     _Validators._validate_function_arguments(awu_matrix)
@@ -196,14 +209,18 @@ def db_drop_view(view_name, schema_name=None):
 
     try:
         return UtilFuncs._drop_view(view_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, "view",
-                                                       view_name),
-                                  MessageCodes.DROP_FAILED) from err
+        if suppress_error:
+            pass
+        else:
+            raise TeradataMlException(Messages.get_message(MessageCodes.DROP_FAILED, "view",
+                                                           view_name),
+                                      MessageCodes.DROP_FAILED) from err
 
 
 @collect_queryband(queryband='LstTbls')
@@ -422,7 +439,7 @@ def _get_select_table_kind(schema_name, table_name, table_kind, datalake_name):
             if object_table_kind is not None:
                 object_table_kind = ', '.join([f"'{value}'" for value in object_table_kind])
             query = SQLBundle._build_select_table_kind(schema_name, object_name_str, object_table_kind)
-            pddf = pd.read_sql(query, tdmlctx.td_connection.connection)
+            pddf = pd.read_sql(query, tdmlctx.get_connection())
 
         # Check if all table kind or volatile table kind is requested.
         # If so,add volatile tables to the pddf.
@@ -431,7 +448,7 @@ def _get_select_table_kind(schema_name, table_name, table_kind, datalake_name):
             # Create list of volatile tables.
             try:
                 vtquery = SQLBundle._build_help_volatile_table()
-                vtdf = pd.read_sql(vtquery, tdmlctx.td_connection.connection)
+                vtdf = pd.read_sql(vtquery, tdmlctx.get_connection())
                 if not vtdf.empty:
                     # Volatile table query returns different column names.
                     # So, rename its column names to match with normal
@@ -579,7 +596,7 @@ def db_transaction(func):
         True
         >>>
     """
-
+    @functools.wraps(func)
     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}"
@@ -1215,7 +1232,7 @@ def db_python_version_diff():
         raise TeradataMlException(Messages.get_message(MessageCodes.PYTHON_NOT_INSTALLED),
                                   MessageCodes.PYTHON_NOT_INSTALLED)
 
-    # Get major version of python installed on Vantage and the current environment.
+    # Get major version of Python installed on Vantage and the current environment.
     python_local = tdmlctx.python_version_local.rsplit(".", 1)[0]
     python_vantage = tdmlctx.python_version_vantage.rsplit(".", 1)[0]
 
@@ -1304,7 +1321,7 @@ def _create_table(table_name,
 
         columns:
             Required Argument.
-            Specifies a python dictionary with column-name(key) to column-type(value) mapping
+            Specifies a Python dictionary with column-name(key) to column-type(value) mapping
             to create table.
             Types: dict
 
@@ -1457,6 +1474,116 @@ def _create_table(table_name,
         raise TeradataMlException(Messages.get_message(msg_code, "create table", str(err)), msg_code)
 
 
+def _create_temporal_table(table_name,
+                           columns,
+                           validtime_columns,
+                           primary_index=None,
+                           partition_by_range=None,
+                           schema_name=None,
+                           skip_if_exists=False):
+    """
+    DESCRIPTION:
+        Internal function used to create validTime dimension temporal table.
+
+    PARAMETERS:
+        table_name:
+            Required Argument.
+            Specifies the name of SQL table.
+            Types: str
+
+        columns:
+            Required Argument.
+            Specifies a Python dictionary with column-name(key) to column-type(value) mapping
+            to create table. Column-type can be of type string or teradatasqlalchemy type.
+            Types: dict
+
+        validtime_columns:
+            Required Argument.
+            Specifies the validTime columns to be created in the table.
+            Note:
+                The columns specified in "validtime_columns" should be present in
+                "columns" argument.
+            Types: tuple of str
+
+        primary_index:
+            Optional Argument.
+            Specifies the column name(s) on which primary index needs to be created.
+            Types: str OR list of Strings (str)
+
+        partition_by_range:
+            Optional Argument.
+            Specifies the column name(s) on which partition by range needs to be created.
+            Types: str OR ColumnExpression
+
+        schema_name:
+            Optional Argument.
+            Specifies the name of the SQL schema in the database to write to.
+            If not specified, table is created in default schema.
+            Types: str
+
+    RETURNS:
+        None
+
+    RAISES:
+        None
+
+    EXAMPLES:
+        >>> from teradataml.dbutils.dbutils import _create_temporal_table
+        >>> from teradatasqlalchemy.types import *
+        # Example: Create a temporal table "Table1" with primary key constraint, partition it by range.
+        #          Make sure to specify column validTime temporal column from columns 'start_time'
+        #          and 'end_time'.
+        >>> _create_temporal_table(table_name="Table1",
+        ...                        columns={"column1": "VARCHAR(100)",
+        ...                                 "column2": INTEGER,
+        ...                                 "start_time": "TIMESTAMP(6)",
+        ...                                 "end_time": TIMESTAMP(6)},
+        ...                        schema_name = "vfs_test",
+        ...                        primary_index='column_name',
+        ...                        partition_by_range='column_name',
+        ...                        validtime_columns=('start_time', 'end_time'))
+    """
+    # Prepare column clause first.
+    columns_clause_ = ['{} {}'.format(k, v if isinstance(v, str)
+                            else v.compile(td_dialect())) for k, v in columns.items()]
+    if validtime_columns:
+        period_for_clause = ['PERIOD FOR ValidPeriod  ({}, {}) AS VALIDTIME'.format(
+            validtime_columns[0], validtime_columns[1])
+        ]
+    else:
+        period_for_clause = []
+    columns_clause = ",\n ".join(columns_clause_+period_for_clause)
+
+    # Prepare primary index clause.
+    if primary_index:
+        primary_index_clause = "PRIMARY INDEX ({})".format(
+            ", ".join(UtilFuncs._as_list(primary_index)))
+    else:
+        primary_index_clause = ""
+
+    # Prepare partition by range clause.
+    if partition_by_range:
+        partition_by_range_clause = "PARTITION BY RANGE_N({})".format(
+            partition_by_range if isinstance(partition_by_range, str) else partition_by_range.compile())
+    else:
+        partition_by_range_clause = ""
+
+    # Prepare create table statement.
+    table_name = UtilFuncs._get_qualified_table_name(schema_name, table_name) if\
+        schema_name else table_name
+    sql = """
+    CREATE MULTISET TABLE {}
+    (\n{}\n)\n{}\n{}
+    """.format(table_name, columns_clause, primary_index_clause, partition_by_range_clause)
+
+    if skip_if_exists:
+        execute_sql(sql, ignore_errors=3803)
+    else:
+        execute_sql(sql)
+
+    return True
+
+
 def _create_database(schema_name, size='10e6', spool_size=None,
                      datalake=None, **kwargs):
     """
@@ -1612,7 +1739,13 @@ def _update_data(update_columns_values, table_name, schema_name, datalake_name=N
     return True
 
 
-def _insert_data(table_name, values, columns=None, schema_name=None, datalake_name=None):
+def _insert_data(table_name,
+                 values,
+                 columns=None,
+                 schema_name=None,
+                 datalake_name=None,
+                 return_uid=False,
+                 ignore_errors=None):
     """
     DESCRIPTION:
         Internal function to insert the data in a table.
@@ -1644,8 +1777,30 @@ def _insert_data(table_name, values, columns=None, schema_name=None, datalake_na
             Specifies the name of the datalake to look for "schema_name".
             Types: str
 
+        return_uid:
+            Optional Argument.
+            Specifies whether the function should return the unique identifier
+            of the inserted row or not. When set to True, function returns the
+            unique ID generated by Teradata Vantage for the inserted row. Otherwise,
+            it returns True if the insert operation is successful.
+            Note:
+                This argument is only applicable when the table is created
+                in such a way it generates unique ID automatically.
+            Default Value: False
+            Types: bool
+
+        ignore_errors:
+            Optional Argument.
+            Specifies the error code(s) to ignore while inserting data.
+            If this argument is not specified, no errors are ignored.
+            Note:
+                Error codes are Teradata Vantage error codes and not
+                teradataml error codes.
+            Default Value: None
+            Types: int or list of int
+
     RETURNS:
-        bool
+        bool or int
 
     RAISES:
         TeradataMlException.
@@ -1668,10 +1823,14 @@ def _insert_data(table_name, values, columns=None, schema_name=None, datalake_na
         columns = ""
         _q_marks = ["?"] * (len(values[0]))
 
-    sql = "insert into {} {} values ({});".format(qualified_table_name, columns, ", ".join(_q_marks))
-    execute_sql(sql, values)
+    if not return_uid:
+        sql = "insert into {} {} values ({});".format(qualified_table_name, columns, ", ".join(_q_marks))
+        execute_sql(sql, values, ignore_errors)
+        return True
 
-    return True
+    sql = "{{fn teradata_agkr(C)}}insert into {} {} values ({});".format(qualified_table_name, columns, ", ".join(_q_marks))
+    c = execute_sql(sql, values, ignore_errors)
+    return c.fetchone()[0]
 
 
 def _upsert_data(update_columns_values,
@@ -1757,7 +1916,164 @@ def _upsert_data(update_columns_values,
     execute_sql(sql, (*update_values, *where_values, *insert_values))
 
 
-def _delete_data(table_name, schema_name=None, datalake_name=None, delete_conditions=None):
+def _merge_data(target_table,
+                target_table_alias_name,
+                source,
+                source_alias_name,
+                condition,
+                matched_details=None,
+                non_matched_clause=None,
+                temporal_clause=None,
+                target_table_schema=None,
+                source_table_schema=None):
+    """
+    DESCRIPTION:
+        Internal function to merge the data in a table.
+
+    PARAMETERS:
+        target_table:
+            Required Argument.
+            Specifies the name of the target table to merge.
+            Types: str
+
+        target_table_alias_name:
+            Required Argument.
+            Specifies the alias name of the target table to merge.
+            Types: str
+
+        source:
+            Required Argument.
+            Specifies the name of the source table to merge.
+            Can be a table name or a teradataml DataFrame.
+            Note:
+                Source can be a SELECT statement also. In this case,
+                one should add paranthesis for the query. For example,
+                value of source should be '(SELECT * FROM TABLE)' if
+                source is a query.
+            Types: str OR teradataml DataFrame
+
+        source_alias_name:
+            Required Argument.
+            Specifies the alias name of the source table to merge.
+            Types: str
+
+        condition:
+            Required Argument.
+            Specifies the condition to merge the data.
+            Types: str OR ColumnExpression
+
+        matched_details:
+            Optional Argument.
+            Specifies what to do when the condition is matched.
+            Teradata allows either UPDATE or DELETE when the condition is matched.
+            Note:
+                ColumnExpressions are not allowed for key 'set' since the aliases
+                should be with the alias name and setting alias name is not straight forward.
+                Hence, not allowing it for now.
+            Types: dict
+            Example: {"action": "UPDATE", "set": {"col1": "src.col1", "col2": "src.col2"}}
+
+        non_matched_clause:
+            Optional Argument.
+            Specifies what to do when the condition is not matched.
+            Teradata allows INSERT when the condition is not matched.
+            Note:
+                ColumnExpressions are not allowed in 'values' since the aliases
+                should be with the alias name and setting alias name is not straight forward.
+                Hence, not allowing it for now.
+            Types: dict
+            Example: {"action": "INSERT", "columns": ["col1", "col2"], "values": ["src.col1", "src.col2"]}
+
+        temporal_clause:
+            Optional Argument.
+            Specifies the temporal clause to be added to the MERGE statement.
+            Types: str
+
+        target_table_schema:
+            Optional Argument.
+            Specifies the schema name of the target table.
+            Types: str
+
+        source_table_schema:
+            Optional Argument.
+            Specifies the schema name of the source table.
+            Note:
+                If source is a DataFrame, this argument is ignored.
+            Types: str
+
+    RETURNS:
+        None
+
+    RAISES:
+        ValueError: If required parameters are missing or invalid.
+
+    EXAMPLES:
+        >>> _merge_data(
+        ...     target_table="target_table",
+        ...     target_table_alias_name="tgt",
+        ...     source="source_table",
+        ...     source_alias_name="src",
+        ...     condition="tgt.id = src.id",
+        ...     matched_details={"action": "UPDATE", "set": {"col1": "src.col1", "col2": "src.col2"}},
+        ...     non_matched_clause={"action": "INSERT", "columns": ["id", "col1"], "values": ["src.id", "src.col1"]}
+        ... )
+    """
+    # Note: Table names are not quoted because source can be a query also.
+    #       To keep it intact, both target tables and source tables are not
+    #       quoted. Hence it is caller function responsibility to add quote
+    #       if either source table or target table has special characters or
+    #       is from the user.
+    quote = UtilFuncs._get_dialect_quoted_name
+    if target_table_schema:
+        target_table = "{}.{}".format(quote(target_table_schema), target_table)
+    else:
+        target_table = target_table
+
+    # If source is DataFrame, extract the query from it.
+    if isinstance(source, str):
+        source = "{}.{}".format(quote(source_table_schema), source) \
+            if source_table_schema else source
+    else:
+        source = "({})".format(source.show_query())
+
+    # If condition is not a string, then prepare from it.
+    condition = condition if isinstance(condition, str) else condition.compile()
+
+    # Start building the MERGE statement
+    merge_sql = (f"MERGE INTO {target_table} AS {target_table_alias_name} \n\tUSING "
+                 f"{source} AS {source_alias_name} \n\tON {condition}")
+
+    # Handle matched clause
+    if matched_details:
+        action = matched_details.get("action", "").upper()
+        if action == "UPDATE":
+            set_clause = ", ".join([f"{col} = {val}"
+                                    for col, val in matched_details.get("set", {}).items()])
+            merge_sql += f"\n\tWHEN MATCHED THEN \n\t\tUPDATE \n\t\tSET \n\t\t{set_clause}"
+        elif action == "DELETE":
+            merge_sql += "\n\tWHEN MATCHED THEN \n\tDELETE\n\t\t"
+        else:
+            raise ValueError("Invalid action in matched_details. Supported actions are 'UPDATE' and 'DELETE'.")
+
+    # Handle non-matched clause
+    if non_matched_clause:
+        action = non_matched_clause.get("action", "").upper()
+        if action == "INSERT":
+            columns = ", ".join(non_matched_clause.get("columns", []))
+            values = ", ".join(non_matched_clause.get("values", []))
+            merge_sql += f"\n\tWHEN NOT MATCHED THEN \n\t\tINSERT ({columns}) \n\t\tVALUES \n\t\t({values})"
+        else:
+            raise ValueError("Invalid action in non_matched_clause. Supported action is 'INSERT'.")
+
+    # Finalize the statement
+    merge_sql += ";"
+    if temporal_clause:
+        merge_sql = "{} {}".format(temporal_clause, merge_sql)
+
+    execute_sql(merge_sql)
+
+
+def _delete_data(table_name, schema_name=None, datalake_name=None, delete_conditions=None, temporal_clause=None):
     """
     DESCRIPTION:
         Internal function to delete the data in a table.
@@ -1784,6 +2100,11 @@ def _delete_data(table_name, schema_name=None, datalake_name=None, delete_condit
             Specifies the ColumnExpression or dictionary containing key values
             pairs to use for removing the data.
             Types: ColumnExpression, dict
+        
+        temporal_clause:
+            Optional Argument.
+            Specifies the temporal clause to be added to the DELETE statement.
+            Types: str
 
     RETURNS:
         int, specifies the number of records those are deleted.
@@ -1819,6 +2140,9 @@ def _delete_data(table_name, schema_name=None, datalake_name=None, delete_condit
 
         sql = sqlbundle._get_sql_query(SQLConstants.SQL_DELETE_SPECIFIC_ROW).format(qualified_table_name, where_clause)
 
+    if temporal_clause:
+        sql = "{} {}".format(temporal_clause, sql)
+
     res = execute_sql(sql)
     return res.rowcount
 
@@ -1998,6 +2322,59 @@ def _execute_query_and_generate_pandas_df(query, index=None, **kwargs):
 
     return pandas_df
 
+def _is_trigger_exist(schema_name, trigger_names):
+    """
+    DESCRIPTION:
+        Checks if all given triggers exist in the specified schema.
+
+    PARAMETERS:
+        schema_name:
+            Required Argument.
+            Specifies the schema/database name.
+            Types: str
+
+        trigger_names:
+            Required Argument.
+            Specifies the trigger name(s) to check.
+            Types: str or list of str
+
+    RETURNS:
+        Tuple - first element specifies whether all provided triggers exist or not. 
+                second element specifies total number of triggers found from "trigger_names".
+
+    RAISES:
+        TeradataMlException
+
+    EXAMPLES:
+        >>> is_trigger_exist("mydb", ["trg1", "trg2"])
+        (True, 2)
+        >>> is_trigger_exist("mydb", ["trg1", "missing_trg"])
+        (False, 1)
+    """
+    # Normalize trigger_names to list
+    triggers = UtilFuncs._as_list(trigger_names)
+    if not triggers:
+        return False
+
+    # Prepare SQL to check all triggers in one call
+    triggers_str = ", ".join("'{}'".format(t) for t in triggers)
+    sql = f"""
+        SELECT TriggerName
+        FROM DBC.TriggersV
+        WHERE DatabaseName = '{schema_name}'
+        AND TriggerName IN ({triggers_str})
+    """
+
+    try:
+        result = execute_sql(sql)
+        found = {row[0] for row in result.fetchall()}
+        num_found = len(found)
+        all_exist = all(t in found for t in triggers)
+        return all_exist, num_found
+    except Exception as e:
+        raise TeradataMlException(
+            Messages.get_message(MessageCodes.EXECUTION_FAILED, "is_triggers_exist", str(e)),
+            MessageCodes.EXECUTION_FAILED)
 
 class _TDSessionParams:
     """
@@ -2277,6 +2654,14 @@ def unset_session_param(name):
         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)
+    if name.upper() == "DEBUG_FUNCTION":
+        # If unset param is debug_function, then check if any  function name is available to unset.
+        if _InternalBuffer.get('function_name') in ('', None):
+            raise TeradataMlException(
+                Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED, 
+                                     "unset_session_param",
+                                     "Set the parameter before unsetting it."),
+                MessageCodes.FUNC_EXECUTION_FAILED)
     # unset_values stores params which are not available in _InternalBuffer, to unset create a dictionary
     # with param as key and unset param as value
     # TODO: Unset for ISOLATED_LOADING should revert to previous behaviour, but we are setting it to NO.
@@ -2307,10 +2692,10 @@ def unset_session_param(name):
 
 
 class _Authorize:
-    """ Parent class to either provide or revoke access on table(s). """
+    """ Parent class to either provide or revoke access on database objects. """
     _property = None
 
-    def __init__(self, objects):
+    def __init__(self, objects, database=None):
         """
         DESCRIPTION:
             Constructor for creating Authorize object.
@@ -2319,7 +2704,12 @@ class _Authorize:
             objects:
                 Required Argument.
                 Specifies the name(s) of the database objects to be authorized.
-                Types: str OR list of str.
+                Types: str OR list of str OR AccessType Enum
+
+            database:
+                Optional Argument.
+                Specifies the name of the database to grant or revoke access.
+                Types: str
 
         RETURNS:
             Object of _Authorize.
@@ -2331,8 +2721,10 @@ class _Authorize:
             >>> auth = _Authorize('vfs_v1')
         """
         # Store the objects here. Then use this where ever required.
+        self._is_enum = issubclass(objects, enum.Enum)
         self._objects = objects
         self._access_method = self.__class__.__name__.upper()
+        self.database = database
 
     def read(self, user):
         """
@@ -2356,11 +2748,7 @@ class _Authorize:
         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
+        return self._apply_access(user, 'read', 'SELECT')
 
     def write(self, user):
         """
@@ -2384,11 +2772,58 @@ class _Authorize:
         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 self._apply_access(user, 'write', 'INSERT, UPDATE, DELETE')
+    
+    def _apply_access(self, user, operation, access_type):
+        """
+        DESCRIPTION:
+            Internal function to grant or revoke access.
+
+        PARAMETERS:
+            user:
+                Required Argument.
+                Specifies the name of the user to have access.
+                Types: str
+
+            operation:
+                Required Argument.
+                Specifies the operation to perform.
+                Permitted Values: 'read', 'write'
+                Types: str
 
+            access_type:
+                Required Argument.
+                Specifies the type of access to grant or revoke.
+                Permitted Values: 
+                    * 'SELECT' for read 
+                    * 'INSERT, UPDATE, DELETE' for write
+                Types: str
+
+        RETURNS:
+            bool, True if access is granted or revoked successfully.
+
+        RAISES:
+            TeradataMlException, OperationalError
+
+        EXAMPLES:
+            >>> _Authorize('repo')._apply_access('BoB', 'read', 'SELECT')
+        """
+        sql_objects = UtilFuncs._as_list(self._objects) if not self._is_enum else \
+                      getattr(self._objects, operation).value
+
+        for obj in sql_objects:
+            if self._is_enum:
+                sql = obj.format(
+                    grant_revoke_=self._access_method,
+                    database_=self.database,
+                    to_from_=self._property,
+                    user_=user
+                )
+            else:
+                sql = "{} {} ON {} {} {}".format(
+                    self._access_method, access_type, obj, self._property, user
+                )
+            execute_sql(sql)
         return True
 
     def read_write(self, user):