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

teradataml/common/messagecodes.py

@@ -126,6 +126,8 @@ class ErrorInfoCodes(Enum):
     CANNOT_USE_TOGETHER_WITH = 'TDML_2042'
     TABLE_DOES_NOT_EXIST = 'TDML_2046'
     DEPENDENT_METHOD = 'TDML_2113'
+    TDMLDF_COLUMN_IN_ARG_FOUND = 'TDML_2114'
+    EITHER_ANY_ARGUMENT = 'TDML_2115'
 
     # Reserved for Generic Error Messages: 2121 - 2199
     RESERVED_KEYWORD = 'TDML_2121'
@@ -227,6 +229,38 @@ class ErrorInfoCodes(Enum):
 
     # OpenAF Error codes starting from 2551 - Reserved till 2560.
     SET_REQUIRED_PARAMS = 'TDML_2551'
+    INVALID_USAGE = 'TDML_2552'
+
+    # Error codes for OTF. Reserved till 2570.
+    OTF_TABLE_REQUIRED = 'TDML_2561'
+
+    # Rest Excceptions. Reserved for 2570 - 2580
+    REST_HTTP_ERROR = 'TDML_2570'
+    REST_AUTH_MISSING_ARG = 'TDML_2571'
+    REST_NOT_CONFIGURED = 'TDML_2572'
+    REST_DEVICE_CODE_NO_BOTH = 'TDML_2573'
+    REST_DEVICE_CODE_GEN_FAILED = 'TDML_2574'
+    REST_DEVICE_CODE_AUTH_FAILED = 'TDML_2575'
+
+    # Python SDK Error codes starting from 2580 - Reserved till 2590.
+    INFO_NOT_PROVIDED_USE_DEFAULT = 'TDML_W_2580' # Logger warning.
+
+    # EFS Error codes starting from 2600 - Reserved till 2650.
+    EFS_COMPONENT_NOT_EXIST = 'TDML_2600'
+    EFS_INVALID_PROCESS_TYPE = 'TDML_2601'
+    EFS_INVALID_FEATURE_TYPE = 'TDML_2602'
+    EFS_FEATURE_IN_DATASET = 'TDML_2603'
+    EFS_FEATURE_IN_CATALOG = 'TDML_2604'
+    EFS_ENTITY_IN_CATALOG = 'TDML_2605'
+    DF_DUPLICATE_VALUES = 'TDML_2606'
+    DF_NULL_VALUES = 'TDML_2607'
+    EFS_FEATURE_ENTITY_MISMATCH = 'TDML_2608'
+    FEATURES_ARCHIVED = 'TDML_2609'
+    EFS_DELETE_BEFORE_ARCHIVE = 'TDML_2610'
+    EFS_OBJ_IN_FEATURE_PROCESS = 'TDML_2611'
+    EFS_OBJECT_NOT_EXIST = 'TDML_2612'
+    EFS_OBJECT_IN_OTHER_DOMAIN = 'TDML_2613'
+
 
 class MessageCodes(Enum):
     """
@@ -373,7 +407,7 @@ class MessageCodes(Enum):
     VANTAGE_WARNING                = "Following warning raised from Vantage with warning code: {}\n{}"
     FASTLOAD_FAILS                  = "fastload() failed to load pandas dataframe to Teradata Vantage."
     REMOVE_FILE_FAILED              = "Failed to remove {} from Teradata Vantage"
-    INPUT_FILE_NOT_FOUND            = "Input file '{}' not found. Please check the file path."
+    INPUT_FILE_NOT_FOUND            = "Input file(s) '{}' not found. Please check the file path(s)."
     INSTALL_FILE_FAILED             = "File '{}' cannot be installed."
     REPLACE_FILE_FAILED             = "Unable to replace '{}'"
     URL_UNREACHABLE                 = "URL '{}' is unreachable."
@@ -396,6 +430,7 @@ class MessageCodes(Enum):
     NO_ENVIRONMENT_FOUND            = "No {} environment(s) found."
     UNSUPPORTED_FILE_EXTENSION      = "Unsupported file extension specified. Supported file extensions is/are {}."
     FILE_EMPTY               = "Input file {} is empty."
+    EITHER_ANY_ARGUMENT    = "Provide either {} argument(s)."
 
     PYTHON_NOT_INSTALLED = "Python is not installed on Vantage. " \
                            "Please install Python interpreter and add-on packages on Vantage."
@@ -442,3 +477,40 @@ class MessageCodes(Enum):
                         "explicitly passed to function or specified using a configuration file, or setting up " \
                         "the environment variables."
     DEPENDENT_METHOD = "Method(s) {} must be called before calling '{}'."
+    TDMLDF_COLUMN_IN_ARG_FOUND = "Column '{}' provided in '{}' argument, exist in {} {}."
+    INVALID_USAGE = "Invalid usage of {0} {1}. Use {0} {1} only {2}."
+    REST_HTTP_ERROR = "Failed to run rest API:\n{}"
+    REST_AUTH_MISSING_ARG = "For '{}' authentication, '{}' is/are not provided in config file or "\
+                            "environment variable or through constructor argument 'auth'."
+    REST_NOT_CONFIGURED = "The argument '{}' is not set. {} endpoint not configured.\n" \
+                          "Try (re)copy the CLI configuration from {} UI -> Session Details -> CLI Config."
+    REST_DEVICE_CODE_NO_BOTH = "Token does not contain access_token or refresh_token. Received token: {}"
+    REST_DEVICE_CODE_GEN_FAILED = "Error generating the device code. Received code: {}."
+    REST_DEVICE_CODE_AUTH_FAILED = "Error authenticating the device code.\n{}."
+
+    INFO_NOT_PROVIDED_USE_DEFAULT = "{} is not provided in path '{}' method '{}' for operationID '{}' using default {}."
+    OTF_TABLE_REQUIRED = "{} is supported only with OTF table."
+    EFS_COMPONENT_NOT_EXIST = "{} '{}' does not exist. Use {} to list valid {}."
+    EFS_INVALID_PROCESS_TYPE = "Invalid process type '{}' detected. Valid types are: {}."
+    EFS_INVALID_FEATURE_TYPE = ("Invalid feature type '{}' detected for feature ''. "
+                                "Features cannot ignest for types: {}.")
+    EFS_FEATURE_IN_DATASET = ("Feature(s) {} is/are associated with an existing dataset(s) {}. "
+                              "Feature(s) can be {} only when they are not associated with any dataset. "
+                              "Use 'DatasetCatalog.list_datasets()' to see the list of features associated with datasets.")
+    EFS_FEATURE_IN_CATALOG = ("Feature '{}' exists in feature catalog. " 
+                              "Delete the feature first using FeatureCatalog.delete_features().")
+    EFS_ENTITY_IN_CATALOG = ("Entity '{}' is associated with feature(s) {} in Feature catalog. "
+                             "Delete these features using FeatureCatalog.delete_features().")
+    DF_DUPLICATE_VALUES = "Duplicate {} are not allowed. Found the duplicate value(s) {}."
+    DF_NULL_VALUES = ("Null value(s) are not allowed in {} while {}. "
+                       "Found the null value(s) {}.")
+    EFS_FEATURE_ENTITY_MISMATCH = ("Feature(s) {} is/are associated with entities {}. One cannot "
+                                   "ingest same feature for another entity in the same data domain. "
+                                   "Either choose a different feature name or choose a different data domain.")
+    FEATURES_ARCHIVED = "Feature(s) {} is/are archived. {}"
+    EFS_DELETE_BEFORE_ARCHIVE = ("{0} '{1}' is not archived. Archive the {0} before deleting it."
+                                 "Use 'FeatureStore.archive_{2}()' to archive the {0}.")
+    EFS_OBJ_IN_FEATURE_PROCESS = ("{0} '{1}' is associated with {2}. {0} can be modified only when it is "
+                                  "not associated with {2}. Archive the {3} using {4} and try again.")
+    EFS_OBJECT_NOT_EXIST = "{} with {} does not exist in data domain '{}'."
+    EFS_OBJECT_IN_OTHER_DOMAIN = "{} with {} does not exist in data domain '{}'. It exists in other data domain(s): {}."

teradataml/common/messages.py

@@ -196,7 +196,33 @@ class Messages():
             [ErrorInfoCodes.TARGET_COL_NOT_FOUND_FOR_EVALUATE, MessageCodes.TARGET_COL_NOT_FOUND_FOR_EVALUATE],
             [ErrorInfoCodes.SET_REQUIRED_PARAMS, MessageCodes.SET_REQUIRED_PARAMS],
             [ErrorInfoCodes.MISSING_ARGS, MessageCodes.CONNECTION_PARAMS],
-            [ErrorInfoCodes.DEPENDENT_METHOD, MessageCodes.DEPENDENT_METHOD]
+            [ErrorInfoCodes.DEPENDENT_METHOD, MessageCodes.DEPENDENT_METHOD],
+            [ErrorInfoCodes.TDMLDF_COLUMN_IN_ARG_FOUND, MessageCodes.TDMLDF_COLUMN_IN_ARG_FOUND],
+            [ErrorInfoCodes.INVALID_USAGE, MessageCodes.INVALID_USAGE],
+            [ErrorInfoCodes.DEPENDENT_METHOD, MessageCodes.DEPENDENT_METHOD],
+            [ErrorInfoCodes.REST_HTTP_ERROR, MessageCodes.REST_HTTP_ERROR],
+            [ErrorInfoCodes.REST_AUTH_MISSING_ARG, MessageCodes.REST_AUTH_MISSING_ARG],
+            [ErrorInfoCodes.REST_NOT_CONFIGURED, MessageCodes.REST_NOT_CONFIGURED],
+            [ErrorInfoCodes.REST_DEVICE_CODE_NO_BOTH, MessageCodes.REST_DEVICE_CODE_NO_BOTH],
+            [ErrorInfoCodes.REST_DEVICE_CODE_GEN_FAILED, MessageCodes.REST_DEVICE_CODE_GEN_FAILED],
+            [ErrorInfoCodes.REST_DEVICE_CODE_AUTH_FAILED, MessageCodes.REST_DEVICE_CODE_AUTH_FAILED],
+            [ErrorInfoCodes.INFO_NOT_PROVIDED_USE_DEFAULT, MessageCodes.INFO_NOT_PROVIDED_USE_DEFAULT],
+            [ErrorInfoCodes.OTF_TABLE_REQUIRED, MessageCodes.OTF_TABLE_REQUIRED],
+            [ErrorInfoCodes.EFS_COMPONENT_NOT_EXIST, MessageCodes.EFS_COMPONENT_NOT_EXIST],
+            [ErrorInfoCodes.EFS_INVALID_PROCESS_TYPE, MessageCodes.EFS_INVALID_PROCESS_TYPE],
+            [ErrorInfoCodes.EFS_FEATURE_IN_DATASET, MessageCodes.EFS_FEATURE_IN_DATASET],
+            [ErrorInfoCodes.EFS_FEATURE_IN_CATALOG, MessageCodes.EFS_FEATURE_IN_CATALOG],
+            [ErrorInfoCodes.EFS_ENTITY_IN_CATALOG, MessageCodes.EFS_ENTITY_IN_CATALOG],
+            [ErrorInfoCodes.DF_DUPLICATE_VALUES, MessageCodes.DF_DUPLICATE_VALUES],
+            [ErrorInfoCodes.DF_NULL_VALUES, MessageCodes.DF_NULL_VALUES],
+            [ErrorInfoCodes.EFS_FEATURE_ENTITY_MISMATCH, MessageCodes.EFS_FEATURE_ENTITY_MISMATCH],
+            [ErrorInfoCodes.FEATURES_ARCHIVED, MessageCodes.FEATURES_ARCHIVED],
+            [ErrorInfoCodes.EFS_DELETE_BEFORE_ARCHIVE, MessageCodes.EFS_DELETE_BEFORE_ARCHIVE],
+            [ErrorInfoCodes.EFS_OBJ_IN_FEATURE_PROCESS, MessageCodes.EFS_OBJ_IN_FEATURE_PROCESS],
+            [ErrorInfoCodes.EFS_OBJECT_NOT_EXIST, MessageCodes.EFS_OBJECT_NOT_EXIST],
+            [ErrorInfoCodes.EFS_OBJECT_IN_OTHER_DOMAIN, MessageCodes.EFS_OBJECT_IN_OTHER_DOMAIN],
+            [ErrorInfoCodes.EITHER_ANY_ARGUMENT, MessageCodes.EITHER_ANY_ARGUMENT],
+
     ]
 
     @staticmethod

teradataml/common/sqlbundle.py

@@ -70,8 +70,14 @@ class SQLBundle:
                 [SQLConstants.SQL_EXEC_STORED_PROCEDURE, "call {0}"],
                 [SQLConstants.SQL_SELECT_COLUMNNAMES_WITH_WHERE, "sel {0} from {1} where {2}"],
                 [SQLConstants.SQL_HELP_DATABASE, "HELP DATABASE {0}"],
-                [SQLConstants.SQL_HELP_DATALAKE, "HELP DATALAKE {0}"]
-
+                [SQLConstants.SQL_HELP_DATALAKE, "HELP DATALAKE {0}"],
+                [SQLConstants.SQL_INSERT_INTO_TABLE_VALUES_WITH_COLUMN_NAMES, "insert into {0} ({1}) values({2})"],
+                [SQLConstants.SQL_HELP_DATALAKE, "HELP DATALAKE {0}"],
+                [SQLConstants.SQL_TD_OTF_METADATA, "SELECT * FROM {0}(ON ({1})) D;"],
+                [SQLConstants.SQL_TD_OTF_SNAPSHOT, "SELECT * FROM {0} FOR SNAPSHOT AS OF {1};"],
+                [SQLConstants.SQL_LIST_TRIGGERS, "SELECT TriggerName FROM DBC.TRIGGERSV WHERE DatabaseName = '{0}' AND TriggerName LIKE '{1}'"],
+                [SQLConstants.SQL_SHOW_TABLE, "SHOW TABLE {0}"],
+                [SQLConstants.SQL_SHOW_VIEW, "SHOW VIEW {0}"]
         ]
         self._add_sql_version()
 
@@ -157,7 +163,7 @@ class SQLBundle:
         return sqlbundle._get_sql_query(SQLConstants.SQL_BASE_QUERY).format(name)
 
     @staticmethod
-    def _build_create_view(view_name, select_expression):
+    def _build_create_view(view_name, select_expression, lock_rows=False):
         """
         Builds a CREATE VIEW DDL statement.
         For Example,
@@ -166,6 +172,11 @@ class SQLBundle:
         PARAMETERS:
             view_name - Viewname to be created
             select_expression - A SQL from which a view is to be created. (SELECT query)
+            lock_rows - When set to True, teradataml DataFrame locks the corresponding row(s) 
+                        in underlying table(s) while accessing the data. Otherwise, 
+                        teradataml DataFrame access the data without locking the rows.
+                        Default is False.
+            
 
         RETURNS:
             A CREATE VIEW DDL statement
@@ -179,6 +190,8 @@ class SQLBundle:
         """
         sqlbundle = SQLBundle()
         query = sqlbundle._get_sql_query(SQLConstants.SQL_CREATE_VIEW)
+        if lock_rows:
+            select_expression = "LOCKING ROW FOR ACCESS {}".format(select_expression)
         return query.format(view_name, select_expression)
 
     @staticmethod
@@ -635,7 +648,7 @@ class SQLBundle:
         return ddlstmt.format(tablename, columns_datatypes)
     
     @staticmethod
-    def _build_insert_into_table_records(tablename, columns):
+    def _build_insert_into_table_records(tablename, columns, column_names=None):
         """
         Builds a prepared statement with parameter markers for a table.
         This is an internal function.
@@ -643,6 +656,7 @@ class SQLBundle:
         PARAMETERS:
             tablename - Table name to insert data.
             columns - The parameter markers for the prepared statement
+            column_names - The column names to be inserted.
 
         RETURNS:
             Returns a prepared statement.
@@ -652,11 +666,15 @@ class SQLBundle:
         
         EXAMPLES:
             preprdstmt = SQLBundle.SQL_INSERT_INTO_TABLE_VALUES('mytab', '?, ?')
-            
+            preprdstmt = SQLBundle.SQL_INSERT_INTO_TABLE_VALUES_WITH_COLUMN_NAMES('mytab', 'column1, column2',  '?, ?')
+
         """
         sqlbundle = SQLBundle()
-        query = sqlbundle._get_sql_query(SQLConstants.SQL_INSERT_INTO_TABLE_VALUES)
-        return query.format(tablename, columns)
+        sqlkey = (SQLConstants.SQL_INSERT_INTO_TABLE_VALUES_WITH_COLUMN_NAMES
+              if column_names else SQLConstants.SQL_INSERT_INTO_TABLE_VALUES)
+        query = sqlbundle._get_sql_query(sqlkey)
+        return (query.format(tablename, column_names, columns)
+            if column_names else query.format(tablename, columns))
 
     @staticmethod
     def _build_delete_all_rows_from_table(tablename):

teradataml/common/utils.py

@@ -13,11 +13,12 @@ by other classes which can be reused according to the need.
 Add all the common functions in this class like creating temporary table names, getting
 the datatypes etc.
 """
+import datetime
 import json
 import os
 import re
 import time
-import uuid
+import uuid, hashlib
 import warnings
 from functools import reduce
 from inspect import getsource
@@ -39,8 +40,9 @@ from teradatasqlalchemy.types import (BIGINT, BLOB, BYTE, BYTEINT, CHAR, CLOB,
 from teradataml import _version
 from teradataml.common import td_coltype_code_to_tdtype
 from teradataml.common.constants import (HTTPRequest, PTITableConstants,
-                                         PythonTypes, TeradataConstants,
-                                         TeradataReservedKeywords,
+                                         PythonTypes, SQLConstants,
+                                         TeradataConstants,
+                                         TeradataReservedKeywords, TeradataTableKindConstants,
                                          TeradataTypes)
 from teradataml.common.exceptions import TeradataMlException
 from teradataml.common.garbagecollector import GarbageCollector
@@ -280,26 +282,37 @@ class UtilFuncs():
         RAISES:
 
         EXAMPLES:
-            new_table_name = UtilFuncs._generate_temp_table_name(user='tdqg', prefix="from_pandas")
-            new_table_name = UtilFuncs._generate_temp_table_name(user='tdqg', prefix="from_pandas",
+            >>> new_table_name = UtilFuncs._generate_temp_table_name(user='tdqg', prefix="from_pandas")
+            >>> new_table_name = UtilFuncs._generate_temp_table_name(user='tdqg', prefix="from_pandas",
                                                                  table_type = TeradataConstants.TERADATA_VIEW)
-            new_table_name = UtilFuncs._generate_temp_table_name(user='tdqg', prefix="from_pandas",
+            >>> new_table_name = UtilFuncs._generate_temp_table_name(user='tdqg', prefix="from_pandas",
                                                                  table_type = TeradataConstants.TERADATA_TABLE)
+            # Example when use_short_object_name is set to True
+            >>> from teradataml.options.configure import configure
+            >>> configure.use_short_object_name = True
+            >>> new_table_name = UtilFuncs._generate_temp_table_name(user='tdqg', prefix="from_pandas")
 
         Output:
             tdml_temp_table__1517501990393350 (or)
             tdqg.tdml_temp_table__1517501990393350 (or)
             tdml_temp_table__from_pandas_1517501990393350 (or)
-            tdqg.tdml_temp_table__from_pandas_1517501990393350
+            tdqg.tdml_temp_table__from_pandas_1517501990393350 (or)
+            ml__1749637109887272
         """
         # Number of seconds since  Jan 1, 1970 00:00:00
         timestamp = time.time()
+        use_short_name = configure.use_short_object_name
         tabname = "ml_"
         random_string = "{}{}".format(floor(timestamp / 1000000),
                                       floor(timestamp % 1000000 * 1000000 +
                                             int(str(uuid.uuid4().fields[-1])[:10])))
-        if prefix is not None:
+        
+        # Append prefix only if use_short_object_name is False and prefix is provided.
+        if (not use_short_name) and (prefix is not None):
             tabname = "{}_{}".format(tabname, prefix)
+        # Append prefix "tdml" when use_short_object_name is True and random string is of length 15.
+        elif use_short_name and (len(random_string)==15):
+            tabname = "tdml"
 
         tabname = "{}_{}".format(tabname, random_string)
 
@@ -309,7 +322,8 @@ class UtilFuncs():
             tabname = "\"{}\".\"{}\"".format(_get_user(), tabname)
             return tabname
 
-        if configure.temp_object_type == TeradataConstants.TERADATA_VOLATILE_TABLE:
+        if (not use_short_name) and (configure.temp_object_type == TeradataConstants.
+                                     TERADATA_VOLATILE_TABLE):
             from teradataml.context.context import _get_user
             return "\"{}\".\"{}_{}\"".format(_get_user(), "vt", tabname)
 
@@ -653,13 +667,17 @@ class UtilFuncs():
 
     @staticmethod
     @collect_queryband(queryband='CreateView')
-    def _create_view(view_name, query):
+    def _create_view(view_name, query, lock_rows=False):
         """
         Create a view from the given query.
 
         PARAMETERS:
             view_name - View name
             query - SQL query
+            lock_rows - When set to True, teradataml DataFrame locks the corresponding row(s)
+                        in underlying table(s) while accessing the data. Otherwise,
+                        teradataml DataFrame access the data without locking the rows.
+                        Default is False.
 
         RAISES
 
@@ -669,7 +687,8 @@ class UtilFuncs():
         EXAMPLES:
             UtilFuncs._create_view(view_name, "select * from table_name")
         """
-        crt_view = SQLBundle._build_create_view(view_name, query)
+
+        crt_view = SQLBundle._build_create_view(view_name, query, lock_rows)
         try:
             UtilFuncs._execute_ddl_statement(crt_view)
             return True
@@ -928,9 +947,13 @@ class UtilFuncs():
         EXAMPLES:
             UtilFuncs._get_help_vtablenames()
         """
-        vtables = UtilFuncs._execute_query(SQLBundle._build_help_volatile_table())
-        if vtables:
-            return list(map(str.strip, filter(None, vtables[0])))
+        vtables = UtilFuncs._execute_query(SQLBundle._build_help_volatile_table(), fetchWarnings=True)
+        if vtables and vtables[0] and vtables[1]:
+            rows, columns = vtables
+            key = TeradataTableKindConstants.VOLATILE_TABLE_NAME.value
+            # Find the index of the column matching the table name
+            col_idx = columns.index(key)
+            return [row[col_idx].strip() for row in rows if row[col_idx]]
         return []
 
     @staticmethod
@@ -1310,7 +1333,8 @@ class UtilFuncs():
 
         return False
 
-    def _is_ascii(col_lst):
+    @staticmethod
+    def _is_non_ascii(col_lst):
         """
         Description:
             Check if the specified string in col_lst has non-ASCII characters in it.
@@ -1569,7 +1593,7 @@ class UtilFuncs():
             return UtilFuncs._teradata_quote_arg(args_list, quote, False)
 
     @staticmethod
-    def _get_metaexpr_using_columns(nodeid, column_info, with_engine=False, is_persist=False):
+    def _get_metaexpr_using_columns(nodeid, column_info, with_engine=False, is_persist=False, **kw):
         """
         This internal function takes in input node ID and column information in zipped lists format
         to return metaexpr with or without engine.
@@ -1610,7 +1634,7 @@ class UtilFuncs():
         ouptut_table = Table(db_table_name, meta,
                              *(Column(col_name, col_type) for col_name, col_type in column_info),
                              schema=db_schema)
-        return _MetaExpression(ouptut_table, is_persist=is_persist)
+        return _MetaExpression(ouptut_table, is_persist=is_persist, **kw)
 
     @staticmethod
     def _get_metaexpr_using_parent_metaexpr(nodeid, metaexpr):
@@ -1648,7 +1672,8 @@ class UtilFuncs():
             col_names.append(meta_cols[col_name].name)
             col_types.append(meta_cols[col_name].type)
 
-        return UtilFuncs._get_metaexpr_using_columns(nodeid, zip(col_names, col_types))
+        return UtilFuncs._get_metaexpr_using_columns(nodeid, zip(col_names, col_types),
+                                                     datalake=metaexpr.datalake)
 
     @staticmethod
     def _create_table_using_columns(table_name, columns_datatypes, pti_clause=None, storage=None):
@@ -2670,7 +2695,10 @@ class UtilFuncs():
         user_function_code = ""
         for func in user_functions:
             # Get the source code of the user function.
-            func = getsource(func)
+            # Note that, checking for lambda function is required for teradatamlspk UDFs
+            # If the function is a lambda function, get the source code from __source__.
+            func = getsource(func) if func.__code__.co_name != "<lambda>" else func.__source__
+
             # If the function have any extra space in the beginning remove it.
             func = func.lstrip()
             # Function can have decorator,e.g. udf as decorator, remove it.
@@ -2753,7 +2781,8 @@ class UtilFuncs():
                                             MessageCodes.PYTHON_VERSION_MISMATCH_OAF)
         else:
             from teradataml.context import context as tdmlctx
-            from teradataml.dbutils.dbutils import (db_python_version_diff, set_session_param)
+            from teradataml.dbutils.dbutils import (db_python_version_diff,
+                                                    set_session_param)
             set_session_param("searchuifdbpath",
                               UtilFuncs._get_dialect_quoted_name(tdmlctx._get_current_databasename()))
             if len(db_python_version_diff()) > 0:
@@ -2798,7 +2827,8 @@ class UtilFuncs():
         """
 
         # Check if OSML required packages are verified or not.
-        from teradataml.opensource._constants import _packages_verified_in_vantage
+        from teradataml.opensource._constants import \
+            _packages_verified_in_vantage
         _is_packages_verfied_in_vantage = _packages_verified_in_vantage.get(
             func, None)
         if _is_packages_verfied_in_vantage:
@@ -2855,7 +2885,8 @@ class UtilFuncs():
 
         else:
             # Check if the versions of Python packages are consistent between Vantage and local.
-            from teradataml.dbutils.dbutils import _db_python_package_version_diff
+            from teradataml.dbutils.dbutils import \
+                _db_python_package_version_diff
             all_package_versions = _db_python_package_version_diff(packages, only_diff=False)
             package_difference = \
                 all_package_versions[all_package_versions.vantage != all_package_versions.local]
@@ -2922,6 +2953,163 @@ class UtilFuncs():
         tdp = preparer(td_dialect)
         return tdp.quote(object_name)
 
+    @staticmethod
+    def _get_hash_value(identifier):
+        """
+        DESCRIPTION:
+            Function to get the hash value of the identifier.
+
+        PARAMETERS:
+            identifier
+                Required Argument.
+                Specifies the identifier to be hashed.
+                Type: str
+
+        RAISES:
+            None
+
+        RETURNS:
+            Hash value of the identifier.
+
+        EXAMPLES:
+            UtilFuncs._get_hash_value(identifier = "tdml.alice")
+
+        OUTPUT:
+            a6c64c2c_58e9_5060_b811_00839ea493ed
+        """
+        # Generate a hash value using SHA-256
+        hash_object = hashlib.sha256(identifier.encode())
+        hash_hex = hash_object.hexdigest()
+
+        # Format the hash value to match the desired format
+        formatted_hash = f"{hash_hex[:8]}_{hash_hex[8:12]}_{hash_hex[12:16]}_{hash_hex[16:20]}_{hash_hex[20:32]}"
+
+        return formatted_hash
+
+    @staticmethod
+    def _get_http_status_phrases_description():
+        """
+        DESCRIPTION:
+            Function to get phrases and description for all HTTP status codes.
+
+        PARAMETERS:
+            None
+
+        RETURNS:
+            dict
+
+        EXAMPLES:
+            >>> UtilFuncs._get_http_status_phrases_description()
+        """
+        from http import HTTPStatus
+        return {status.value: {"phrase": status.phrase, "description": status.description} \
+                for status in HTTPStatus}
+
+    @staticmethod
+    def _get_time_formatted_string(period):
+        """
+        DESCRIPTION:
+            Converts a string representing Period to the formatted TIMESTAMP/DATE string for snapshot queries.
+
+        PARAMETERS:
+            period:
+                Required Argument.
+                Specifies the period string to be converted.
+                Types: str
+
+        RETURNS:
+            The formatted TIMESTAMP/DATE string.
+
+        RAISES:
+            ValueError.
+
+        EXAMPLES:
+        >>> UtilFuncs._get_time_formatted_string('2025-06-01 12:00:00.123')
+        """
+        # Try to parse as datetime string
+        try:
+            for fmt in ["%Y-%m-%d %H:%M:%S.%f", "%Y-%m-%d %H:%M:%S", "%Y-%m-%d"]:
+                try:
+                    dt = datetime.datetime.strptime(period, fmt)
+                    # If input had microseconds, preserve them
+                    if "%f" in fmt and "." in period:
+                        # Remove trailing zeros and dot if needed
+                        result = "TIMESTAMP'{}'".format(dt.strftime("%Y-%m-%d %H:%M:%S.%f").rstrip("0").rstrip("."))
+                    elif "%S" in fmt:
+                        result = "TIMESTAMP'{}'".format(dt.strftime("%Y-%m-%d %H:%M:%S"))
+                    else:
+                        result = "DATE'{}'".format(dt.strftime("%Y-%m-%d"))
+                    return result
+                except ValueError:
+                    continue
+            raise ValueError(f"Unrecognized period format: {period}")
+        except Exception as e:
+            raise ValueError(f"Could not convert period: {period}") from e
+
+    @staticmethod
+    def extract_table_names_from_query(query):
+        """
+        Extracts all table/view names from FROM, JOIN, and ON-AS clauses in a SQL query.
+        Handles nested queries and captures subqueries in ON (...), and ON <table> AS <alias>.
+        """
+        # Regex for FROM, JOIN, and ON ... AS ... clauses
+        # This is a simplification; for production, use a SQL parser.
+        table_names = set()
+        # FROM ... (possibly with nested SELECT)
+        for match in re.finditer(r'from\s+([^\s\(\)]+)', query, re.IGNORECASE):
+            table_names.add(match.group(1).strip())
+        # JOIN ... (possibly with nested SELECT)
+        for match in re.finditer(r'join\s+([^\s\(\)]+)', query, re.IGNORECASE):
+            table_names.add(match.group(1).strip())
+        # ON ( ... ) AS ... Nested Query in ON Clause.
+        for match in re.finditer(r'ON\s+\(([^)]+)\)\s+AS\s+["\']?\w+["\']?', query, re.IGNORECASE):
+            table_names.update(UtilFuncs.extract_table_names_from_query(match.group(1)))
+        # ON <table> AS <alias> (no parentheses)
+        for match in re.finditer(r'ON\s+(["\']?\w+["\']?(?:\.["\']?\w+["\']?)*)\s+AS\s+["\']?\w+["\']?', query, re.IGNORECASE):
+            table_names.add(match.group(1).strip())
+        return list(table_names)
+
+    @staticmethod
+    def _get_normalize_and_deduplicate_columns(columns):
+        """
+        DESCRIPTION:
+            Function that normalizes and deduplicates a list of column names.
+            This function processes the "columns", which can be a list of column names
+            as strings or ColumnExpression, or a single column name/ColumnExpression.
+            It extracts the column names, removes duplicates while preserving order, 
+            and returns the resulting list of unique column names.
+
+        PARAMETERS:
+            columns:
+                Required Argument.
+                Specifies the column.
+                Types: str, ColumnExpression, list of str or ColumnExpression
+
+        RAISES:
+            None
+
+        RETURNS:
+            list
+
+        EXAMPLES:
+            >>> load_examples_data('dataframe', 'sales')
+            >>> df = DataFrame('sales')
+            >>> columns = [df.Jan, 'Jan', 'Feb', df.Feb, 'Mar']
+            >>> UtilFuncs._get_normalize_and_deduplicate_columns(columns)
+            ['Jan', 'Feb', 'Mar']
+
+        """
+        columns_list = []
+        seen = set()
+
+        for column in (columns if isinstance(columns, list) else [columns]):
+            name = column if isinstance(column, str) else column.name
+            if name not in seen:
+                seen.add(name)
+                columns_list.append(name)
+
+        return columns_list
 
+# Keeping at the end to avoid circular dependency
 from teradataml.common.aed_utils import AedUtils
 from teradataml.dbutils.filemgr import remove_file

teradataml/context/aed_context.py

@@ -115,20 +115,26 @@ class AEDContext:
         """
         # Define extension to load AED library depending on the OS platform.
         os_type = platform.system()
+        arch_suffix = ""
         if (os_type == "Windows"):
-            self.extension = "dll"
-            self.lib_name = "aed"
+            extension = "dll"
+            lib_name = "aed"
         elif (os_type == "Darwin"):
-            self.extension = "dylib"
-            self.lib_name = "libaed"
+            extension = "dylib"
+            lib_name = "libaed"
         else:
-            self.extension = "so"
-            self.lib_name = "libaed"
+            # Linux case
+            extension = "so"
+            lib_name = "libaed"
+            # Only apply architecture suffix for aarch64/ARM64
+            machine = platform.uname().machine
+            if machine == "aarch64":
+                arch_suffix = "_" + machine
+
         # TODO:: Use logger when it is available.
-        libPathName = os.path.join(os.sep,
-                                   os.path.dirname(os.path.abspath(__file__)),
-                                   "../lib", #"Debug",
-                                     "{0}_0_1.{1}".format(self.lib_name, self.extension))
+        from teradataml import _TDML_DIRECTORY
+        libPathName = os.path.join(os.sep, _TDML_DIRECTORY, "lib", 
+                                   "{0}_0_1{1}.{2}".format(lib_name, arch_suffix, extension))
         try:
             elecommon = cdll.LoadLibrary(libPathName)
         except Exception as err: