Transactions - read-only operations are also queued [DATAREDIS-600]

[spring-projects-issues]

Mircea Gaceanu opened DATAREDIS-600 and commented

It seems all operations inside a transaction are queued. According to the documentation the readonly operations should run a new connection (http://docs.spring.io/spring-data/redis/docs/current/reference/html/#tx.spring).
This prevents implementing "read-and-modify" transactions!

Test case throwing NPE:

 @Test
    public void testTemplateTransaction() {
        redisTemplate.opsForValue().set("foo", "bar");

        redisTemplate.multi();

        Set keys = redisTemplate.keys("*");
        Assert.assertFalse(keys.isEmpty()); // NPE

        redisTemplate.exec();
    }

Did I get something wrong here? It's too strange :-)

---

Affects: 1.8 GA (Ingalls)

[spring-projects-issues]

Mark Paluch commented

Transactional refers to @Transactional use and not programmatic transaction control. A transaction created and controlled by a PlatformTransactionManager binds the connection to the current thread and command execution determines whether a command is a read-only command and routes calls to the appropriate connection.

Transactional use looks like:

@Transactional
@Service
public class MyService {

	private StringRedisTemplate template;

	public MyService(StringRedisTemplate template) {
		this.template = template;
	}

	public void doSomething() {
		// runs on a connection that was prepared for a Redis transaction
		template.opsForValue().set("key", "value");

		// routed to a non-transactional connection
		template.keys("*");
	}
}

[spring-projects-issues]

Mircea Gaceanu commented

Thanks for the quick reply.

Actually my goal is to have @Transactional methods. But I don't know what an implementation of PlatformTransactionManager for Redis should actually do. If you could point me to a basic example, I would greatly appreciate.

From what I see, the flow would be the same in a @Transactional context:

1. Configure RedisTemplate bean in configuration class: RedisTemplate.setEnableTransactionSupport(true);
2. Execute any operation (outside transaction)

• At this point the connection will bind to the current thread
• conn = RedisConnectionUtils.bindConnection(factory, enableTransactionSupport); - RedisTemplate.execute() line 192
• Further operations will use the very same connection

3. Call @Transactional method
4. MULTI is called on the thread bounded connection

• RedisConnectionUtils.potentiallyRegisterTransactionSynchronisation()

5. Operations will be queued, because of the MULTI mode (RedisConnection.isQueuing() will return true for each operation)

[spring-projects-issues]

Mark Paluch commented

The transaction manager choice depends on your application. As soon as you use a JDBC data source, you can use DataSourceTransactionManager. Standalone apps can rely on JtaTransactionManager but require JTA. There are also specific transaction managers for WebLogic and WebSphere runtimes

[spring-projects-issues]

Mircea Gaceanu commented

As soon as there's one template operation before the transaction starts, ALL operations inside the transaction will be queued.
Please have a look at the test case from the pull request: #237