refactor(core): remove upsert entities methods and related SQL statements

ado/core/samplestore/sql.py

@@ -1139,89 +1139,6 @@ def addMeasurement(
             request_db_id=request_db_id,
         )
 
-    def upsertExperimentResults(
-        self,
-        entities: list[Entity],
-        experiment: Experiment,
-    ) -> None:
-
-        self.upsertEntities(entities, [experiment])
-
-    def upsertEntities(
-        self,
-        entities: list[Entity],
-        experiments: list[Experiment] | None = None,
-    ) -> None:
-        """Raises:
-        SystemError: If there are any errors encountered with upserting entities to SQL DB
-        """
-
-        # Local
-        for entity in entities:
-            storedEntity = self._entities.get(entity.identifier)  # type: Entity
-            if storedEntity is not None:
-                # Merge the entities property values measured here and upsert the result
-                if experiments is not None and len(experiments) != 0:
-                    for experiment in experiments:
-                        values = entity.propertyValuesFromExperiment(experiment)
-                        for v in values:
-                            storedEntity.add_measurement_result(
-                                ValidMeasurementResult(
-                                    entityIdentifier=storedEntity.identifier,
-                                    measurements=[v],
-                                )
-                            )
-                else:
-                    # if no experiments are specified we add everything.
-                    values = entity.propertyValues
-                    for v in values:
-                        if storedEntity.valueForProperty(v.property) is None:
-                            storedEntity.add_measurement_result(
-                                ValidMeasurementResult(
-                                    entityIdentifier=storedEntity.identifier,
-                                    measurements=[v],
-                                )
-                            )
-            else:
-                self._entities[entity.identifier] = entity
-
-        # Retrieve stored version of all the entities
-
-        for index in range(0, len(entities), 5000):
-            # Replace entities passed with the stored equivalent as that was the one that's updated
-            selectedEntities = [
-                self._entities[entity.identifier]
-                for entity in entities[index : index + 5000]
-            ]
-
-            values = [
-                {
-                    "identifier": e.identifier,
-                    "representation": e.model_dump_json(
-                        exclude_defaults=True, exclude_unset=True
-                    ),
-                }
-                for e in selectedEntities
-            ]
-
-            self.log.debug(f"Inserting {len(values)} entities")
-
-            try:
-                # Remote
-                with self.engine.begin() as connectable:
-                    query = ado.metastore.sql.statements.upsert_entities(
-                        sample_store_name=self._tablename,
-                        dialect=self.engine.dialect.name,
-                    )
-                    connectable.execute(query, values)
-            except SQLAlchemyError as error:
-                self.log.critical(
-                    f"Failed to upsert entity batch starting from {index}. Error: {error}"
-                )
-                raise SystemError(
-                    f"Failed to upsert entity batch starting from {index}. Error: {error}"
-                ) from error
-
     def close(self) -> None:
 
         pass

ado/metastore/sql/statements.py

@@ -487,27 +487,6 @@ def insert_entities_ignore_on_duplicate(
     return query
 
 
-def upsert_entities(
-    sample_store_name: str, dialect: Literal["mysql", "sqlite"] = "mysql"
-) -> sqlalchemy.TextClause:
-    if dialect == "sqlite":
-        query = sqlalchemy.text(rf"""
-            INSERT INTO {sample_store_name}
-            (identifier, representation)
-            VALUES (:identifier, :representation)
-            ON CONFLICT(identifier) DO UPDATE SET representation = excluded.representation
-            """)  # noqa: S608 - sample_store_name is not untrusted
-    else:
-        query = sqlalchemy.text(rf"""
-            INSERT INTO {sample_store_name}
-            (identifier, representation)
-            VALUES (:identifier, :representation)
-            ON DUPLICATE KEY UPDATE representation=values(representation)
-            """)  # noqa: S608 - sample_store_name is not untrusted
-
-    return query
-
-
 def resource_select_latest_by_kinds(
     kinds: list[str],
     dialect: Literal["mysql", "sqlite"] = "mysql",

tests/fixtures/samplestore/crud.py

@@ -57,16 +57,6 @@ def _add_entities_to_sample_store(
     return _add_entities_to_sample_store
 
 
-@pytest.fixture
-def upsert_entities_to_sample_store() -> Callable[[SQLSampleStore, list[Entity]], None]:
-    def _upsert_entities_to_sample_store(
-        sql_sample_store: SQLSampleStore, entities: list[Entity]
-    ) -> None:
-        sql_sample_store.upsertEntities(entities)
-
-    return _upsert_entities_to_sample_store
-
-
 ##################################################################
 #
 #                         READ

tests/samplestore/create/test_create.py

@@ -128,16 +128,6 @@ def test_add_entities_to_sample_store(
     add_entities_to_sample_store(random_sql_sample_store(), entities)
 
 
-def test_upsert_entities_to_sample_store(
-    random_entities: Callable[[int], list[Entity]],
-    random_sql_sample_store: Callable[[], SQLSampleStore],
-    upsert_entities_to_sample_store: Callable[[SQLSampleStore, list[Entity]], None],
-) -> None:
-    quantity = 3
-    entities = random_entities(quantity=quantity)
-    upsert_entities_to_sample_store(random_sql_sample_store(), entities)
-
-
 def test_add_measurement_request_to_sample_store(
     ml_multi_cloud_benchmark_performance_experiment: Experiment,
     random_ml_multi_cloud_benchmark_performance_measurement_requests: Callable[