How to do transaction without have to write it in Lua?

[kokizzu]

https://www.tarantool.io/en/doc/latest/book/box/atomic/

[funny-falcon]

Afaik there is no way for external transaction.

[Totktonada]

Now we have the interactive transactions support on the server side: tarantool/tarantool#2016. So it worth to implement in the connector.

A brief protocol description is here: tarantool/doc#2310.

net.box API as a reference: tarantool/doc#2311.

[AnaNek]

The proposed API for this feature is the following:

1. Add method to create a stream object for Connection and ConnectionPool, method for Connection doesn't get any parameters, method for ConnectionPool get mode parameter.

func (conn *Connection) NewStream() (*Stream, error);
func (connPool *ConnectionPool) NewStream(userMode Mode) (*Stream, error);

2. Implement Stream object with the Do(), DoTyped(), DoAsync() to work with request objects and add Begin(), Commit(), Rollback() methods.
   Begin() - start transaction via iproto stream.
   Commit() - commit transaction.
   Rollback() - rollback transaction.

Use case example:

package main

import (
        "fmt"
        "log"

        "github.com/tarantool/go-tarantool"
)

func main() {
        conn, err := Connect(server, opts)
        if err != nil {
	    fmt.Printf("Failed to connect: %s", err.Error())
            return
        }
        if conn == nil {
	    fmt.Printf("conn is nil after Connect")
            return
        }
        defer conn.Close()

        stream, err := conn.NewStream()
        if err != nil {
	    fmt.Printf("Failed to create stream: %s", err.Error())
            return
        }
        if stream == nil {
	    fmt.Printf("stream is nil after NewStream")
            return
        }

        // Begin transaction
	resp, err = stream.Begin()
	if err != nil {
		fmt.Printf("Failed to Begin: %s", err.Error())
		return
	}
	fmt.Printf("Begin transaction:response is %#v\n", resp.Code)

	// Insert in stream
	req = tarantool.NewInsertRequest(spaceName).
		Tuple([]interface{}{uint(1001), "hello2", "world2"})
	resp, err = stream.Do(req)
	if err != nil {
		fmt.Printf("Failed to Insert: %s", err.Error())
		return
	}
	fmt.Printf("Insert in stream:response is %#v\n", resp.Code)

	// Select not related to the transaction
	// while transaction is not commited
	// result of select is empty
	req = tarantool.NewSelectRequest(spaceNo).
		Index(indexNo).
		Offset(0).
		Limit(1).
		Iterator(tarantool.IterEq).
		Key([]interface{}{uint(1001)})
	resp, err = conn.Do(req)
	if err != nil {
		fmt.Printf("Failed to Select: %s", err.Error())
		return
	}
	fmt.Printf("Select out of stream:response is %#v\n", resp.Data)

	// Select in stream
	req = tarantool.NewSelectRequest(spaceNo).
		Index(indexNo).
		Offset(0).
		Limit(1).
		Iterator(tarantool.IterEq).
		Key([]interface{}{uint(1001)})
	resp, err = stream.Do(req)
	if err != nil {
		fmt.Printf("Failed to Select: %s", err.Error())
		return
	}
	fmt.Printf("Select in stream:response is %#v\n", resp.Data)

	// Commit transaction
	resp, err = stream.Commit()
	if err != nil {
		fmt.Printf("Failed to Commit: %s", err.Error())
		return
	}
	fmt.Printf("Commit transaction:response is %#v\n", resp.Code)

	// Select outside of transaction
	req = tarantool.NewSelectRequest(spaceNo).
		Index(indexNo).
		Offset(0).
		Limit(1).
		Iterator(tarantool.IterEq).
		Key([]interface{}{uint(1001)})
	resp, err = conn.Do(req)
	if err != nil {
		fmt.Printf("Failed to Select: %s", err.Error())
		return
	}
	fmt.Printf("Select after commit:response is %#v\n", resp.Data)
}