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

teradataml/common/constants.py

@@ -18,6 +18,14 @@ from teradataml.options.configure import configure
 from teradatasqlalchemy.types import (INTEGER, SMALLINT, BIGINT, BYTEINT, DECIMAL, FLOAT, NUMBER, VARCHAR)
 from teradatasqlalchemy.types import (DATE, TIME, TIMESTAMP)
 from teradatasqlalchemy.types import (BYTE, VARBYTE, BLOB)
+from teradatasqlalchemy import (CHAR, CLOB)
+from teradatasqlalchemy import (PERIOD_DATE, PERIOD_TIME, PERIOD_TIMESTAMP)
+from teradatasqlalchemy import (INTERVAL_YEAR, INTERVAL_YEAR_TO_MONTH, INTERVAL_MONTH,
+                                INTERVAL_DAY,INTERVAL_DAY_TO_HOUR, INTERVAL_DAY_TO_MINUTE,
+                                INTERVAL_DAY_TO_SECOND, INTERVAL_HOUR,
+                                INTERVAL_HOUR_TO_MINUTE, INTERVAL_HOUR_TO_SECOND,
+                                INTERVAL_MINUTE, INTERVAL_MINUTE_TO_SECOND,
+                                INTERVAL_SECOND)
 from teradatasqlalchemy import (GEOMETRY, MBR, MBB)
 
 
@@ -53,6 +61,7 @@ class SQLConstants(Enum):
     SQL_DELETE_ALL_ROWS = 29
     SQL_DELETE_SPECIFIC_ROW = 30
     SQL_EXEC_STORED_PROCEDURE = 31
+    SQL_SELECT_COLUMNNAMES_WITH_WHERE = 32
     CONSTRAINT = ["check_constraint", "primary_key_constraint",
                   "foreign_key_constraint", "unique_key_constraint"]
 
@@ -123,6 +132,14 @@ class TeradataTypes(Enum):
     TD_DATE_TYPES = [DATE, sqlalchemy.sql.sqltypes.Date]
     TD_DATE_CODES = ["DA"]
     TD_NULL_TYPE = "NULLTYPE"
+    TD_ALL_TYPES = (BYTEINT, SMALLINT, INTEGER, BIGINT, DECIMAL, FLOAT, NUMBER,
+                    TIMESTAMP, DATE, TIME, CHAR, VARCHAR, CLOB, BYTE, VARBYTE,
+                    BLOB, PERIOD_DATE, PERIOD_TIME, PERIOD_TIMESTAMP,
+                    INTERVAL_YEAR, INTERVAL_YEAR_TO_MONTH, INTERVAL_MONTH,
+                    INTERVAL_DAY, INTERVAL_DAY_TO_HOUR, INTERVAL_DAY_TO_MINUTE,
+                    INTERVAL_DAY_TO_SECOND, INTERVAL_HOUR,
+                    INTERVAL_HOUR_TO_MINUTE, INTERVAL_HOUR_TO_SECOND,
+                    INTERVAL_MINUTE, INTERVAL_MINUTE_TO_SECOND, INTERVAL_SECOND)
 
 
 class TeradataTableKindConstants(Enum):
@@ -425,6 +442,10 @@ class TableOperatorConstants(Enum):
     MAP_TEMPLATE = "dataframe_map.template"
     # Template of the intermediate script that will be generated.
     APPLY_TEMPLATE = "dataframe_apply.template"
+    # Template of the intermediate script that will be generated for UDF.
+    UDF_TEMPLATE = "dataframe_udf.template"
+    # Template of the intermediate script that will be generated for register.
+    REGISTER_TEMPLATE = "dataframe_register.template"
     # In-DB execution mode.
     INDB_EXEC = "IN-DB"
     # Local execution mode.
@@ -439,6 +460,10 @@ class TableOperatorConstants(Enum):
     MAP_PARTITION_OP = "map_partition"
     # apply operation.
     APPLY_OP = "apply"
+    # udf operation.
+    UDF_OP = "udf"
+    # register operation.
+    REGISTER_OP = "register"
     # Template of the script_executor that will be used to generate the temporary script_executor file.
     SCRIPT_TEMPLATE = "script_executor.template"
     # Log Type.
@@ -476,6 +501,9 @@ class TableOperatorConstants(Enum):
                                                     "delimiter(' ') " \
                                                     "returns('package VARCHAR({2}), " \
                                                     "version VARCHAR({2})'))"
+    
+    SCRIPT_LIST_FILES_QUERY = "SELECT DISTINCT * FROM SCRIPT (SCRIPT_COMMAND " \
+                       "('ls ./{}') RETURNS ('Files VARCHAR({})'))"
 
 class ValibConstants(Enum):
     # A dictionary that maps teradataml name of the exposed VALIB function name
@@ -1369,6 +1397,7 @@ class TeradataAnalyticFunctionTypes(Enum):
     UAF = "UAF"
     TABLEOPERATOR = "TABLE_OPERATOR"
     BYOM = "BYOM"
+    STORED_PROCEDURE = "STORED_PROCEDURE"
 
 
 class TeradataAnalyticFunctionInfo(Enum):
@@ -1379,6 +1408,8 @@ class TeradataAnalyticFunctionInfo(Enum):
     TABLE_OPERATOR = {"func_type": "tableoperator", "lowest_version": "17.00 ",
                       "display_function_type_name" :"TABLE OPERATOR"}
     BYOM = {"func_type": "byom", "lowest_version": None, "display_function_type_name": "BYOM"}
+    STORED_PROCEDURE = {"func_type": "storedprocedure", "lowest_version": "17.20", "display_function_type_name": "UAF",
+           "metadata_class" : "_AnlyFuncMetadataUAF"}
 
 class TeradataUAFSpecificArgs(Enum):
     INPUT_MODE = "input_mode"
@@ -1436,3 +1467,44 @@ class CloudProvider(Enum):
     # and '2018-03-28', using the latest one.
     X_MS_VERSION = "2019-12-12"
     X_MS_BLOB_TYPE = "BlockBlob"
+
+class SessionParamsSQL:
+    # Holds the SQL Statements for Session params.
+    TIMEZONE = "SET TIME ZONE {}"
+    ACCOUNT = "SET SESSION ACCOUNT = '{}' FOR {}"
+    CALENDAR = "SET SESSION CALENDAR = {}"
+    CHARACTER_SET_UNICODE = "SET SESSION CHARACTER SET UNICODE PASS THROUGH {}"
+    COLLATION = "SET SESSION COLLATION {}"
+    CONSTRAINT = "SET SESSION CONSTRAINT = {}"
+    DATABASE = "SET SESSION DATABASE {}"
+    DATEFORM = "SET SESSION DATEFORM = {}"
+    DEBUG_FUNCTION = "SET SESSION DEBUG FUNCTION {} {}"
+    DOT_NOTATION = "SET SESSION DOT NOTATION {} ON ERROR"
+    ISOLATED_LOADING = "SET SESSION FOR {} ISOLATED LOADING"
+    FUNCTION_TRACE = "SET SESSION FUNCTION TRACE USING {} FOR TABLE {}"
+    JSON_IGNORE_ERRORS = "SET SESSION JSON IGNORE ERRORS {}"
+    SEARCHUIFDBPATH = "SET SESSION SEARCHUIFDBPATH = {}"
+    TRANSACTION_ISOLATION_LEVEL = "SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL {}"
+    QUERY_BAND = "SET QUERY_BAND = {} FOR {}"
+    UDFSEARCHPATH = "SET SESSION UDFSEARCHPATH = {} FOR FUNCTION = {}"
+
+class SessionParamsPythonNames:
+    # Holds the SQL Statements for Session params.
+    TIMEZONE = "Session Time Zone"
+    ACCOUNT = "Account Name"
+    CALENDAR = "Calendar"
+    COLLATION = "Collation"
+    DATABASE = "Current DataBase"
+    DATEFORM = 'Current DateForm'
+
+
+class Action(Enum):
+    # Holds variable names for the type of grant to be provided.
+    GRANT = "GRANT"
+    REVOKE = "REVOKE"
+
+class Permission(Enum):
+    # Holds variable names for the type of permission to be provided.
+    READ = "READ"
+    WRITE = "WRITE"
+

teradataml/common/deprecations.py

@@ -87,13 +87,19 @@ def argument_deprecation(tdml_version, deprecated_arguments, behaviour=False, al
 
     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)
+            # Check if deprecated arguments is a list, if not convert it to a list
+            deprecated_args_list = deprecated_arguments if isinstance(deprecated_arguments, list) \
+                else [deprecated_arguments]
+            # Check list of deprecated arguments are used in the function call
+            deprecated_arguments_used = [arg for arg in deprecated_args_list if arg in kwargs]
+            if deprecated_arguments_used:
+                msg = "\nThe argument(s) \"{}\" will be deprecated in {}."
+                if behaviour:
+                    msg = "\nBehaviour of the argument(s) \"{}\" will change in {}."
+                msg = msg.format(deprecated_arguments_used, 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)

teradataml/common/garbagecollector.py

@@ -22,6 +22,7 @@ from teradataml.common.messages import Messages
 from teradataml.common.messagecodes import MessageCodes
 from teradataml.common.constants import TeradataConstants
 from teradataml.options.configure import configure
+from teradataml.utils.internal_buffer import _InternalBuffer
 from teradatasql import OperationalError
 import psutil
 import getpass
@@ -36,15 +37,22 @@ class GarbageCollector():
     garbage collection, so that they can be dropped when connection is disconnected/lost.
     Writes to a output file where the database name & table/view/script names are persisted.
     """
-    __garbage_persistent_file_name = getpass.getuser() + "_garbagecollect.info"
+    # Adding old garbage collector file name to support backward compatibility.
+    __old_garbage_persistent_file_name = getpass.getuser() + "_garbagecollect.info"
     __garbagecollector_folder_name = '.teradataml'
     __contentseperator = ","
+    __filenameseperator = "_"
     __version = "ver1.0"
     __gc_tables = []
     __gc_views = []
     __gc_scripts = []
     __gc_container = []
     __gc_apply = []
+    # Function to get the garbage collector file name specific to host and process.
+    _get_gc_file_name = lambda: "{}_{}_{}_garbagecollect.info".format(
+        getpass.getuser(),
+        tdmlctx.context._get_host_ip(),
+        str(os.getpid()))
 
     @staticmethod
     def _get_temp_dir_name():
@@ -93,7 +101,7 @@ class GarbageCollector():
         """
         tempdir = GarbageCollector._get_temp_dir_name()
         os.makedirs(tempdir, exist_ok=True)
-        tempfile = os.path.join(os.path.sep, tempdir, GarbageCollector.__garbage_persistent_file_name)
+        tempfile = os.path.join(os.path.sep, tempdir, GarbageCollector._get_gc_file_name())
         return tempfile
 
     @staticmethod
@@ -205,29 +213,31 @@ class GarbageCollector():
         EXAMPLES:
             GarbageCollector._add_to_garbagecollector(object_name = "temp"."temp_table1")
         """
-        if object_name and object_type:
-            try:
-                tempfilename = GarbageCollector.__make_temp_file_name()
-                writecontent = str(GarbageCollector.__version) + "," + str(os.getpid())
-                writecontent += "," + str(object_type.value)
-                writecontent += "," + object_name + "\n"
-                with open(tempfilename, 'a+') as fgc:
-                    fgc.write(writecontent)
-                if configure._validate_gc:
-                    GarbageCollector.__validate_gc_add_object(object_name, object_type)
-            except TeradataMlException:
-                raise
-            except Exception as err:
-                logger.error(Messages.get_message(MessageCodes.TDMLDF_CREATE_GARBAGE_COLLECTOR) + str(err))
-                raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_CREATE_GARBAGE_COLLECTOR),
-                                          MessageCodes.TDMLDF_CREATE_GARBAGE_COLLECTOR) from err
-            finally:
-                if fgc is not None:
-                    fgc.close()
+        # Use global lock while writing to the garbage collector file.
+        with _InternalBuffer.get("global_lock"):
+            if object_name and object_type:
+                try:
+                    tempfilename = GarbageCollector.__make_temp_file_name()
+                    writecontent = str(GarbageCollector.__version) + "," + str(os.getpid())
+                    writecontent += "," + str(object_type.value)
+                    writecontent += "," + object_name + "\n"
+                    with open(tempfilename, 'a+') as fgc:
+                        fgc.write(writecontent)
+                    if configure._validate_gc:
+                        GarbageCollector.__validate_gc_add_object(object_name, object_type)
+                except TeradataMlException:
+                    raise
+                except Exception as err:
+                    logger.error(Messages.get_message(MessageCodes.TDMLDF_CREATE_GARBAGE_COLLECTOR) + str(err))
+                    raise TeradataMlException(Messages.get_message(MessageCodes.TDMLDF_CREATE_GARBAGE_COLLECTOR),
+                                                MessageCodes.TDMLDF_CREATE_GARBAGE_COLLECTOR) from err
+                finally:
+                    if fgc is not None:
+                        fgc.close()
         return True
 
     @staticmethod
-    def __deleterow(content_row):
+    def __deleterow(content_row, file_name):
         """
         DESCRIPTION:
             Deletes an entry from persisted file.
@@ -237,6 +247,11 @@ class GarbageCollector():
                 Required Argument.
                 Specifies the text of row to delete from the persisted file.
                 Types: str
+            
+            file_name:
+                Required Argument.
+                Specifies the name of the file to delete the row.
+                Types: str
 
         RETURNS:
             None.
@@ -248,10 +263,9 @@ class GarbageCollector():
             GarbageCollector._deleterow(content_row = 'ver1.0,72136,3,"alice"."temp_table_gbview1"')
         """
         try:
-            tempfilename = GarbageCollector.__make_temp_file_name()
-            if not os.path.isfile(tempfilename):
+            if not os.path.isfile(file_name):
                 return True
-            with open(tempfilename, 'r+') as fgc:
+            with open(file_name, 'r+') as fgc:
                 output = fgc.readlines()
                 fgc.seek(0)
                 for dbtablename in output:
@@ -491,104 +505,122 @@ class GarbageCollector():
         """
         try:
             td_connection = tdmlctx.context.get_connection()
-            tempfilename = GarbageCollector.__make_temp_file_name()
-            if not os.path.isfile(tempfilename):
+            # Get the temp directory where garbage collector file is persisted.
+            tempdir = GarbageCollector._get_temp_dir_name()
+            # Garbage collect file that is created by the current host and current process.
+            # Also check if file is not of current process and associated process is
+            # currently running in the system or not.
+            # Walk through the temp directory and filter garbage collector files.
+            tempfiles = []
+            for root, _, files in os.walk(tempdir):
+                for file in files:
+                    if file.endswith('_garbagecollect.info'):
+                        try:
+                            filepath = os.path.join(root, file)
+                            fileparts = file.split(GarbageCollector.__filenameseperator)
+                            hostname = fileparts[1]
+                            filepid = int(fileparts[2])
+                            # Check for both host ip and hostname in case user passed hostname for creating connection.
+                            if hostname == tdmlctx.context._get_host_ip() or hostname == tdmlctx.context._get_host():
+                                if filepid == os.getpid() or not psutil.pid_exists(filepid):
+                                    tempfiles.append(filepath)
+                        except (IndexError, ValueError):
+                            # Handle the case where the filename format is not as expected
+                            # check if old garbage collector file is present.
+                            if file == GarbageCollector.__old_garbage_persistent_file_name:
+                                tempfiles.append(filepath)
+
+            # Process each garbage collector file.
+            if len(tempfiles) == 0:
                 return True
-            with open(tempfilename, 'r+') as fgc:
-                content = fgc.readlines()
-
-            for contentrecord in content:
-                contentrecord = contentrecord.strip()
-
-                if (td_connection is not None) and (len(contentrecord) > 0):
-                    try:
-                        recordparts = contentrecord.split(GarbageCollector.__contentseperator)
-                        version = recordparts[0]
-                        contentpid = int(recordparts[1].strip())
-                        # Check and garbage collect even currrent running process at exit.
-                        # Check if contentpid is not of current process as well as any
-                        # currently running process in the system
-                        proceed_to_cleanup = False
-                        if contentpid != int(os.getpid()):
-                            if not psutil.pid_exists(contentpid):
-                                proceed_to_cleanup = True
-                        else:
-                            proceed_to_cleanup = True
-                        if proceed_to_cleanup == True:
-                            object_type = int(recordparts[2].strip())
-                            database_object = recordparts[3].strip()
-
-                            # Create the TeradataConstant to use with __delete_object_from_gc_list().
-                            object_type_enum = TeradataConstants(object_type)
-
+            else:
+                for tempfilename in tempfiles:
+                    if not os.path.isfile(tempfilename):
+                        return True
+                    with open(tempfilename, 'r+') as fgc:
+                        content = fgc.readlines()
+
+                    for contentrecord in content:
+                        contentrecord = contentrecord.strip()
+                        if (td_connection is not None) and (len(contentrecord) > 0):
                             try:
-                                # Drop the table/view/script/container based on database object type retrieved from the collector file.
-                                # # Drop table.
-                                if TeradataConstants.TERADATA_TABLE.value == object_type:
-                                    tdmlutil.utils.UtilFuncs._drop_table(database_object,
-                                                                         check_table_exist=False)
-
-                                # # Drop view.
-                                elif TeradataConstants.TERADATA_VIEW.value == object_type:
-                                    tdmlutil.utils.UtilFuncs._drop_view(database_object,
-                                                                        check_view_exist=False)
-
-                                elif object_type in [TeradataConstants.TERADATA_LOCAL_SCRIPT.value,
-                                                    TeradataConstants.TERADATA_TEXT_FILE.value]:
-                                    GarbageCollector.__delete_gc_tempdir_local_file(database_object, object_type)
-
-                                # # Drop Apply script.
-                                elif TeradataConstants.TERADATA_APPLY.value == object_type:
-                                    tdmlutil.utils.UtilFuncs._delete_script(database_object,
-                                                                            file_type=object_type_enum)
-                                    # Delete the script locally
-                                    GarbageCollector.__delete_gc_tempdir_local_file(database_object, object_type)
-
-                                # # Drop STO script.
-                                else:
-                                    tdmlutil.utils.UtilFuncs._delete_script(database_object,
-                                                                            file_type=object_type_enum,
-                                                                            check_script_exist=False)
-                                    # Delete the script locally
-                                    GarbageCollector.__delete_gc_tempdir_local_file(database_object, object_type)
-
-                                # Finally, delete the entry from gc lists if required.
-                                GarbageCollector.__delete_object_from_gc_list(database_object,
-                                                                              object_type_enum)
-
-                                # Remove the entry for a table/view from GC, after it has been dropped.
-                                GarbageCollector.__deleterow(contentrecord)
-                            except OperationalError as operr:
-                                # Remove the entry for a table/view/script even after drop has failed,
-                                # if that object does not exist.
-                                # Also added additional check for error when the database containing
-                                # the object doesn't exist anymore.
-                                if "[Teradata Database] [Error 3802] Database" in str(operr) or \
-                                        "[Teradata Database] [Error 3807] Object" in str(operr) or \
-                                        "[Teradata Database] [Error 9852] The file" in str(operr):
-                                    GarbageCollector.__deleterow(contentrecord)
-                                    # Delete entry from gc lists of required.
-                                    GarbageCollector.__delete_object_from_gc_list(database_object,
-                                                                                  object_type_enum)
-                            except (TeradataMlException, RuntimeError) as err:
-                                if "Failed to execute get_env" in str(err) or \
-                                    "Failed to execute remove_file" in str(err):
-                                    # For removing files in OpenAF environment.
-                                    GarbageCollector.__deleterow(contentrecord)
-                                    # Delete entry from gc lists of required.
+                                recordparts = contentrecord.split(GarbageCollector.__contentseperator)
+                                object_type = int(recordparts[2].strip())
+                                database_object = recordparts[3].strip()
+
+                                # Create the TeradataConstant to use with __delete_object_from_gc_list().
+                                object_type_enum = TeradataConstants(object_type)
+
+                                try:
+                                    # Drop the table/view/script/container based on database object type retrieved from the collector file.
+                                    # # Drop table.
+                                    if TeradataConstants.TERADATA_TABLE.value == object_type:
+                                        tdmlutil.utils.UtilFuncs._drop_table(database_object,
+                                                                            check_table_exist=False)
+
+                                    # # Drop view.
+                                    elif TeradataConstants.TERADATA_VIEW.value == object_type:
+                                        tdmlutil.utils.UtilFuncs._drop_view(database_object,
+                                                                            check_view_exist=False)
+
+                                    elif object_type in [TeradataConstants.TERADATA_LOCAL_SCRIPT.value,
+                                                        TeradataConstants.TERADATA_TEXT_FILE.value]:
+                                        GarbageCollector.__delete_gc_tempdir_local_file(database_object, object_type)
+
+                                    # # Drop Apply script.
+                                    elif TeradataConstants.TERADATA_APPLY.value == object_type:
+                                        tdmlutil.utils.UtilFuncs._delete_script(database_object,
+                                                                                file_type=object_type_enum)
+                                        # Delete the script locally
+                                        GarbageCollector.__delete_gc_tempdir_local_file(database_object, object_type)
+
+                                    # # Drop STO script.
+                                    else:
+                                        tdmlutil.utils.UtilFuncs._delete_script(database_object,
+                                                                                file_type=object_type_enum,
+                                                                                check_script_exist=False)
+                                        # Delete the script locally
+                                        GarbageCollector.__delete_gc_tempdir_local_file(database_object, object_type)
+
+                                    # Remove the entry for a table/view from GC, after it has been dropped.
+                                    GarbageCollector.__deleterow(contentrecord, tempfilename)
+                                    
+                                    # Finally, delete the entry from gc lists if required.
                                     GarbageCollector.__delete_object_from_gc_list(database_object,
-                                                                                  object_type_enum)
-                            except FileNotFoundError:
-                                # This will occur only when the item being deleted is a file,
-                                # and it's local copy is not found.
-                                GarbageCollector.__deleterow(contentrecord)
-                                if object_type == TeradataConstants.TERADATA_APPLY:
-                                    GarbageCollector.__gc_apply.remove(database_object)
-                                elif object_type == TeradataConstants.TERADATA_SCRIPT:
-                                    GarbageCollector.__gc_scripts.remove(database_object)
-                    except Exception as err:
-                        pass
-                        # logger.error(Messages.get_message(MessageCodes.TDMLDF_DELETE_GARBAGE_COLLECTOR) + str(err))
+                                                                                object_type_enum)
+                                except OperationalError as operr:
+                                    # Remove the entry for a table/view/script even after drop has failed,
+                                    # if that object does not exist.
+                                    # Also added additional check for error when the database containing
+                                    # the object doesn't exist anymore.
+                                    if "[Teradata Database] [Error 3802] Database" in str(operr) or \
+                                            "[Teradata Database] [Error 3807] Object" in str(operr) or \
+                                            "[Teradata Database] [Error 9852] The file" in str(operr):
+                                        GarbageCollector.__deleterow(contentrecord, tempfilename)
+                                        # Delete entry from gc lists of required.
+                                        GarbageCollector.__delete_object_from_gc_list(database_object,
+                                                                                    object_type_enum)
+                                except (TeradataMlException, RuntimeError) as err:
+                                    if "Failed to execute get_env" in str(err) or \
+                                        "Failed to execute remove_file" in str(err):
+                                        # For removing files in OpenAF environment.
+                                        GarbageCollector.__deleterow(contentrecord, tempfilename)
+                                        # Delete entry from gc lists of required.
+                                        GarbageCollector.__delete_object_from_gc_list(database_object,
+                                                                                    object_type_enum)
+                                except FileNotFoundError:
+                                    # This will occur only when the item being deleted is a file,
+                                    # and it's local copy is not found.
+                                    GarbageCollector.__deleterow(contentrecord, tempfilename)
+                                    if object_type == TeradataConstants.TERADATA_APPLY:
+                                        GarbageCollector.__gc_apply.remove(database_object)
+                                    elif object_type == TeradataConstants.TERADATA_SCRIPT:
+                                        GarbageCollector.__gc_scripts.remove(database_object)
+                            except Exception as err:
+                                pass
+                    # delete empty file itself after deleting the entry from the file
+                    if os.path.getsize(tempfilename) == 0:
+                        GarbageCollector._delete_local_file(tempfilename)
         except Exception as e:
             logger.error(Messages.get_message(MessageCodes.TDMLDF_DELETE_GARBAGE_COLLECTOR) + str(e))
         finally:

teradataml/common/messagecodes.py

@@ -86,6 +86,7 @@ class ErrorInfoCodes(Enum):
     LIST_DB_TABLES_FAILED = 'TDML_2053'
     INVALID_CONTEXT_CONNECTION = 'TDML_2054'
     TDMLDF_REQUIRED_TABLE_ALIAS = "TDML_2055"
+    TDMLDF_ALIAS_REQUIRED = TDMLDF_REQUIRED_TABLE_ALIAS
     TDMLDF_COLUMN_ALREADY_EXISTS = "TDML_2056"
     TDMLDF_AGGREGATE_INVALID_COLUMN = 'TDML_2057'
     TDMLDF_AGGREGATE_COMBINED_ERR = 'TDML_2058'
@@ -219,6 +220,10 @@ class ErrorInfoCodes(Enum):
     PARTITION_VALUES_NOT_MATCHING = 'TDML_2538'
     PARTITION_IN_BOTH_FIT_AND_PREDICT = 'TDML_2539'
     INVALID_PARTITIONING_COLS = 'TDML_2540'
+    TARGET_COL_NOT_FOUND_FOR_EVALUATE = 'TDML_2541'
+
+    # OpenAF Error codes starting from 2551 - Reserved till 2560.
+    AUTH_TOKEN_REQUIRED = 'TDML_2551'
 
 class MessageCodes(Enum):
     """
@@ -273,6 +278,7 @@ class MessageCodes(Enum):
                                       "and df.select([['col1', 'col2', 'col3']])."
     TDMLDF_INVALID_TABLE_ALIAS      = "{} should not be equal."
     TDMLDF_REQUIRED_TABLE_ALIAS     = "All arguments lsuffix, rsuffix, lprefix and rprefix should not be None as TeradataML DataFrames contains common column(s)."
+    TDMLDF_ALIAS_REQUIRED           = "Use aliased DataFrames for self {}."
     TDMLDF_COLUMN_ALREADY_EXISTS    = "Column name with alias '{}' already exists in {} TeradataML DataFrame, change '{}'"
     TDMLDF_INVALID_JOIN_CONDITION   = "Invalid 'on' condition(s): '{}', check documentation for valid conditions."
     TDMLDF_UNEQUAL_NUMBER_OF_COLUMNS = "Number of columns in '{}' and '{}' should be equal."
@@ -418,7 +424,10 @@ class MessageCodes(Enum):
                 "they should be present in '{}' DataFrame."
     PARTITIONING_COLS_IN_FEATURE_COLS = "Columns in '{}' argument should not be part of"\
                                         " feature columns."
-    PARTITION_VALUES_NOT_MATCHING = "Values in training and test data partition columns should be same."
+    PARTITION_VALUES_NOT_MATCHING = "Values in {} and {} data partition columns should be same."
     PARTITION_IN_BOTH_FIT_AND_PREDICT = "Use \"partition_columns\" only if model is fitted with partition_column(s)."
     INVALID_PARTITIONING_COLS = "Provided partition_column(s) '{}' is/are not present in parent of '{}' DataFrame(s)."
-    PATH_NOT_FOUND = "Specified local path '{}' not found. Please check the path."
+    PATH_NOT_FOUND = "Specified local path '{}' not found. Please check the path."
+    TARGET_COL_NOT_FOUND_FOR_EVALUATE = "Target column '{}' not found in the passed dataFrame. "\
+                                        "evaluate() requires target column to be present in the dataFrame."
+    AUTH_TOKEN_REQUIRED = "Authentication token is required to run '{}'. Set the token using set_auth_token()."

teradataml/common/messages.py

@@ -88,6 +88,7 @@ class Messages():
             [ErrorInfoCodes.TDMLDF_INVALID_JOIN_CONDITION, MessageCodes.TDMLDF_INVALID_JOIN_CONDITION],
             [ErrorInfoCodes.TDMLDF_INVALID_TABLE_ALIAS, MessageCodes.TDMLDF_INVALID_TABLE_ALIAS],
             [ErrorInfoCodes.TDMLDF_REQUIRED_TABLE_ALIAS, MessageCodes.TDMLDF_REQUIRED_TABLE_ALIAS],
+            [ErrorInfoCodes.TDMLDF_ALIAS_REQUIRED, MessageCodes.TDMLDF_ALIAS_REQUIRED],
             [ErrorInfoCodes.TDMLDF_COLUMN_ALREADY_EXISTS, MessageCodes.TDMLDF_COLUMN_ALREADY_EXISTS],
             [ErrorInfoCodes.INVALID_LENGTH_ARGS, MessageCodes.INVALID_LENGTH_ARGS],
             [ErrorInfoCodes.TDMLDF_AGGREGATE_UNSUPPORTED, MessageCodes.TDMLDF_AGGREGATE_UNSUPPORTED],
@@ -189,7 +190,9 @@ class Messages():
             [ErrorInfoCodes.PARTITION_VALUES_NOT_MATCHING, MessageCodes.PARTITION_VALUES_NOT_MATCHING],
             [ErrorInfoCodes.PARTITION_IN_BOTH_FIT_AND_PREDICT, MessageCodes.PARTITION_IN_BOTH_FIT_AND_PREDICT],
             [ErrorInfoCodes.INVALID_PARTITIONING_COLS, MessageCodes.INVALID_PARTITIONING_COLS],
-            [ErrorInfoCodes.PATH_NOT_FOUND, MessageCodes.PATH_NOT_FOUND]
+            [ErrorInfoCodes.PATH_NOT_FOUND, MessageCodes.PATH_NOT_FOUND],
+            [ErrorInfoCodes.TARGET_COL_NOT_FOUND_FOR_EVALUATE, MessageCodes.TARGET_COL_NOT_FOUND_FOR_EVALUATE],
+            [ErrorInfoCodes.AUTH_TOKEN_REQUIRED, MessageCodes.AUTH_TOKEN_REQUIRED],
     ]
 
     @staticmethod

teradataml/common/sqlbundle.py

@@ -47,7 +47,7 @@ class SQLBundle:
                 [SQLConstants.SQL_HELP_COLUMNS, "help column {0}.*"],
                 [SQLConstants.SQL_DROP_TABLE, "DROP TABLE {0}"],
                 [SQLConstants.SQL_DROP_VIEW, "DROP VIEW {0}"],
-                [SQLConstants.SQL_NROWS_FROM_QUERY, "SELECT COUNT(*) FROM {0}"],
+                [SQLConstants.SQL_NROWS_FROM_QUERY, "SELECT CAST(COUNT(*) AS BIGINT) FROM {0}"],
                 [SQLConstants.SQL_TOP_NROWS_FROM_TABLEORVIEW, "select top {0} * from {1}"],
                 [SQLConstants.SQL_INSERT_INTO_TABLE_VALUES, "insert into {0} values({1})"],
                 [SQLConstants.SQL_SELECT_COLUMNNAMES_FROM, "sel {0} from ({1}) as {2}"],
@@ -67,7 +67,8 @@ class SQLBundle:
                 [SQLConstants.SQL_DELETE_ALL_ROWS, "DELETE FROM {0}"],
                 [SQLConstants.SQL_DELETE_SPECIFIC_ROW, "DELETE FROM {0} WHERE {1}"],
                 [SQLConstants.SQL_CREATE_TABLE_USING_COLUMNS, "CREATE MULTISET TABLE {0}( {1} )"],
-                [SQLConstants.SQL_EXEC_STORED_PROCEDURE, "call {0}"]
+                [SQLConstants.SQL_EXEC_STORED_PROCEDURE, "call {0}"],
+                [SQLConstants.SQL_SELECT_COLUMNNAMES_WITH_WHERE, "sel {0} from {1} where {2}"],
 
         ]
         self._add_sql_version()
@@ -446,11 +447,32 @@ class SQLBundle:
         query = sqlbundle._get_sql_query(SQLConstants.SQL_SELECT_DATABASENAME).format(schema_name)
         if table_name:
             if '%' in table_name:
-                query = "{0}{1}".format(query, sqlbundle._get_sql_query(SQLConstants.SQL_AND_TABLE_NAME_LIKE).format(table_name))
+                # Check if '%' is present in the between of table name excluding first and last character
+                # as '%' can be present at the start or end of table name
+                # and replace single quotes with empty string
+                # Checking for following cases with % in between table name:
+                # eg: table_name = 'ab%c', '%a%bc', '%ab%c%' or 'ab%c%'
+
+                # table_name[1:-1] - Removing single quotes from table name
+                # table_name[1:-1][1:-1] - Removing first and last character from table_name[1:-1]
+                if '%' in table_name[1:-1][1:-1]:
+                    query = "{0}{1}".format(query, sqlbundle._get_sql_query(SQLConstants.SQL_AND_TABLE_NAME_LIKE).format(table_name))
+                else:
+                    # Checking for following cases with % at the start or end of table name:
+                    # eg: table_name = '%abc', 'abc%', '%abc%'
+                    # Extracting table name without '%' character
+                    table_name_str = table_name.replace('%', '')
+
+                    # Adding condition to check if table name contains the string using POSITION function
+                    # POSITION function returns the position index of the substring in the string if found,
+                    # else returns 0
+                    query = "{0}{1}{2}".format(query, sqlbundle._get_sql_query(SQLConstants.SQL_AND_TABLE_NAME_LIKE).format(table_name), \
+                                            " AND POSITION({0} IN TABLENAME) > 0".format(table_name_str))
             else:
-                query = "{0}{1}".format(query, sqlbundle._get_sql_query(SQLConstants.SQL_AND_TABLE_NAME).format(table_name))
+                query = "{0}{1}".format(query, sqlbundle._get_sql_query(SQLConstants.SQL_AND_TABLE_NAME_LIKE).format(table_name))
         if table_kind:
             query = '{0}{1}'.format(query, sqlbundle._get_sql_query(SQLConstants.SQL_AND_TABLE_KIND).format(table_kind))
+        
         return query
 
     # TODO :: Following SQLConstants needs to be implemented as and when needed.