from sqlalchemy.orm import sessionmaker from sqlalchemy import create_engine from typing import Type, Dict, Any from sqlalchemy.exc import IntegrityError, SQLAlchemyError from sqlalchemy.orm import Session from core.errors.logger import logger from core.models.manage.session_management import get_session from core.models.orm_models.Base import BaseModel from core.models.manage.wrapper import safe_db_operation, WrapperRollback from core.models.DatabaseOperation import DatabaseOperation, DBErrorType # all models it knows how to do: from core.models.orm_models.CachedSync import CachedSync from core.models.orm_models.Location import Location from core.models.orm_models.Operator import Operator from core.models.orm_models.Dependency import Dependency from core.models.orm_models.EncryptedProxy import EncryptedProxy from sqlalchemy import exists @safe_db_operation def verify_table_not_empty(model_class: Type, session: Session) -> DatabaseOperation: """Checks if the table contains at least one record.""" return session.query(exists().select_from(model_class)).scalar() # This is the main public interface, def insert_into_model(model_class: Type, all_data: dict | list, override=False) -> DatabaseOperation: """ Purpose: Generic ORM insert for any model. Keeping it generic for reuse. Args: model_class: The ORM model class all_data: Dictionary or list of dictionaries with data matching the model override: If True, wipe the table before inserting Returns: DatabaseOperation object with true/false """ # Normalize to list for uniform handling data_list = all_data if isinstance(all_data, list) else [all_data] # Call the wrapped function with normalized data inserted = _wrapped_insert(model_class=model_class, data_list=data_list, override=override) if not inserted.valid: return inserted not_blank = verify_table_not_empty(model_class) if not not_blank: error_type = "Although it initally inserted, it returned blank." logger.error(error_type) return DatabaseOperation(valid=False, error_type=DBErrorType.UNKNOWN, message=error_type) logger.info("Confirmed it's not blank") return inserted @safe_db_operation def _wrapped_insert(model_class: Type, data_list: dict | list, session: Session, override=False) -> DatabaseOperation: """Insert items. Doesn't manage session. It's managed by the wrapper safe_db_operation""" if not data_list: error_msg = f"Critical error with Insert: There's blank data_list for {model_class}." logger.error(error_msg) return DatabaseOperation( valid=False, error_type=DBErrorType.MISSING_DATA, message=error_msg ) if override: logger.info(f"First, WIPING the pre-existing data for {model_class.__name__}. Are you sure you intended to completely delete the old data?") session.query(model_class).delete() logger.info(f"Starting insert for {model_class.__name__}") # Get valid field names upfront valid_fields = {col.name for col in model_class.__table__.columns} logger.info(f"valid_fields are {valid_fields}") # Filter data proactively filtered_data_list = [] all_dropped_fields = set() for each_json in data_list: filtered_json = {k: v for k, v in each_json.items() if k in valid_fields} filtered_data_list.append(filtered_json) # Track dropped fields dropped = set(each_json.keys()) - valid_fields all_dropped_fields.update(dropped) # Log if we dropped anything if all_dropped_fields: logger.info(f"Filtered unknown fields before insert: {all_dropped_fields}") try: for filtered_json in filtered_data_list: logger.info(f"inserting {filtered_json}") instance = model_class(**filtered_json) session.add(instance) session.commit() logger.info("Finished wrapped insert!") return DatabaseOperation( valid=True, tried_filtered=bool(all_dropped_fields), message=f"Inserted successfully" + (f" after filtering {all_dropped_fields}" if all_dropped_fields else "") ) except Exception as e: # Unexpected error during insert session.rollback() raise WrapperRollback(DatabaseOperation( valid=False, error_type=DBErrorType.UNKNOWN, message=f"Wrapped Insert Failed: {str(e)}" )) # =================== Isolation Test ====================== """ Spoof Failure of an operational error to trigger/test a migration """ # from sqlalchemy import text # # 1. Drop a column the model expects # if model_class == Location: # with get_session() as session: # print("dropping provider_name from location..") # session.execute(text("ALTER TABLE locations DROP COLUMN provider_name")) # session.commit() # print("dropped provider_name from location!!!") # # 2. Now insert will trigger OperationalError