tdfs4ds 0.2.4.26__py3-none-any.whl → 0.2.5.1__py3-none-any.whl

tdfs4ds/feature_store/feature_store_management.py

@@ -9,6 +9,7 @@ import pandas as pd
 import tqdm
 import inspect
 import re
+from tdfs4ds import logger_safe, logger
 
 @execute_query_wrapper
 def feature_store_catalog_view_creation():
@@ -129,57 +130,27 @@ def feature_store_catalog_creation(if_exists='replace', comment='this table is a
     return tdfs4ds.FEATURE_CATALOG_NAME
 
 
-def feature_store_table_creation(entity_id, feature_type, if_exists='fail', primary_index = None, partitioning = ''):
+def feature_store_table_creation(entity_id, feature_type, if_exists='fail', primary_index=None, partitioning=''):
     """
     Creates a table and a corresponding view for feature storage in a Teradata database schema, based on specified entity ID and feature type.
-
-    This function automates the creation of a table and view tailored for storing features in a structured manner. It leverages provided entity identifiers and feature types to generate table and view names dynamically, integrating with an existing feature catalog for consistency and reference. The table and view are created with considerations for primary indexing and optional partitioning strategies to optimize data management and access.
-
-    Parameters:
-    - entity_id (dict): Maps column names to their respective data types, defining the structure of the entity identifier(s).
-    - feature_type (str): Specifies the data type of the feature (e.g., 'FLOAT', 'BIGINT', 'VARCHAR_LATIN', 'VARCHAR_UNICODE').
-    - if_exists (str, optional): Determines the action if the table already exists. Options include:
-                                 'fail' (default), which raises an error; and 'replace', which drops the existing table and creates a new one.
-    - primary_index (list, optional): Specifies the columns to be used as the primary index for the table. Enhances data retrieval performance.
-    - partitioning (str, optional): SQL clause to define table partitioning. Aids in managing large datasets efficiently.
-
-    Returns:
-    str: The name of the newly created feature store table.
-
-    Note:
-    - Utilizes default schema and feature catalog names as defined in the tdfs4ds module.
-    - The primary index typically includes the entity ID, feature ID, and feature version for optimal data organization.
-    - A secondary index on the feature ID facilitates efficient querying.
-    - Corresponding views offer a snapshot of the current valid-time features, simplifying temporal queries.
-    - Existing tables are handled based on the 'if_exists' parameter, with support for replacing or retaining the tables.
-    - Assumes necessary database access and permissions are available for table and view creation.
-
-    Example Usage:
-    >>> entity_id_dict = {'customer_id': 'INTEGER'}
-    >>> table_name = feature_store_table_creation(entity_id_dict, 'FLOAT')
-    >>> print(f"Feature store table {table_name} created successfully.")
     """
-
-
-    table_name, view_name = get_feature_store_table_name(entity_id, feature_type, primary_index = primary_index, partitioning = partitioning)
-    if len([t for t in tdml.db_list_tables(schema_name=tdfs4ds.SCHEMA).TableName if t.lower() ==table_name.lower()]) > 0:
-        if tdfs4ds.DISPLAY_LOGS:
-            print(f'table {table_name} in the {tdfs4ds.SCHEMA} database already exists. No need to create it.')
+    table_name, view_name = get_feature_store_table_name(entity_id, feature_type, primary_index=primary_index, partitioning=partitioning)
+    if len([t for t in tdml.db_list_tables(schema_name=tdfs4ds.SCHEMA).TableName if t.lower() == table_name.lower()]) > 0:
+        logger_safe('info', f'table {table_name} in the {tdfs4ds.SCHEMA} database already exists. No need to create it.')
         return table_name
     else:
-        if tdfs4ds.DISPLAY_LOGS:
-            print(f'table {table_name} in the {tdfs4ds.SCHEMA} database does not exists. Need to create it.')
+        logger_safe('info', f'table {table_name} in the {tdfs4ds.SCHEMA} database does not exists. Need to create it.')
 
     query_feature_value = {
         'FLOAT':            'FEATURE_VALUE FLOAT',
         'BIGINT':           'FEATURE_VALUE BIGINT',
         'VARCHAR_LATIN':    f'FEATURE_VALUE VARCHAR({tdfs4ds.VARCHAR_SIZE}) CHARACTER SET LATIN',
         'VARCHAR_UNICODE':  f'FEATURE_VALUE VARCHAR({tdfs4ds.VARCHAR_SIZE}) CHARACTER SET UNICODE',
-        'TIMESTAMP0' :      'FEATURE_VALUE TIMESTAMP(0)',
-        'TIMESTAMP0TZ' :    'FEATURE_VALUE TIMESTAMP(0) WITH TIME ZONE',
-        'PERIODTS0' :       'FEATURE_VALUE PERIOD(TIMESTAMP(0))',
+        'TIMESTAMP0':       'FEATURE_VALUE TIMESTAMP(0)',
+        'TIMESTAMP0TZ':     'FEATURE_VALUE TIMESTAMP(0) WITH TIME ZONE',
+        'PERIODTS0':        'FEATURE_VALUE PERIOD(TIMESTAMP(0))',
         'PERIODTS0TZ':      'FEATURE_VALUE PERIOD(TIMESTAMP(0) WITH TIME ZONE)',
-        'DECIMAL' :         'FEATURE_VALUE DECIMAL(38,19)'
+        'DECIMAL':          'FEATURE_VALUE DECIMAL(38,19)'
     }
 
     # Construct the column definitions for the table based on the entity ID
@@ -196,12 +167,14 @@ def feature_store_table_creation(entity_id, feature_type, if_exists='fail', prim
     # SQL query to create the feature store table
     if feature_type.lower() == 'ref':
         partitioning = partitioning.replace('"', "'")
-        partitioning = partitioning.replace(f'RANGE_N(FEATURE_ID BETWEEN 0 AND {tdfs4ds.FEATURE_PARTITION_N} EACH {tdfs4ds.FEATURE_PARTITION_EACH}),','')
+        partitioning = partitioning.replace(f'RANGE_N(FEATURE_ID BETWEEN 0 AND {tdfs4ds.FEATURE_PARTITION_N} EACH {tdfs4ds.FEATURE_PARTITION_EACH}),', '')
         partitioning = partitioning.replace(
             f'RANGE_N(FEATURE_ID BETWEEN 0 AND {tdfs4ds.FEATURE_PARTITION_N} EACH {tdfs4ds.FEATURE_PARTITION_EACH})',
-            '')
+            ''
+        )
         substr = extract_partition_content(partitioning.upper())
-        if len(substr)==0: partitioning =  ''
+        if len(substr) == 0:
+            partitioning = ''
         query = f"""
         CREATE MULTISET TABLE {tdfs4ds.SCHEMA}.{table_name},
             FALLBACK,
@@ -217,7 +190,7 @@ def feature_store_table_creation(entity_id, feature_type, if_exists='fail', prim
             {partitioning};
     """
     else:
-        partitioning = partitioning.replace('"',"'")
+        partitioning = partitioning.replace('"', "'")
         query = f"""
         CREATE MULTISET TABLE {tdfs4ds.SCHEMA}.{table_name},
                 FALLBACK,
@@ -266,39 +239,40 @@ def feature_store_table_creation(entity_id, feature_type, if_exists='fail', prim
 
     try:
         # Attempt to execute the create table query
-        execute_query(query)
-        execute_query(query3)
+        execute_query(query, raise_error=True)
+        execute_query(query3, raise_error=True)
         if tdml.display.print_sqlmr_query:
-            print(query)
-            print(query3)
-        if tdfs4ds.DISPLAY_LOGS: print(f'TABLE {tdfs4ds.SCHEMA}.{table_name} has been created')
-        #execute_query(query2)
+            logger_safe('info', query)
+            logger_safe('info', query3)
+        logger_safe('info', f'TABLE {tdfs4ds.SCHEMA}.{table_name} has been created')
+        # execute_query(query2)
     except Exception as e:
-        # If the table already exists and if_exists is set to 'replace', drop the table and recreate it
-        print(str(e).split('\n')[0])
-        if str(e).split('\n')[0].endswith('already exists.') and (if_exists == 'replace'):
-            execute_query(f'DROP TABLE  {tdfs4ds.SCHEMA}.{table_name}')
-            if tdfs4ds.DISPLAY_LOGS: print(f'TABLE {tdfs4ds.SCHEMA}.{table_name} has been dropped')
+        msg = str(e).split('\n')[0]
+        logger_safe('error', msg)
+        if msg.endswith('already exists.') and (if_exists == 'replace'):
+            execute_query(f'DROP TABLE  {tdfs4ds.SCHEMA}.{table_name}', raise_error=True)
+            logger_safe('info', f'TABLE {tdfs4ds.SCHEMA}.{table_name} has been dropped')
             try:
                 # Attempt to recreate the table after dropping it
-                execute_query(query)
-                if tdfs4ds.DISPLAY_LOGS: print(f'TABLE {tdfs4ds.SCHEMA}.{table_name} has been re-created')
+                execute_query(query, raise_error=True)
+                logger_safe('info', f'TABLE {tdfs4ds.SCHEMA}.{table_name} has been re-created')
                 if tdml.display.print_sqlmr_query:
-                    print(query)
-            except Exception as e:
-                print(str(e).split('\n')[0])
+                    logger_safe('info', query)
+            except Exception as e2:
+                logger_safe('error', str(e2).split('\n')[0])
 
     try:
         # Attempt to create the view
-        execute_query(query_view)
+        execute_query(query_view, raise_error=True)
         if tdml.display.print_sqlmr_query:
-            print(query)
-        if tdfs4ds.DISPLAY_LOGS: print(f'VIEW {tdfs4ds.SCHEMA}.{view_name} has been created')
+            logger_safe('info', query_view)
+        logger_safe('info', f'VIEW {tdfs4ds.SCHEMA}.{view_name} has been created')
     except Exception as e:
-        print(str(e).split('\n')[0])
+        logger_safe('error', str(e).split('\n')[0])
 
     return table_name
 
+
 def register_features(entity_id, feature_names_types, primary_index = None, partitioning = ''):
     """
     Orchestrates the registration or update of feature definitions in a Teradata database's feature catalog.
@@ -350,46 +324,47 @@ def register_features(entity_id, feature_names_types, primary_index = None, part
 
 def _register_features_merge(entity_id, feature_names_types, primary_index=None, partitioning=''):
     """
-    Registers or updates feature definitions in a Teradata database's feature catalog, associating entity identifiers
-    with feature names, types, and other metadata. This function prepares and executes SQL operations to insert new
-    feature definitions or update existing ones, considering partitioning strategies and primary index configurations.
-
-    Parameters:
-    - entity_id (dict): Specifies the entity's identifiers with keys representing attribute names. This dictionary
-                        is crucial for defining the scope and granularity of feature data.
-    - feature_names_types (dict): Maps feature names to their properties, including data types and unique identifiers.
-                                  Each value is a dictionary with keys 'type' and 'id' indicating the feature's data
-                                  type and a unique identifier, respectively.
-    - primary_index (list, optional): Identifies the primary index column(s) for the feature data. This influences
-                                      the organization and performance of database operations. If not specified,
-                                      defaults are used based on the entity_id structure.
-    - partitioning (str, optional): Describes the partitioning strategy through a string listing column names used
-                                    for partitioning. This can impact data storage and retrieval performance.
-
-    Returns:
-    pd.DataFrame: Contains details of the registered features, including names, types, IDs, and references to the
-                  respective feature store table and view names, alongside metadata about the entity and database schema.
-
-    Note:
-    - The function dynamically constructs SQL queries for inserting new features or updating existing ones in the
-      feature catalog, adapting to the provided partitioning and primary index settings.
-    - Assumes the existence of a Teradata feature catalog table in the specified schema and that the database connection
-      is correctly configured.
-    - Utilizes the tdfs4ds module for database schema configurations and valid-time temporal table considerations.
-
-    Example Usage:
-    >>> entity_id = {'customer_id': 'INTEGER'}
-    >>> feature_names_types = {'age': {'type': 'BIGINT', 'id': 1}, 'gender': {'type': 'VARCHAR_LATIN', 'id': 2}}
-    >>> registered_features = register_features(entity_id, feature_names_types)
-    >>> print(registered_features)
-
-    This example demonstrates registering features for an entity with attributes customer_id, age, and gender,
-    where age and gender features have specified types and unique IDs.
+    Register or update feature definitions in the feature catalog, with temporal support.
+
+    This function builds (or refreshes) entries in the Teradata feature catalog from a
+    mapping of feature names to their metadata, computes the target feature store table
+    and view names, stages the metadata to a temporary table, and executes a MERGE into
+    the catalog (with optional VALIDTIME support based on `tdfs4ds.FEATURE_STORE_TIME`).
+
+    Parameters
+    ----------
+    entity_id : dict[str, Any]
+        Mapping of entity-key column names to types. Only the keys (column names) are
+        required here; values are not used by this function.
+    feature_names_types : dict[str, dict]
+        Dict of feature name -> {"type": <SQL_TYPE>, "id": <int>} describing each
+        feature’s storage type and identifier in the catalog.
+    primary_index : list[str] | None, optional
+        Primary index column(s) to use when deriving the feature store table/view names.
+        If None, defaults are inferred by `get_feature_store_table_name`.
+    partitioning : str, optional
+        Partitioning expression or comma-separated column list used by
+        `get_feature_store_table_name`.
+
+    Returns
+    -------
+    pd.DataFrame
+        A dataframe of the features that were (up)registered, including:
+        FEATURE_NAME, FEATURE_TYPE, FEATURE_ID, FEATURE_TABLE, FEATURE_VIEW,
+        ENTITY_NAME, FEATURE_DATABASE, DATA_DOMAIN.
+
+    Notes
+    -----
+    - When `tdfs4ds.FEATURE_STORE_TIME is None`, uses CURRENT VALIDTIME (non-explicit start/end).
+      Otherwise uses `VALIDTIME PERIOD ('<FEATURE_STORE_TIME>', '<END_PERIOD>')` and adds
+      the valid-time start/end when inserting.
+    - Respects `tdfs4ds.DISPLAY_LOGS` via `logger_safe`.
     """
 
-    if tdfs4ds.FEATURE_STORE_TIME == None:
+    # --- VALIDTIME setup -----------------------------------------------------
+    if tdfs4ds.FEATURE_STORE_TIME is None:
         validtime_statement = 'CURRENT VALIDTIME'
-        validtime_start = 'CAST(CURRENT_TIME AS TIMESTAMP(0) WITH TIME ZONE)'
+        validtime_start = "CAST(CURRENT_TIME AS TIMESTAMP(0) WITH TIME ZONE)"
     else:
         validtime_statement = f"VALIDTIME PERIOD '({tdfs4ds.FEATURE_STORE_TIME},{tdfs4ds.END_PERIOD})'"
         validtime_start = f"CAST('{tdfs4ds.FEATURE_STORE_TIME}' AS TIMESTAMP(0) WITH TIME ZONE)"
@@ -399,154 +374,174 @@ def _register_features_merge(entity_id, feature_names_types, primary_index=None,
     else:
         end_period_ = tdfs4ds.END_PERIOD
 
-    if len(list(feature_names_types.keys())) == 0:
-        if tdfs4ds.DISPLAY_LOGS: print('no new feature to register')
+    # --- Input checks & early exit ------------------------------------------
+    if not feature_names_types:
+        logger_safe("info", "register_features: no new features to register")
         return
 
-    # Create a comma-separated string of entity IDs
-    entity_id_list = list(entity_id.keys())
-    entity_id_list.sort()
-    ENTITY_ID__ = ','.join([k for k in entity_id_list])
-
-    # Create a DataFrame from the feature_names_types dictionary
-    if len(feature_names_types.keys()) > 1:
-        df = pd.DataFrame(feature_names_types).transpose().reset_index()
-        df.columns = ['FEATURE_NAME', 'FEATURE_TYPE', 'FEATURE_ID']
-    else:
-        df = pd.DataFrame(columns=['FEATURE_NAME', 'FEATURE_TYPE', 'FEATURE_ID'])
-        k = list(feature_names_types.keys())[0]
-        df['FEATURE_NAME'] = [k]
-        df['FEATURE_TYPE'] = [feature_names_types[k]['type']]
-        df['FEATURE_ID'] = [feature_names_types[k]['id']]
-
-
-
-    if tdfs4ds.DEBUG_MODE:
-        print('register_features', 'primary_index', primary_index)
-        print('register_features', 'partitioning', partitioning)
-        print('df', df)
-
-    # Generate the feature table and view names based on the entity ID and feature type
-    df['FEATURE_TABLE'] = df.apply(lambda row: get_feature_store_table_name(entity_id, row.iloc[1],
-                                                                            primary_index=primary_index,
-                                                                            partitioning=partitioning)[0],
-                                   axis=1)
-    df['FEATURE_VIEW'] = df.apply(lambda row: get_feature_store_table_name(entity_id, row.iloc[1],
-                                                                           primary_index=primary_index,
-                                                                           partitioning=partitioning)[1],
-                                  axis=1)
-
-    # Add additional columns to the DataFrame
-    df['ENTITY_NAME'] = ENTITY_ID__
-    df['FEATURE_DATABASE'] = tdfs4ds.SCHEMA
-    df['DATA_DOMAIN'] = tdfs4ds.DATA_DOMAIN
-
-    # Copy the DataFrame to a temporary table in Teradata
-    tdml.copy_to_sql(df, table_name='temp', schema_name=tdfs4ds.SCHEMA, if_exists='replace',
-                     primary_index='FEATURE_ID',
-                     types={'FEATURE_ID': tdml.BIGINT})
-
-
-
-    if tdfs4ds.DEBUG_MODE:
-        print("-----------_register_features_merge - df")
-        print(df)
+    # --- Entity columns (ordered, stable) -----------------------------------
+    entity_cols = sorted(list(entity_id.keys()))
+    ENTITY_ID__ = ",".join(entity_cols)
 
-    if tdfs4ds.FEATURE_STORE_TIME == None:
+    # --- Build dataframe safely (no transpose tricks) ------------------------
+    rows = []
+    for fname, meta in feature_names_types.items():
+        try:
+            rows.append({
+                "FEATURE_NAME": fname,
+                "FEATURE_TYPE": meta["type"],
+                "FEATURE_ID":   meta["id"],
+            })
+        except KeyError as e:
+            logger_safe("error", "register_features: missing key %s in feature '%s' meta=%s", str(e), fname, meta)
+            raise
+
+    df = pd.DataFrame(rows, columns=["FEATURE_NAME", "FEATURE_TYPE", "FEATURE_ID"])
+
+    logger_safe(
+        "debug",
+        "register_features: features_count=%d | entity_cols=%s | primary_index=%s | partitioning=%s",
+        len(df),
+        entity_cols,
+        primary_index,
+        partitioning,
+    )
+
+    # --- Compute feature table & view names ---------------------------------
+    # Use apply to preserve original order; get_feature_store_table_name returns (table, view)
+    df["FEATURE_TABLE"] = df.apply(
+        lambda row: get_feature_store_table_name(
+            entity_id,
+            row["FEATURE_TYPE"],
+            primary_index=primary_index,
+            partitioning=partitioning
+        )[0],
+        axis=1
+    )
+    df["FEATURE_VIEW"] = df.apply(
+        lambda row: get_feature_store_table_name(
+            entity_id,
+            row["FEATURE_TYPE"],
+            primary_index=primary_index,
+            partitioning=partitioning
+        )[1],
+        axis=1
+    )
+
+    # --- Add catalog columns -------------------------------------------------
+    df["ENTITY_NAME"] = ENTITY_ID__
+    df["FEATURE_DATABASE"] = tdfs4ds.SCHEMA
+    df["DATA_DOMAIN"] = tdfs4ds.DATA_DOMAIN
+
+    # --- Stage to temp table -------------------------------------------------
+    tdml.copy_to_sql(
+        df,
+        table_name="temp",
+        schema_name=tdfs4ds.SCHEMA,
+        if_exists="replace",
+        primary_index="FEATURE_ID",
+        types={"FEATURE_ID": tdml.BIGINT},
+    )
+    logger_safe("debug", "register_features: staged %d rows to %s.temp", len(df), tdfs4ds.SCHEMA)
+
+    # --- Build MERGE statement ----------------------------------------------
+    if tdfs4ds.FEATURE_STORE_TIME is None:
+        # no explicit start/end in INSERT branch
         query_merge = f"""
          {validtime_statement}
-         MERGE INTO  {tdfs4ds.SCHEMA}.{tdfs4ds.FEATURE_CATALOG_NAME} EXISTING_FEATURES
+         MERGE INTO {tdfs4ds.SCHEMA}.{tdfs4ds.FEATURE_CATALOG_NAME} EXISTING_FEATURES
          USING (
              SELECT
-                CASE WHEN B.FEATURE_ID IS NULL THEN A.FEATURE_ID ELSE B.FEATURE_ID END AS FEATURE_ID
-            ,   A.FEATURE_NAME
-            ,   A.FEATURE_TYPE
-            ,   A.FEATURE_TABLE
-            ,   A.FEATURE_DATABASE
-            ,   A.FEATURE_VIEW
-            ,   A.ENTITY_NAME
-            ,   A.DATA_DOMAIN
-            FROM {tdfs4ds.SCHEMA}.temp A
-            LEFT JOIN {tdfs4ds.SCHEMA}.{tdfs4ds.FEATURE_CATALOG_NAME_VIEW} B
-            ON A.FEATURE_NAME = B.FEATURE_NAME
-            AND A.ENTITY_NAME = B.ENTITY_NAME -- modified
-            AND A.DATA_DOMAIN = B.DATA_DOMAIN
-             ) UPDATED_FEATURES
-         ON UPDATED_FEATURES.FEATURE_ID = EXISTING_FEATURES.FEATURE_ID
-         AND UPDATED_FEATURES.FEATURE_NAME = EXISTING_FEATURES.FEATURE_NAME
-         AND UPDATED_FEATURES.DATA_DOMAIN = EXISTING_FEATURES.DATA_DOMAIN
-         WHEN MATCHED THEN
-             UPDATE
-             SET
-                FEATURE_TABLE    = UPDATED_FEATURES.FEATURE_TABLE,
-                FEATURE_TYPE     = UPDATED_FEATURES.FEATURE_TYPE,
-                FEATURE_DATABASE = UPDATED_FEATURES.FEATURE_DATABASE,
-                FEATURE_VIEW     = UPDATED_FEATURES.FEATURE_VIEW
-                --,ENTITY_NAME      = UPDATED_FEATURES.ENTITY_NAME -- modified
-         WHEN NOT MATCHED THEN
-             INSERT
+                   CASE WHEN B.FEATURE_ID IS NULL THEN A.FEATURE_ID ELSE B.FEATURE_ID END AS FEATURE_ID
+                 , A.FEATURE_NAME
+                 , A.FEATURE_TYPE
+                 , A.FEATURE_TABLE
+                 , A.FEATURE_DATABASE
+                 , A.FEATURE_VIEW
+                 , A.ENTITY_NAME
+                 , A.DATA_DOMAIN
+             FROM {tdfs4ds.SCHEMA}.temp A
+             LEFT JOIN {tdfs4ds.SCHEMA}.{tdfs4ds.FEATURE_CATALOG_NAME_VIEW} B
+               ON A.FEATURE_NAME = B.FEATURE_NAME
+              AND A.ENTITY_NAME = B.ENTITY_NAME
+              AND A.DATA_DOMAIN = B.DATA_DOMAIN
+         ) UPDATED_FEATURES
+           ON UPDATED_FEATURES.FEATURE_ID   = EXISTING_FEATURES.FEATURE_ID
+          AND UPDATED_FEATURES.FEATURE_NAME = EXISTING_FEATURES.FEATURE_NAME
+          AND UPDATED_FEATURES.DATA_DOMAIN  = EXISTING_FEATURES.DATA_DOMAIN
+         WHEN MATCHED THEN UPDATE SET
+               FEATURE_TABLE    = UPDATED_FEATURES.FEATURE_TABLE
+             , FEATURE_TYPE     = UPDATED_FEATURES.FEATURE_TYPE
+             , FEATURE_DATABASE = UPDATED_FEATURES.FEATURE_DATABASE
+             , FEATURE_VIEW     = UPDATED_FEATURES.FEATURE_VIEW
+         WHEN NOT MATCHED THEN INSERT
              (  UPDATED_FEATURES.FEATURE_ID
-            ,   UPDATED_FEATURES.FEATURE_NAME
-            ,   UPDATED_FEATURES.FEATURE_TYPE
-            ,   UPDATED_FEATURES.FEATURE_TABLE
-            ,   UPDATED_FEATURES.FEATURE_DATABASE
-            ,   UPDATED_FEATURES.FEATURE_VIEW
-            ,   UPDATED_FEATURES.ENTITY_NAME
-            ,   UPDATED_FEATURES.DATA_DOMAIN
-            )
-         """
+              , UPDATED_FEATURES.FEATURE_NAME
+              , UPDATED_FEATURES.FEATURE_TYPE
+              , UPDATED_FEATURES.FEATURE_TABLE
+              , UPDATED_FEATURES.FEATURE_DATABASE
+              , UPDATED_FEATURES.FEATURE_VIEW
+              , UPDATED_FEATURES.ENTITY_NAME
+              , UPDATED_FEATURES.DATA_DOMAIN
+             );
+        """
     else:
+        # insert with explicit valid-time start/end
         query_merge = f"""
          {validtime_statement}
-         MERGE INTO  {tdfs4ds.SCHEMA}.{tdfs4ds.FEATURE_CATALOG_NAME} EXISTING_FEATURES
+         MERGE INTO {tdfs4ds.SCHEMA}.{tdfs4ds.FEATURE_CATALOG_NAME} EXISTING_FEATURES
          USING (
              SELECT
-                CASE WHEN B.FEATURE_ID IS NULL THEN A.FEATURE_ID ELSE B.FEATURE_ID END AS FEATURE_ID
-            ,   A.FEATURE_NAME
-            ,   A.FEATURE_TYPE
-            ,   A.FEATURE_TABLE
-            ,   A.FEATURE_DATABASE
-            ,   A.FEATURE_VIEW
-            ,   A.ENTITY_NAME
-            ,   A.DATA_DOMAIN
-            FROM {tdfs4ds.SCHEMA}.temp A
-            LEFT JOIN {tdfs4ds.SCHEMA}.{tdfs4ds.FEATURE_CATALOG_NAME_VIEW} B
-            ON A.FEATURE_NAME = B.FEATURE_NAME
-            AND A.ENTITY_NAME = B.ENTITY_NAME -- modified
-            AND A.DATA_DOMAIN = B.DATA_DOMAIN
-             ) UPDATED_FEATURES
-         ON  UPDATED_FEATURES.FEATURE_ID = EXISTING_FEATURES.FEATURE_ID
-         AND UPDATED_FEATURES.FEATURE_NAME = EXISTING_FEATURES.FEATURE_NAME
-         AND UPDATED_FEATURES.DATA_DOMAIN = EXISTING_FEATURES.DATA_DOMAIN
-         WHEN MATCHED THEN
-             UPDATE
-             SET
-                FEATURE_TABLE    = UPDATED_FEATURES.FEATURE_TABLE,
-                FEATURE_TYPE    = UPDATED_FEATURES.FEATURE_TYPE,
-                FEATURE_DATABASE = UPDATED_FEATURES.FEATURE_DATABASE,
-                FEATURE_VIEW     = UPDATED_FEATURES.FEATURE_VIEW
-                --,ENTITY_NAME      = UPDATED_FEATURES.ENTITY_NAME -- modified
-         WHEN NOT MATCHED THEN
-             INSERT
+                   CASE WHEN B.FEATURE_ID IS NULL THEN A.FEATURE_ID ELSE B.FEATURE_ID END AS FEATURE_ID
+                 , A.FEATURE_NAME
+                 , A.FEATURE_TYPE
+                 , A.FEATURE_TABLE
+                 , A.FEATURE_DATABASE
+                 , A.FEATURE_VIEW
+                 , A.ENTITY_NAME
+                 , A.DATA_DOMAIN
+             FROM {tdfs4ds.SCHEMA}.temp A
+             LEFT JOIN {tdfs4ds.SCHEMA}.{tdfs4ds.FEATURE_CATALOG_NAME_VIEW} B
+               ON A.FEATURE_NAME = B.FEATURE_NAME
+              AND A.ENTITY_NAME = B.ENTITY_NAME
+              AND A.DATA_DOMAIN = B.DATA_DOMAIN
+         ) UPDATED_FEATURES
+           ON UPDATED_FEATURES.FEATURE_ID   = EXISTING_FEATURES.FEATURE_ID
+          AND UPDATED_FEATURES.FEATURE_NAME = EXISTING_FEATURES.FEATURE_NAME
+          AND UPDATED_FEATURES.DATA_DOMAIN  = EXISTING_FEATURES.DATA_DOMAIN
+         WHEN MATCHED THEN UPDATE SET
+               FEATURE_TABLE    = UPDATED_FEATURES.FEATURE_TABLE
+             , FEATURE_TYPE     = UPDATED_FEATURES.FEATURE_TYPE
+             , FEATURE_DATABASE = UPDATED_FEATURES.FEATURE_DATABASE
+             , FEATURE_VIEW     = UPDATED_FEATURES.FEATURE_VIEW
+         WHEN NOT MATCHED THEN INSERT
              (  UPDATED_FEATURES.FEATURE_ID
-            ,   UPDATED_FEATURES.FEATURE_NAME
-            ,   UPDATED_FEATURES.FEATURE_TYPE
-            ,   UPDATED_FEATURES.FEATURE_TABLE
-            ,   UPDATED_FEATURES.FEATURE_DATABASE
-            ,   UPDATED_FEATURES.FEATURE_VIEW
-            ,   UPDATED_FEATURES.ENTITY_NAME
-            ,   UPDATED_FEATURES.DATA_DOMAIN,
-             {validtime_start},
-             '{end_period_}')
-         """
+              , UPDATED_FEATURES.FEATURE_NAME
+              , UPDATED_FEATURES.FEATURE_TYPE
+              , UPDATED_FEATURES.FEATURE_TABLE
+              , UPDATED_FEATURES.FEATURE_DATABASE
+              , UPDATED_FEATURES.FEATURE_VIEW
+              , UPDATED_FEATURES.ENTITY_NAME
+              , UPDATED_FEATURES.DATA_DOMAIN
+              , {validtime_start}
+              , '{end_period_}'
+             );
+        """
 
-    if tdfs4ds.DEBUG_MODE:
-        print("-----------_register_features_merge - query_merge")
-        print(query_merge)
-    # Execute the update and insert queries
+    logger_safe("debug", "register_features: merge_sql_preview=%s", " ".join(query_merge.split())[:400] + " ...")
+
+    # --- Execute MERGE -------------------------------------------------------
     execute_query(query_merge)
+    logger_safe(
+        "info",
+        "register_features: merged %d features into %s.%s",
+        len(df),
+        tdfs4ds.SCHEMA,
+        tdfs4ds.FEATURE_CATALOG_NAME,
+    )
 
     return df
+
 def _register_features_update_insert(entity_id, feature_names_types, primary_index = None, partitioning = ''):
     """
     Registers or updates feature definitions in a Teradata database's feature catalog, associating entity identifiers
@@ -1011,7 +1006,7 @@ def delete_feature(feature_name, entity_id, data_domain=None):
         print('table name : ', table_name)
 
     query = f"""
-    DELETE {table_name}
+    NONSEQUENCED VALIDTIME DELETE {table_name}
     WHERE FEATURE_ID = (
         SEL FEATURE_ID FROM {tdfs4ds.SCHEMA}.{tdfs4ds.FEATURE_CATALOG_NAME_VIEW}
         WHERE FEATURE_NAME = '{feature_name}'

tdfs4ds/genai/__init__.py

@@ -0,0 +1,27 @@
+from .documentation import (
+    document_sql_query_columns,
+    document_process,
+    documentation_tables_creation,
+    document_sql_query_explain,
+    build_explain_documentation_chain,
+    run_explain_documentation,
+    build_sql_documentation_chain,
+    run_sql_documentation,
+    build_llm,
+    get_the_explain,
+    display_process_info
+)
+
+__all__ = [
+    "document_sql_query_columns",
+    "document_process",
+    "documentation_tables_creation",
+    "document_sql_query_explain",
+    "build_explain_documentation_chain",
+    "run_explain_documentation",
+    "build_sql_documentation_chain",
+    "run_sql_documentation",
+    "build_llm",
+    "get_the_explain",
+    "display_process_info"
+]