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

teradataml/clients/auth_client.py

@@ -97,8 +97,8 @@ class _AuthWorkflow:
             "pat": self.state['pat_token'],
             "sub": self.state['username']
         }
-        # Add iat if required.
-        if self.state['valid_from']:
+        # Add iat if applicable.
+        if self.state['valid_from'] is not None:
             payload.update({"iat": self.state['valid_from']})
         return payload
 

teradataml/common/aed_utils.py

@@ -150,7 +150,7 @@ class AedUtils:
 
         return self.aed_context._validate_aed_return_code(ret_code[0], nodeid_out[0].decode("utf-8"))
 
-    def _aed_select(self, nodeid, select_expr, distinct=False):
+    def _aed_select(self, nodeid, select_expr, distinct=False, timestamp_expr=None):
         """
         This wrapper function facilitates a integration with 'aed_select',
         a C++ function, in AED library, with Python tdml library.
@@ -162,6 +162,7 @@ class AedUtils:
             nodeid - A DAG node, a input to the select API.
             select_expr - Columns, to be selected from the data frame.
             distinct - Boolean, to decide addition of Distinct clause.
+            timestamp_expr - A string, to specify the temporal table clause.
 
         EXAMPLES:
             aed_table_nodeid = AedObj._aed_table("dbname.tablename")
@@ -181,11 +182,16 @@ class AedUtils:
                                                   POINTER(c_char_p),
                                                   POINTER(c_char_p),
                                                   POINTER(c_char_p),
+                                                  POINTER(c_int),
                                                   POINTER(c_int)
                                                   ]
 
         arg_name = ["projection"]
         arg_value = ["DISTINCT " + select_expr if distinct else select_expr]
+        if timestamp_expr:
+            arg_name.append("timestamp_expr")
+            arg_value.append(timestamp_expr)
+
         temp_table_name = UtilFuncs._generate_temp_table_name(prefix="select_", use_default_database=True, quote=False)
         output_table = [UtilFuncs._extract_table_name(temp_table_name)]
         output_schema = [UtilFuncs._extract_db_name(temp_table_name)]
@@ -195,6 +201,8 @@ class AedUtils:
 
         # return code
         ret_code = self.aed_context._int_array1(0)
+
+        length = self.aed_context._int_array1(len(arg_value))
         try:
             # *** AED request to select columns
             self.aed_context.ele_common_lib.aed_select(self.aed_context._arr_c([nodeid]),
@@ -203,6 +211,7 @@ class AedUtils:
                                            self.aed_context._arr_c(output_table),
                                            self.aed_context._arr_c(output_schema),
                                            nodeid_out,
+                                           length,
                                            ret_code)
         except Exception as emsg:
             raise TeradataMlException(Messages.get_message(MessageCodes.AED_EXEC_FAILED, "(aed_select)" + str(emsg)),
@@ -2050,7 +2059,7 @@ class AedUtils:
                                                          POINTER(c_int)
                                                          ]
         # Get number of parent nodes present to allocate enough memory
-        number_of_parent_nodes = self._aed_get_parent_node_count(nodeid);
+        number_of_parent_nodes = self._aed_get_parent_node_count(nodeid)
         parent_nodeids = self.aed_context._arr_c(["00000000000000000000"] * number_of_parent_nodes)
         ret_code = self.aed_context._int_array1(0)
 

teradataml/common/bulk_exposed_utils.py

@@ -98,7 +98,9 @@ def _validate_unimplemented_function(func_name, func_params, *args, **kwargs):
                                                       function_signature,
                                                       return_statement)
     # Creating function object from the string in locals.
-    exec(function_expression)
+    global_scope = {}
+    namespace = {}
+    exec(function_expression, global_scope, namespace)
 
     # kwargs may contain other properties too. So, before we call the function,
     # copying kwargs to another variable and remove additional properties.
@@ -107,5 +109,5 @@ def _validate_unimplemented_function(func_name, func_params, *args, **kwargs):
         if not param in TDMLFrameworkKeywords.AGGREGATE_FUNCTION_DEFAULT_ARGUMENTS.value:
             kw[param] = kwargs[param]
 
-    return locals().get(func_name)(*args, **kw)
+    return namespace[func_name](*args, **kw)
 

teradataml/common/constants.py

@@ -63,10 +63,14 @@ class SQLConstants(Enum):
     SQL_SELECT_COLUMNNAMES_WITH_WHERE = 32
     SQL_HELP_DATABASE = 33
     SQL_HELP_DATALAKE = 34
+    SQL_INSERT_INTO_TABLE_VALUES_WITH_COLUMN_NAMES = 35
     CONSTRAINT = ["check_constraint", "primary_key_constraint",
                   "foreign_key_constraint", "unique_key_constraint"]
     SQL_TD_OTF_METADATA = 35
     SQL_TD_OTF_SNAPSHOT = 36
+    SQL_LIST_TRIGGERS = 37
+    SQL_SHOW_TABLE = 38
+    SQL_SHOW_VIEW = 39
 
 
 class TeradataConstants(Enum):
@@ -143,6 +147,9 @@ class TeradataTypes(Enum):
                     INTERVAL_DAY_TO_SECOND, INTERVAL_HOUR,
                     INTERVAL_HOUR_TO_MINUTE, INTERVAL_HOUR_TO_SECOND,
                     INTERVAL_MINUTE, INTERVAL_MINUTE_TO_SECOND, INTERVAL_SECOND)
+    TD_RANGE_N_CLAUSE_TYPES = (INTERVAL_YEAR, INTERVAL_DAY, INTERVAL_MONTH,
+                               INTERVAL_MINUTE, INTERVAL_SECOND, INTERVAL_HOUR)
+
 
 
 class TeradataTableKindConstants(Enum):
@@ -155,6 +162,21 @@ class TeradataTableKindConstants(Enum):
     VOLATILE_TABLE_NAME = 'Table Name'
     REGULAR_TABLE_NAME = 'TableName'
 
+class DataFrameTypes(Enum):
+    VIEW = "VIEW"
+    VALID_TIME_VIEW = "VALID_TIME_VIEW"
+    TRANSACTION_TIME_VIEW = "TRANSACTION_TIME_VIEW"
+    BI_TEMPORAL_VIEW = "BI_TEMPORAL_VIEW"
+    REGULAR_TABLE = "TABLE"
+    OTF_TABLE = "OTF"
+    BI_TEMPORAL = "BI_TEMPORAL"
+    TRANSACTION_TIME= "TRANSACTION_TIME"
+    VALID_TIME = "VALID_TIME"
+    ART_TABLE = "ART"
+    VOLATILE_TABLE = "VOLATILE_TABLE"
+    VALID_TIME_VOLATILE_TABLE = "VALID_TIME_VOLATILE_TABLE"
+    TRANSACTION_TIME_VOLATILE_TABLE = "TRANSACTION_TIME_VOLATILE_TABLE"
+    BI_TEMPORAL_VOLATILE_TABLE = "BI_TEMPORAL_VOLATILE_TABLE"
 
 class SQLPattern(Enum):
     SQLMR = re.compile(r"SELECT \* FROM .*\((\s*.*)*\) as .*", re.IGNORECASE)
@@ -1434,7 +1456,8 @@ class TeradataReservedKeywords(Enum):
                                "SUMMARY",
                                "HASH",
                                "METHOD",
-                               "TYPE"
+                               "TYPE",
+                               "CATALOG"
                                ]
 
 
@@ -1509,10 +1532,21 @@ class AsyncStatusColumns(Enum):
 
 
 class AsyncOpStatus(Enum):
-    # Holds valid status for asynchronous operatiosns in UES.
+    # Holds valid status for asynchronous operations in UES.
     FILE_INSTALLED = "File Installed"
     ERRED = "Errored"
     FINISHED = "Finished"
+    MODEL_INSTALLED = "ModelInstalled"
+
+
+class AsyncOpStatusOAFColumns(Enum):
+    # Holds column names of dataframe representing status of given claim-id.
+    CLAIM_ID = "Claim Id"
+    FILE_LIB_MODEL_NAME = "File/Libs/Model"
+    METHOD_NAME = "Method Name"
+    STAGE = "Stage"
+    TIMESTAMP = "Timestamp"
+    ADDITIONAL_DETAILS = "Additional Details"
 
 
 class CloudProvider(Enum):
@@ -1559,6 +1593,23 @@ class SessionParamsPythonNames(Enum):
 class AutoMLConstants(Enum):
     # List stores feature selection methods
     FEATURE_SELECTION_MTDS = ["lasso", "rfe", "pca"]
+    # Model lists
+    SUPERVISED_MODELS = ["glm", "svm", "knn", "decision_forest", "xgboost"]
+    CLUSTERING_MODELS = ["KMeans", "GaussianMixture"]
+    ALL_MODELS = SUPERVISED_MODELS + CLUSTERING_MODELS
+    
+    # Metric lists  
+    CLASSIFICATION_METRICS = ["MICRO-F1", "MACRO-F1", "MICRO-RECALL", "MACRO-RECALL",
+                             "MICRO-PRECISION", "MACRO-PRECISION", "WEIGHTED-PRECISION", 
+                             "WEIGHTED-RECALL", "WEIGHTED-F1", "ACCURACY"]
+    
+    REGRESSION_METRICS = ["R2", "MAE", "MSE", "MSLE", "MAPE", "MPE", 
+                         "RMSE", "RMSLE", "ME", "EV", "MPD", "MGD"]
+                         
+    CLUSTERING_METRICS = ["SILHOUETTE", "CALINSKI", "DAVIES"]
+    
+    # Combined for default case
+    ALL_METRICS = REGRESSION_METRICS + CLASSIFICATION_METRICS + CLUSTERING_METRICS
 
 
 class AuthMechs(Enum):
@@ -1577,3 +1628,12 @@ class TDServices(Enum):
     """
     VECTORSTORE = "vectorstore"
     MOPS = "MODELOPS" # For future reference
+
+class AccessQueries(Enum):
+    """
+    Enum to hold permitted access queries.
+    """
+    read = ["{grant_revoke_} SELECT ON {database_} {to_from_} {user_}"]
+    write= ["{grant_revoke_} CREATE TABLE ON {database_} {to_from_} {user_}",
+            "{grant_revoke_} CREATE VIEW ON {database_} {to_from_} {user_}",
+            "{grant_revoke_} DELETE, UPDATE, INSERT ON {database_} {to_from_} {user_}"]

teradataml/common/garbagecollector.py

@@ -325,23 +325,26 @@ class GarbageCollector():
             raise
 
     @staticmethod
-    def _delete_object_entry(object_to_delete,
+    def _delete_object_entry(objects_to_delete,
                              object_type=TeradataConstants.TERADATA_TABLE,
                              remove_entry_from_gc_list=False):
         """
         DESCRIPTION:
             Deletes an entry of table/view/script from persisted file.
-            This makes sure that the object is not garbage collected.
+            This makes sure that the object(s) is/are not garbage collected.
 
         PARAMETERS:
-            object_to_delete:
+            objects_to_delete:
                 Required Argument.
-                Specifies the name of the table/view/script to be deleted.
-                Types: str
+                Specifies the names of the table/view/script to be deleted.
+                Types: str or list of str
 
             object_type:
                 Optional Argument.
                 Specifies the type of the object (table/view/script) to be deleted.
+                Note:
+                    Pass None, when object type is not available. In this case, the given object will be
+                    removed from GC file based on just object name and current process id.
                 Default Value: TeradataConstants.TERADATA_TABLE
                 Types: TeradataConstants
 
@@ -365,8 +368,11 @@ class GarbageCollector():
             None.
 
         EXAMPLES:
-            GarbageCollector._delete_table_view_entry(object_to_delete = 'temp.temp_table1')
+            GarbageCollector._delete_table_view_entry(objects_to_delete = 'temp.temp_table1')
         """
+        from teradataml.common.utils import UtilFuncs
+        objects_to_delete = UtilFuncs._as_list(objects_to_delete)
+
         try:
             tempfilename = GarbageCollector.__make_temp_file_name()
             if not os.path.isfile(tempfilename):
@@ -383,25 +389,37 @@ class GarbageCollector():
                     db_object_type = int(record_parts[2].strip())
                     db_object = record_parts[3].strip()
 
+                    _added_in_gc_file = False # Set to True if the entry is added to GC file.
+
                     # Avoid substring matches by comparing object names in full.
                     # Also make sure to check for the pid.
-                    if not (object_to_delete == db_object
+                    if object_type and not (db_object in objects_to_delete
                             and object_type.value == db_object_type
                             and int(os.getpid()) == contentpid):
                         fgc.write(db_object_entry)
-                    else:
-                        if remove_entry_from_gc_list and configure._validate_gc:
-                            # Delete the entry from gc lists if required.
-                            GarbageCollector.__delete_object_from_gc_list(object_to_delete,
-                                                                          object_type)
-
-                        # If object is a script, also delete the local copy of the file.
-                        if object_type in \
-                            [TeradataConstants.TERADATA_SCRIPT,
-                             TeradataConstants.TERADATA_APPLY,
-                             TeradataConstants.TERADATA_TEXT_FILE,
-                             TeradataConstants.TERADATA_LOCAL_SCRIPT]:
-                            GarbageCollector.__delete_gc_tempdir_local_file(db_object, object_type)
+                        _added_in_gc_file = True
+
+                    elif object_type is None:
+                        if db_object in objects_to_delete and int(os.getpid()) == contentpid:
+                            # Skip adding to GC file if the object is being deleted but object_type is passed as None.
+                            pass
+                        else:
+                            fgc.write(db_object_entry)
+                            _added_in_gc_file = True
+
+
+                    if not _added_in_gc_file and remove_entry_from_gc_list and configure._validate_gc:
+                        # Delete the entry from gc lists if required.
+                        GarbageCollector.__delete_object_from_gc_list(db_object, object_type)
+
+
+                    # If object is a script, also delete the local copy of the file.
+                    if not _added_in_gc_file and object_type in \
+                        [TeradataConstants.TERADATA_SCRIPT,
+                         TeradataConstants.TERADATA_APPLY,
+                         TeradataConstants.TERADATA_TEXT_FILE,
+                         TeradataConstants.TERADATA_LOCAL_SCRIPT]:
+                        GarbageCollector.__delete_gc_tempdir_local_file(db_object, object_type)
                 fgc.truncate()
         except Exception as e:
             raise
@@ -456,8 +474,19 @@ class GarbageCollector():
                 GarbageCollector.__gc_container.remove(object_name)
             elif TeradataConstants.TERADATA_APPLY == object_type:
                 GarbageCollector.__gc_apply.remove(object_name)
-            else:
+            elif TeradataConstants.TERADATA_SCRIPT == object_type:
                 GarbageCollector.__gc_scripts.remove(object_name)
+            else:
+                # If none of the conditions met, then try removing from all.
+                _all_gc_lists = [GarbageCollector.__gc_tables, GarbageCollector.__gc_views,
+                                 GarbageCollector.__gc_scripts, GarbageCollector.__gc_container,
+                                 GarbageCollector.__gc_apply]
+                for _list in _all_gc_lists:
+                    try:
+                        _list.remove(object_name)
+                    except ValueError:
+                        # If the object is not found in the list, just ignore.
+                        pass
 
     @staticmethod
     def _delete_local_file(file_path):

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,7 @@ 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'
@@ -242,6 +245,22 @@ class ErrorInfoCodes(Enum):
     # 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):
     """
@@ -388,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."
@@ -411,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."
@@ -457,6 +477,8 @@ 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'."
@@ -468,4 +490,27 @@ class MessageCodes(Enum):
 
     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

@@ -197,6 +197,9 @@ class Messages():
             [ErrorInfoCodes.SET_REQUIRED_PARAMS, MessageCodes.SET_REQUIRED_PARAMS],
             [ErrorInfoCodes.MISSING_ARGS, MessageCodes.CONNECTION_PARAMS],
             [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],
@@ -204,7 +207,22 @@ class Messages():
             [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.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

@@ -71,8 +71,13 @@ class SQLBundle:
                 [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_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_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()
 
@@ -158,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,
@@ -167,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
@@ -180,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
@@ -636,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.
@@ -644,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.
@@ -653,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):