teradataml 17.20.0.6__py3-none-any.whl → 20.0.0.0__py3-none-any.whl

teradataml/common/utils.py

@@ -22,6 +22,8 @@ import sqlalchemy
 from pathlib import Path
 from numpy import number
 from sqlalchemy import Column, MetaData, Table
+from teradataml.context.context import get_connection
+
 from teradataml import _version
 from teradataml.context import context as tdmlctx
 from teradataml.common.exceptions import TeradataMlException
@@ -37,7 +39,7 @@ from teradataml.common.constants import TeradataConstants, PTITableConstants, \
 from teradataml.common.warnings import VantageRuntimeWarning
 from teradataml.options.configure import configure
 from teradataml.options.display import display
-from teradataml.common.constants import TeradataReservedKeywords
+from teradataml.common.constants import TeradataReservedKeywords, TeradataConstants
 
 from teradatasqlalchemy.types import _TDType
 from teradatasqlalchemy.types import (INTEGER, SMALLINT, BIGINT, BYTEINT,
@@ -45,162 +47,13 @@ from teradatasqlalchemy.types import (INTEGER, SMALLINT, BIGINT, BYTEINT,
 from teradatasqlalchemy.types import (DATE, TIME, TIMESTAMP)
 from teradatasqlalchemy.types import (BYTE, VARBYTE, BLOB)
 from teradatasqlalchemy.types import (CHAR, VARCHAR, CLOB)
-from functools import wraps, reduce
+from functools import reduce
 import warnings
+from teradatasqlalchemy.telemetry.queryband import set_queryband, collect_queryband, get_qb_query
 from teradataml.utils.utils import execute_sql
 from teradataml.utils.validators import _Validators
 from sqlalchemy.exc import OperationalError as sqlachemyOperationalError
 
-def package_deprecation(version, replacement=None, type="class"):
-    """
-    Define a deprecation decorator.
-
-    PARAMETERS:
-        replacement:
-            Optional Argument.
-            `replacement` should refer to the new API to be used instead.
-
-        type:
-            Optional Argument.
-             Specifies the type of entity being deprecated.
-             For example,
-                class or function
-
-    EXAMPLES:
-        @package_deprecation('16.20.x.y')
-        def old_func(): ...
-        @package_deprecation('16.20.x.y', 'teradataml.analytics.mle')
-        def old_func(): ..."""
-
-    def decorator(func):
-        def wrapper(*args, **kwargs):
-            msg = "\nThe \"{}\" {} has moved to a new package in version {}."
-            if replacement:
-                msg += "\nImport from the teradataml package, or directly from the {} module." + \
-                       "\nSee the teradataml {} User Guide for more information."
-            warnings.warn(msg.format('.'.join([func.__module__, func.__name__]), type, version,
-                                     replacement + '.' + func.__name__, version),
-                          category=DeprecationWarning, stacklevel=2)
-            return func(*args, **kwargs)
-
-        return wraps(func)(wrapper)
-
-    return decorator
-
-def argument_deprecation(tdml_version, deprecated_arguments, behaviour=False, alternatives=None):
-    """
-    Decorator for deprecating of argument(s) for a function or class constructor.
-
-    PARAMETERS:
-        tdml_version:
-            Required Argument.
-            Specifies the teradataml version when the argument will be deprecated.
-            Types: str
-
-        deprecated_arguments:
-            Required Argument.
-            Specifies the name(s) of the argument(s) to be deprecated.
-            Types: str OR list of Strings (str)
-        
-        behaviour:
-            Optional Argument.
-            Specifies whether behaviour of the argument is deprecated.
-            Types: bool
-
-        alternatives:
-            Optional Argument.
-            Specifies the name(s) of the argument(s) that are alternative
-            to the deprecate arguments.
-            Types: str OR list of Strings (str)
-        
-
-    EXAMPLES:
-        # Example 1: Deprecate behavior of arguments "arg1" and "arg2".
-        @argument_deprecation("17.20.00.02", ["arg1", "arg2"], True)
-        def old_func(self): ...
-
-        # Example 2: Deprecate argument completely.
-        @argument_deprecation("17.20.00.02", "old_arg")
-        def old_func(self): ...
-
-        # Example 3: Deprecate arguments completely with alternative.
-        @argument_deprecation("17.20.00.02", ["arg1", "arg2"], False, ["new_arg"])
-        def old_func(self): ...
-
-        # Example 4: Deprecate behavior of arguments "old_arg1" and "old_arg2" and provide alternatives.
-        @argument_deprecation("17.20.00.02", ["arg1", "arg2"], True, ["alt_arg1", "alt_arg2"])
-        def old_func(self): ...
-
-    """
-    def decorator(func):
-        def wrapper(*args, **kwargs):
-            msg = "\nThe argument(s) \"{}\" will be deprecated in {}."
-            if behaviour:
-                msg = "\nBehaviour of the argument(s) \"{}\" will change in {}."
-            msg = msg.format(deprecated_arguments, tdml_version)
-            if alternatives is not None:
-                msg += "\nUse argument(s) \"{}\" instead.".format(alternatives)
-            warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
-            return func(*args, **kwargs)
-
-        return wraps(func)(wrapper)
-    return decorator
-
-def function_deprecation(tdml_version, behaviour=False, alternatives=None):
-    """
-    Decorator for deprecating a function.
-
-    PARAMETERS:
-        tdml_version:
-            Required Argument.
-            Specifies the teradataml version when the function will be deprecated.
-            Types: str
-
-        behaviour:
-            Optional Argument.
-            Specifies whether behaviour of the function is deprecated.
-            Default value: False
-            Types: bool
-            
-
-        alternatives:
-            Optional Argument.
-            Specifies the name of the function that is alternative
-            to the deprecate function.
-            Default value: None
-            Types: str
-        
-
-    EXAMPLES:
-        # Example 1: Deprecate behavior of function "old_func".
-        @function_deprecation("17.20.00.03", True)
-        def old_func(self): ...
-
-        # Example 2: Deprecate function "old_func" completely.
-        @function_deprecation("17.20.00.03")
-        def old_func(self): ...
-
-        # Example 3: Deprecate function "old_func" completely with alternative function "new_func".
-        @function_deprecation("17.20.00.03", False, "new_func")
-        def old_func(self): ...
-
-        # Example 4: Deprecate behavior of function "old_func".
-        @function_deprecation("17.20.00.03", True)
-        def old_func(self): ...
-    """
-    def decorator(func):
-        def wrapper(*args, **kwargs):
-            msg = "\nThe function \"{}\" will be deprecated in {}."
-            if behaviour:
-                msg = "\nBehaviour of the function \"{}\" will change in {}."
-            msg = msg.format(func.__name__, tdml_version)
-            if alternatives is not None:
-                msg += "\nInstead, Use following function \"{}\".".format(alternatives)
-            warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
-            return func(*args, **kwargs)
-        return wraps(func)(wrapper)
-    return decorator
-
 
 class UtilFuncs():
     def _get_numeric_datatypes(self):
@@ -467,7 +320,8 @@ class UtilFuncs():
     @staticmethod
     def _generate_temp_script_name(database_name=None, prefix=None, use_default_database=True,
                                    gc_on_quit=True, quote=True,
-                                   script_type=TeradataConstants.TERADATA_SCRIPT):
+                                   script_type=TeradataConstants.TERADATA_SCRIPT,
+                                   extension=None):
         """
         DESCRIPTION:
             Function to return the random string for temporary script names.
@@ -512,6 +366,12 @@ class UtilFuncs():
                 Default value: TeradataConstants.TERADATA_SCRIPT
                 Types: TeradataConstant
 
+            extension:
+                Optional Argument.
+                Specifies the extension of the script.
+                Default value: None
+                Types: str
+
         RETURNS:
             Temporary script name.
 
@@ -540,6 +400,9 @@ class UtilFuncs():
 
         script_name = "{}_{}".format(script_name, random_string)
 
+        if extension is not None:
+            script_name = "{}.{}".format(script_name, extension)
+
         dbname_to_use = tdmlctx._get_current_databasename()
         if not use_default_database and database_name is not None:
             dbname_to_use = database_name
@@ -634,6 +497,8 @@ class UtilFuncs():
             UtilFuncs._execute_ddl_statement('create table mytab (col1 int, col2 varchar(20))')
 
         """
+        # Empty queryband buffer before SQL call.
+        UtilFuncs._set_queryband()
         # Let's execute our DDL statement with escape function '{fn teradata_fake_result_sets}'
         # offered by teradatasql driver. This function will allow us catch any warnings thrown
         # from the Vantage. Hence, executing the DDL statement with this escape function.
@@ -719,6 +584,8 @@ class UtilFuncs():
             UtilFuncs._execute_query("call SYSUIF.list_base_environments()", False, True)
 
         """
+        # Empty queryband buffer before SQL call.
+        UtilFuncs._set_queryband()
 
         if fetchWarnings:
             # Let's execute our DDL statement with escape function '{fn teradata_fake_result_sets}'
@@ -772,6 +639,7 @@ class UtilFuncs():
                                       MessageCodes.CONNECTION_FAILURE)
 
     @staticmethod
+    @collect_queryband(queryband='CreateView')
     def _create_view(view_name, query):
         """
         Create a view from the given query.
@@ -796,6 +664,7 @@ class UtilFuncs():
             raise
 
     @staticmethod
+    @collect_queryband(queryband='CreateTbl')
     def _create_table(table_name, query, volatile=False):
         """
         Create a table from the given query.
@@ -846,6 +715,7 @@ class UtilFuncs():
         return [str(i) for i in result[0]]
 
     @staticmethod
+    @collect_queryband(queryband='CreateVolaTbl')
     def _get_volatile_table(query, with_data=False):
         """
         Creates a volatile table as query.
@@ -944,7 +814,8 @@ class UtilFuncs():
         return False
 
     @staticmethod
-    def _delete_script(script_name, check_script_exist=True):
+    def _delete_script(script_name, file_type=TeradataConstants.TERADATA_SCRIPT,
+                       check_script_exist=True):
         """
         DESCRIPTION:
             Function to remove a user-installed file/script.
@@ -955,8 +826,18 @@ class UtilFuncs():
                 Specifies the name of the script to remove.
                 Types: str
 
+            file_type:
+                Optional Argument.
+                Specifies the type of the file to remove, whether it is from
+                Enterpise (TeradataConstants.TERADATA_SCRIPT) or from Lake
+                (TeradataConstants.TERADATA_APPLY).
+                Default value: TeradataConstants.TERADATA_SCRIPT
+                Permitted Values: TeradataConstants.TERADATA_SCRIPT, TeradataConstants.TERADATA_APPLY
+                Types: TeradataConstants
+
             check_script_exist:
-                Required Argument.
+                Required Argument. Applicable only when "file_type" is
+                TeradataConstants.TERADATA_SCRIPT. Ignored otherwise.
                 Specifies whether to check if the script exists or not before removing it.
                 When 'True', the presence of the script will be check for.
                 Default value: True
@@ -980,30 +861,44 @@ class UtilFuncs():
                                                        quote='"')
         current_db = tdmlctx._get_current_databasename()
 
-        script_exists = False
-        if check_script_exist:
-            query = "select count(*) from dbc.tablesV " \
-                    "where databasename = '{}' and tablename = '{}' " \
-                    "and tablekind = 'Z'".format(dbname, script_alias)
-
-            script_exists = True if UtilFuncs._execute_query(query)[0][0] == 1 else False
-
-        if script_exists or not check_script_exist:
-            try:
-                # If the database is not the current/default database, we need to
-                # set that as the session database to be able to remove the file.
-                if dbname.lower() != current_db.lower():
-                    execute_sql('database {}'.format(dbname))
+        if file_type == TeradataConstants.TERADATA_SCRIPT:
+            script_exists = False
+            if check_script_exist:
+                query = "select count(*) from dbc.tablesV " \
+                        "where databasename = '{}' and tablename = '{}' " \
+                        "and tablekind = 'Z'".format(dbname, script_alias)
+
+                script_exists = True if UtilFuncs._execute_query(query)[0][0] == 1 else False
+
+            if script_exists or not check_script_exist:
+                try:
+                    # If the database is not the current/default database, we need to
+                    # set that as the session database to be able to remove the file.
+                    if dbname and dbname.lower() != current_db.lower():
+                        execute_sql('database {}'.format(dbname))
+
+                    # Strip off the file extension and extract the base name.
+                    from pathlib import Path
+                    script_base_name = Path(script_alias).stem
+
+                    # Remove the file.
+                    remove_file(script_base_name, force_remove=True, suppress_output=True)
+                    return True
+                except:
+                    raise
+                finally:
+                    # Reset the database if it was set to something else.
+                    if dbname and dbname.lower() != current_db.lower():
+                        execute_sql('database {}'.format(current_db))
+        else:
+            # environment name and file name are separated by '::'
+            # like <user_env_name(str)>::<apply_script_name>
+            env_name, script_alias = script_alias.split('::')
 
-                # Remove the file.
-                remove_file(script_alias, force_remove=True, suppress_output=True)
-                return True
-            except:
-                raise
-            finally:
-                # Reset the database if it was set to something else.
-                if dbname.lower() != current_db.lower():
-                    execute_sql('database {}'.format(current_db))
+            from teradataml.scriptmgmt.lls_utils import get_env
+            env = get_env(env_name)
+            env.remove_file(script_alias, suppress_output=True)
+            return True
 
     @staticmethod
     def _get_help_vtablenames():
@@ -1697,114 +1592,6 @@ class UtilFuncs():
         supported_engines = TeradataConstants.SUPPORTED_ENGINES.value
         return supported_engines[engine]['name']
 
-    @staticmethod
-    def _get_function_mappings_from_config_file(alias_config_file):
-        """
-        Function to return the function mappings given the location of configuration file in
-        argument 'alias_config_file'.
-
-        PARAMETERS:
-            alias_config_file:
-                Required Argument.
-                Specifies the location of configuration file to be read.
-
-        RETURNS:
-            Function mappings as a dictionary of function_names to alias_names.
-
-        RAISES:
-            TeradataMLException
-
-        EXAMPLES:
-            UtilFuncs._get_function_mappings_from_config_file("config_file_location")
-
-        """
-        repeated_function_names = []
-        function_mappings = {}
-        invalid_function_mappings = []
-        invalid_function_mappings_line_nos = []
-        # Reading configuration files
-        with open(alias_config_file, 'r') as fread:
-            for line_no, line in enumerate(fread.readlines()):
-                line = line.strip()
-
-                # Ignoring empty lines in the config files.
-                if line == "":
-                    continue
-
-                # If the separator ":" is not present.
-                if ':' not in line:
-                    invalid_function_mappings.append(line)
-                    invalid_function_mappings_line_nos.append(str(line_no + 1))
-                else:
-                    func_name, alias_name = line.split(":")
-                    func_name = func_name.strip()
-                    alias_name = alias_name.strip()
-
-                    # First line of 'alias_config_file' has header "functionName:aliasName".
-                    if line_no == 0 and func_name == "functionName" and alias_name == "aliasName":
-                        continue
-
-                    if func_name == "" or alias_name == "":
-                        invalid_function_mappings.append(line)
-                        invalid_function_mappings_line_nos.append(str(line_no + 1))
-                        continue
-
-                    if func_name.lower() in function_mappings:
-                        repeated_function_names.append(func_name.lower())
-
-                    # Loading function maps with lower values for key.
-                    function_mappings[func_name.lower()] = alias_name
-
-        # Presence of Invalid function mappings in the 'alias_config_file'.
-        if len(invalid_function_mappings) > 0:
-            err_ = Messages.get_message(MessageCodes.CONFIG_ALIAS_INVALID_FUNC_MAPPING)
-            err_ = err_.format("', '".join(invalid_function_mappings),
-                               ", ".join(invalid_function_mappings_line_nos),
-                               alias_config_file)
-            raise TeradataMlException(err_, MessageCodes.CONFIG_ALIAS_INVALID_FUNC_MAPPING)
-
-        # Raising teradataml exception if there are any duplicates in function names.
-        if len(repeated_function_names) > 0:
-            raise TeradataMlException(Messages.get_message(
-                MessageCodes.CONFIG_ALIAS_DUPLICATES).format(alias_config_file,
-                                                             ", ".join(repeated_function_names)),
-                                      MessageCodes.CONFIG_ALIAS_DUPLICATES)
-
-        return function_mappings
-
-    @staticmethod
-    def _check_alias_config_file_exists(vantage_version, alias_config_file):
-        """
-        Function to validate whether alias_config_file exists for the current vantage version.
-
-        PARAMETERS:
-            vantage_version:
-                Required Argument.
-                Specifies the current vantage version.
-
-            alias_config_file:
-                Required Argument.
-                Specifies the location of configuration file to be read.
-
-        RETURNS:
-            True, if the file 'alias_config_file' is present in the
-            teradataml/config directory for the current vantage version.
-
-        RAISES:
-            TeradataMLException
-
-        EXAMPLES:
-            UtilFuncs._check_alias_config_file_exists("vantage1.0", "config_file_location")
-
-        """
-        # Raise exception if alias config file is not defined.
-        if not Path(alias_config_file).exists():
-            raise TeradataMlException(Messages.get_message(
-                MessageCodes.CONFIG_ALIAS_CONFIG_FILE_NOT_FOUND).format(alias_config_file,
-                                                                        vantage_version),
-                                      MessageCodes.CONFIG_ALIAS_CONFIG_FILE_NOT_FOUND)
-        return True
-
     @staticmethod
     def _as_list(obj):
         """
@@ -1856,7 +1643,7 @@ class UtilFuncs():
             obj = UtilFuncs._get_all_columns(df, False)
         """
         if is_object_type_tdml_column:
-            return object.expression.table.columns
+            return UtilFuncs._all_df_column_expressions(object)
         # object._metaexpr.c extracts the data to a list. And, the caller of
         # this function will again iterate through the list, to process the
         # list i.e. object._metaexpr.c is being iterated twice. To avoid this,
@@ -2495,6 +2282,137 @@ class UtilFuncs():
             return True
         return False
 
+    @staticmethod
+    def _all_df_column_expressions(df_column):
+        """
+        DESCRIPTION:
+            A method to get all the SQLALchemy Columns involved in corresponding DataFrame.
+
+        PARAMETERS:
+            df_column:
+                Required Argument.
+                Specifies teradataml DataFrame ColumnExpression.
+                Types: teradataml DataFrame ColumnExpression
+
+        RAISES:
+            None
+
+        RETURNS:
+            list
+
+        EXAMPLES:
+            >>> self._all_df_column_expressions
+        """
+        cols = []
+        for table_ in df_column._get_sqlalchemy_tables(df_column.expression):
+            cols = cols + list(table_.columns)
+        return cols
+
+    @staticmethod
+    def _all_df_columns(df_column):
+        """
+        DESCRIPTION:
+            A method to get all the column names involved in corresponding DataFrame.
+
+        PARAMETERS:
+            df_column:
+                Required Argument.
+                Specifies teradataml DataFrame ColumnExpression.
+                Types: teradataml DataFrame ColumnExpression
+
+        RAISES:
+            None
+
+        RETURNS:
+            list
+
+        EXAMPLES:
+            >>> self._all_df_columns
+        """
+        return [col.name for col in UtilFuncs._all_df_column_expressions(df_column)]
+
+    @staticmethod
+    def _is_lake():
+        """
+        DESCRIPTION:
+            An internal function to check whether system is Lake or enterprise.
+
+        PARAMETERS:
+            None.
+
+        RAISES:
+            None
+
+        RETURNS:
+            bool
+
+        EXAMPLES:
+            >>> self._is_lake()
+        """
+
+        from teradataml.context.context import _get_database_version
+        return int(_get_database_version().split(".")[0]) >= 20
+
+    @staticmethod
+    def _get_python_execution_path():
+        """
+         DESCRIPTION:
+             An internal function to get the python execution path.
+
+         PARAMETERS:
+             None.
+
+         RAISES:
+             None
+
+         RETURNS:
+             bool
+
+         EXAMPLES:
+             >>> self._get_python_execution_path()
+         """
+
+        if UtilFuncs._is_lake():
+            return "python"
+        else:
+            if configure.indb_install_location == "/var/opt/teradata/languages/sles12sp3/Python/":
+                return '{}bin/python3'.format(configure.indb_install_location)
+            else:
+                return configure.indb_install_location
+
+    def _is_view(tablename):
+        """
+        DESCRIPTION:
+            Internal function to check whether the object is view or not.
+        PARAMETERS:
+            tablename:
+                Required Argument.
+                Table name or view name to be checked.
+                Types: str
+        RAISES:
+            None.
+        RETURNS:
+            True when the tablename is view, else false.
+        EXAMPLES:
+            >>> _is_view('"dbname"."tablename"')
+        """
+        db_name = UtilFuncs._teradata_unquote_arg(UtilFuncs._extract_db_name(tablename), "\"")
+        table_view_name = UtilFuncs._teradata_unquote_arg(UtilFuncs._extract_table_name(tablename), "\"")
+        query = SQLBundle._build_select_table_kind(db_name, "{0}".format(table_view_name), "'V'")
+
+        df = UtilFuncs._execute_query(query)
+        if len(df) > 0:
+            return True
+        else:
+            return False
+    @staticmethod
+    def _set_queryband():
+        try:
+            qb_query = get_qb_query()
+            execute_sql(qb_query)
+        except Exception:
+            pass
+
 
 from teradataml.common.aed_utils import AedUtils
 from teradataml.dbutils.filemgr import remove_file