How to persist PanacheEntity avoiding duplicate key exception?

Question

I want to persist an entity. I want to skip it in case it already exists in the datastore. Assume the name field is part of the primary key. Assume p1 exists in the datastore. Only p2 should be inserted. Inserting p1 produces duplicate key exception.

@Entity
public class PersonEntity extends PanacheEntity {
    String name;    
    public PersonEntity(String name){
        this.name=name;
    }
    public static Uni<PersonEntity> findByName(String name) {
        return find("name", name).firstResult();
    }
}

@QuarkusTest
public class PersonResourceTest {
  @Test
  @ReactiveTransactional
  void persistListOfPersons() {
      List<PersonEntity> persons = List.of(new PersonEntity("p1"), new PersonEntity("p2"));
      Predicate<PersonEntity> personExists = entity -> {
        //How to consume Uni? 
        Uni<PersonEntity> entityUni = PersonEntity.findByName(entity.name);
        //entityUni.onItem().ifNull().continueWith(???);
        //include entity in filtered stream
        //return true;
        //exclude entity from filtered stream
        return false;
      };
      List<PersonEntity> filteredPersons = persons.stream().filter(personExists).toList();
      PersonEntity.persist(filteredPersons);
  }
}

I can't produce a valid filter predicate. I need a boolean value somehow produced by the person query. But how?

This should serve as a minimum reproducable example.

Answer 1

I've tried to reformat your implementation with Multi and transformToUniAndConcatenate method to save the insertion order of items.

@Test
public void fruits()
        throws Throwable {
    var persons = List.of(new Person("Frank"),
                         new Person("Jack"),
                         new Person("Frank"),
                         new Person("Jack"),
                         new Person("Steve"),
                          new Person("Steve"));

    var results = VertxContextSupport.subscribeAndAwait(() -> Panache.withTransaction(() ->
                         Multi.createFrom().iterable(persons)
                              .onItem().transformToUniAndConcatenate(f ->
                                     Person.count("name", f.name)
                                        .map(count -> count > 0)
                                        .flatMap(exists -> {
                                          if (exists) {
                                              return Uni.createFrom().item(false);
                                          } else {
                                              return Person.persist(f).replaceWith(true);
                                          }
                                        }))
                              .collect()
                              .asList()
                    )
            );
    // [true, true, false, false, true, false]
    System.out.println(results);
}