[Feature] transactional support #249

aburmeis · 2022-08-30T16:59:23Z

As mentioned in #80 this introduces a platform transaction manager based on Arango stream transactions. Do do so, all queries and the simple repository have to use options including the transaction id. As stream transactions need all collections written on creation, additional ones can be passed as labels from the @Transactional annotation.

The ArangoTransactionManager will handle each transaction as one stream transaction allowing implicit read from undeclared collections. Isolation level will be repeatable read (serialisable is not supported). All write collections have to be declared, either explicit using @Transactional(label = {"Entities", "hasEdge"}) or implicit from the first AQL WITH (will be combined as the stream transaction begin is postponed until the first query is fired). Any defined transaction timeout is used as lock timeout of the stream transaction.

The manager implements Propagation.REQUIRED and Propagation.SUPPORTS only (REQUIRED is the default). Any other will fail due to lack of suspend/resume implementation.

Transaction management is enabled the following way:

@Configuration
@EnableTransactionManagement
@Import(ArangoTransactionManagementConfigurer.class)
class ArangoTransactionSupport {
}

The typical use case would make all public methods of a service transactional read only and the mutating ones declaring the collections:

@Service
@Transactional(readOnly = true)
public class MyService {

    public Entity getById(Long id) {
        ...
    }

    @Transactional(label = {"Entities"})
    public Entity save(Entity modified) {
        ...
    }
}

You can also use programmatic transactions with support from TransactionAttributeTemplate. Either create one using DefaultTransactionAttribute or set labels before calling execute().

aburmeis · 2022-08-31T09:24:23Z

@Zyqsempai this is the contribution we offered earlier this year

aburmeis · 2022-08-31T15:29:47Z

The additional documentation can be found in a gist: spring-data-reference-repositories-transactions.md

aburmeis · 2022-09-01T14:06:07Z

@MalteJoe @jakobjoachim its on the way

rashtao · 2022-09-15T09:32:15Z

Thanks for this awesome contribution, I will review it as soon as I will have time.

rashtao

Hi @aburmeis,
as far as I can see, ArangoTransactionManager assumes that the db and all the collection involved in the transaction already exist when beginning the transaction. Unfortunately, this is not the case with the current implementation. In fact db and collections are currently initialized lazily. They are checked if exist only when the first operation upon them is performed. This behavior should change, as pointed out in #125 and all data definitions like db, collections, indexes, should be checked on startup.

A further complication derives from the fact that we should support SPEL expressions in dbs and collections names, i.e. see

spring-data/src/test/java/com/arangodb/springframework/core/mapping/MultiTenancyCollectionLevelMappingTest.java

Line 40 in 7224786

@Document("#{tenantProvider.getId()}_collection")

It should be possible checking existence of db and collections in the ArangoTransactionManager, but note that in case you need to create a collection, you should remember to dinamically evaluate the name in case it contains a SPEL expression and consider the related create options (https://github.com/arangodb/spring-data/blob/286b502d78bee5e5d5f551b4c2213238919fe625/src/main/java/com/arangodb/springframework/annotation/Document.java). To do it, you should ideally have the related entity class, see

spring-data/src/main/java/com/arangodb/springframework/core/template/ArangoTemplate.java

Lines 176 to 181 in eb46251

    
           private ArangoCollection _collection(final Class<?> entityClass, final Object id) { 
        
           	final ArangoPersistentEntity<?> persistentEntity = converter.getMappingContext() 
        
           			.getRequiredPersistentEntity(entityClass); 
        
           	final String name = determineCollectionFromId(id).orElse(persistentEntity.getCollection()); 
        
           	return _collection(name, persistentEntity, persistentEntity.getCollectionOptions()); 
        
           }

Therefore, instead of using labels strings to specify write collections of the transaction, it would be ideal having a dedicated annotation which would allow specify the entity classes directly (eg. @ArangoTransaction(writeCollections = {Actor.class, Movie.class})).

cla-bot · 2023-01-30T12:05:00Z