connection_pool

package
v1.9.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 2, 2022 License: BSD-2-Clause Imports: 7 Imported by: 1

Documentation

Overview

Package with methods to work with a Tarantool cluster considering master discovery.

Main features:

- Return available connection from pool according to round-robin strategy.

- Automatic master discovery by mode parameter.

Since: 1.6.0

Index

Examples

Constants

This section is empty.

Variables

View Source 
var (
	ErrEmptyAddrs        = errors.New("addrs (first argument) should not be empty")
	ErrWrongCheckTimeout = errors.New("wrong check timeout, must be greater than 0")
	ErrNoConnection      = errors.New("no active connections")
	ErrTooManyArgs       = errors.New("too many arguments")
	ErrIncorrectResponse = errors.New("incorrect response format")
	ErrIncorrectStatus   = errors.New("incorrect instance status: status should be `running`")
	ErrNoRwInstance      = errors.New("can't find rw instance in pool")
	ErrNoRoInstance      = errors.New("can't find ro instance in pool")
	ErrNoHealthyInstance = errors.New("can't find healthy instance in pool")
)

Functions

This section is empty.

Types

type ConnectionHandler added in v1.9.0 

type ConnectionHandler interface {
	// Discovered is called when a connection with a role has been detected
	// (for the first time or when a role of a connection has been changed),
	// but is not yet available to send requests. It allows for a client to
	// initialize the connection before using it in a pool.
	//
	// The client code may cancel adding a connection to the pool. The client
	// need to return an error from the Discovered call for that. In this case
	// the pool will close connection and will try to reopen it later.
	Discovered(conn *tarantool.Connection, role Role) error
	// Deactivated is called when a connection with a role has become
	// unavaileble to send requests. It happens if the connection is closed or
	// the connection role is switched.
	//
	// So if a connection switches a role, a pool calls:
	// Deactivated() + Discovered().
	//
	// Deactivated will not be called if a previous Discovered() call returns
	// an error. Because in this case, the connection does not become available
	// for sending requests.
	Deactivated(conn *tarantool.Connection, role Role) error
}

ConnectionHandler provides callbacks for components interested in handling changes of connections in a ConnectionPool.

type ConnectionInfo 

type ConnectionInfo struct {
	ConnectedNow bool
	ConnRole     Role
}

ConnectionInfo structure for information about connection statuses:

- ConnectedNow reports if connection is established at the moment.

- ConnRole reports master/replica role of instance.

type ConnectionPool 

type ConnectionPool struct {
	// contains filtered or unexported fields
}

Main features:

- Return available connection from pool according to round-robin strategy.

- Automatic master discovery by mode parameter.

func Connect 

func Connect(addrs []string, connOpts tarantool.Opts) (connPool *ConnectionPool, err error)

ConnectWithOpts creates pool for instances with addresses addrs.

func ConnectWithOpts 

func ConnectWithOpts(addrs []string, connOpts tarantool.Opts, opts OptsPool) (connPool *ConnectionPool, err error)

ConnectWithOpts creates pool for instances with addresses addrs with options opts.

func (*ConnectionPool) Call 

func (connPool *ConnectionPool) Call(functionName string, args interface{}, userMode Mode) (resp *tarantool.Response, err error)

Call16 calls registered Tarantool function. It uses request code for Tarantool >= 1.7 if go-tarantool was build with go_tarantool_call_17 tag. Otherwise, uses request code for Tarantool 1.6.

Example 
pool, err := examplePool(testRoles)
if err != nil {
	fmt.Println(err)
}
defer pool.Close()

// Call a function 'simple_incr' with arguments.
resp, err := pool.Call17("simple_incr", []interface{}{1}, connection_pool.PreferRW)
fmt.Println("Call simple_incr()")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)

Output:

Call simple_incr()
Error <nil>
Code 0
Data [2]

func (*ConnectionPool) Call16 added in v1.7.0 

func (connPool *ConnectionPool) Call16(functionName string, args interface{}, userMode Mode) (resp *tarantool.Response, err error)

Call16 calls registered Tarantool function. It uses request code for Tarantool 1.6, so result is converted to array of arrays. Deprecated since Tarantool 1.7.2.

func (*ConnectionPool) Call16Async added in v1.7.0 

func (connPool *ConnectionPool) Call16Async(functionName string, args interface{}, userMode Mode) *tarantool.Future

Call16Async sends a call to registered Tarantool function and returns Future. It uses request code for Tarantool 1.6, so future's result is always array of arrays. Deprecated since Tarantool 1.7.2.

func (*ConnectionPool) Call16Typed added in v1.7.0 

func (connPool *ConnectionPool) Call16Typed(functionName string, args interface{}, result interface{}, userMode Mode) (err error)

Call16Typed calls registered function. It uses request code for Tarantool 1.6, so result is converted to array of arrays. Deprecated since Tarantool 1.7.2.

func (*ConnectionPool) Call17 

func (connPool *ConnectionPool) Call17(functionName string, args interface{}, userMode Mode) (resp *tarantool.Response, err error)

Call17 calls registered Tarantool function. It uses request code for Tarantool >= 1.7, so result is not converted (though, keep in mind, result is always array).

func (*ConnectionPool) Call17Async 

func (connPool *ConnectionPool) Call17Async(functionName string, args interface{}, userMode Mode) *tarantool.Future

Call17Async sends a call to registered Tarantool function and returns Future. It uses request code for Tarantool >= 1.7, so future's result will not be converted (though, keep in mind, result is always array).

func (*ConnectionPool) Call17Typed 

func (connPool *ConnectionPool) Call17Typed(functionName string, args interface{}, result interface{}, userMode Mode) (err error)

Call17Typed calls registered function. It uses request code for Tarantool >= 1.7, so result is not converted (though, keep in mind, result is always array).

func (*ConnectionPool) CallAsync 

func (connPool *ConnectionPool) CallAsync(functionName string, args interface{}, userMode Mode) *tarantool.Future

CallAsync sends a call to registered Tarantool function and returns Future. It uses request code for Tarantool >= 1.7 if go-tarantool was build with go_tarantool_call_17 tag. Otherwise, uses request code for Tarantool 1.6.

func (*ConnectionPool) CallTyped 

func (connPool *ConnectionPool) CallTyped(functionName string, args interface{}, result interface{}, userMode Mode) (err error)

CallTyped calls registered function. It uses request code for Tarantool >= 1.7 if go-tarantool was build with go_tarantool_call_17 tag. Otherwise, uses request code for Tarantool 1.6.

func (*ConnectionPool) Close 

func (connPool *ConnectionPool) Close() []error

Close closes connections in pool.

func (*ConnectionPool) ConfiguredTimeout 

func (connPool *ConnectionPool) ConfiguredTimeout(mode Mode) (time.Duration, error)

ConfiguredTimeout gets timeout of current connection.

func (*ConnectionPool) ConnectedNow 

func (connPool *ConnectionPool) ConnectedNow(mode Mode) (bool, error)

ConnectedNow gets connected status of pool.

func (*ConnectionPool) Delete 

func (connPool *ConnectionPool) Delete(space, index interface{}, key interface{}, userMode ...Mode) (resp *tarantool.Response, err error)

Delete performs deletion of a tuple by key. Result will contain array with deleted tuple.

Example 
pool, err := examplePool(testRoles)
if err != nil {
	fmt.Println(err)
}
defer pool.Close()

// Connect to servers[2] to check if tuple
// was inserted on RW instance
conn, err := tarantool.Connect(servers[2], connOpts)
if err != nil || conn == nil {
	fmt.Printf("failed to connect to %s", servers[2])
	return
}

// Insert a new tuple {"key1", "value1"}.
_, err = conn.Insert(spaceNo, []interface{}{"key1", "value1"})
if err != nil {
	fmt.Printf("Failed to insert: %s", err.Error())
	return
}
// Insert a new tuple {"key2", "value2"}.
_, err = conn.Insert(spaceNo, []interface{}{"key2", "value2"})
if err != nil {
	fmt.Printf("Failed to insert: %s", err.Error())
	return
}

// Delete tuple with primary key {"key1"}.
resp, err := pool.Delete(spaceNo, indexNo, []interface{}{"key1"})
fmt.Println("Delete key1")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)

// Delete tuple with primary key { "key2" }.
resp, err = pool.Delete(spaceName, indexName, []interface{}{"key2"}, connection_pool.PreferRW)
fmt.Println("Delete key2")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)

Output:

Delete key1
Error <nil>
Code 0
Data [[key1 value1]]
Delete key2
Error <nil>
Code 0
Data [[key2 value2]]

func (*ConnectionPool) DeleteAsync 

func (connPool *ConnectionPool) DeleteAsync(space, index interface{}, key interface{}, userMode ...Mode) *tarantool.Future

DeleteAsync sends deletion action to Tarantool and returns Future. Future's result will contain array with deleted tuple.

func (*ConnectionPool) DeleteTyped 

func (connPool *ConnectionPool) DeleteTyped(space, index interface{}, key interface{}, result interface{}, userMode ...Mode) (err error)

DeleteTyped performs deletion of a tuple by key and fills result with deleted tuple.

func (*ConnectionPool) Do added in v1.7.0 

func (connPool *ConnectionPool) Do(req tarantool.Request, userMode Mode) *tarantool.Future

Do sends the request and returns a future. For requests that belong to an only one connection (e.g. Unprepare or ExecutePrepared) the argument of type Mode is unused.

Example 
pool, err := examplePool(testRoles)
if err != nil {
	fmt.Println(err)
}
defer pool.Close()

// Ping a Tarantool instance to check connection.
req := tarantool.NewPingRequest()
resp, err := pool.Do(req, connection_pool.ANY).Get()
fmt.Println("Ping Code", resp.Code)
fmt.Println("Ping Data", resp.Data)
fmt.Println("Ping Error", err)

Output:

Ping Code 0
Ping Data []
Ping Error <nil>

func (*ConnectionPool) Eval 

func (connPool *ConnectionPool) Eval(expr string, args interface{}, userMode Mode) (resp *tarantool.Response, err error)

Eval passes lua expression for evaluation.

Example 
pool, err := examplePool(testRoles)
if err != nil {
	fmt.Println(err)
}
defer pool.Close()

// Run raw Lua code.
resp, err := pool.Eval("return 1 + 2", []interface{}{}, connection_pool.PreferRW)
fmt.Println("Eval 'return 1 + 2'")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)

Output:

Eval 'return 1 + 2'
Error <nil>
Code 0
Data [3]

func (*ConnectionPool) EvalAsync 

func (connPool *ConnectionPool) EvalAsync(expr string, args interface{}, userMode Mode) *tarantool.Future

EvalAsync sends a lua expression for evaluation and returns Future.

func (*ConnectionPool) EvalTyped 

func (connPool *ConnectionPool) EvalTyped(expr string, args interface{}, result interface{}, userMode Mode) (err error)

EvalTyped passes lua expression for evaluation.

func (*ConnectionPool) Execute added in v1.9.0 

func (connPool *ConnectionPool) Execute(expr string, args interface{}, userMode Mode) (resp *tarantool.Response, err error)

Execute passes sql expression to Tarantool for execution.

func (*ConnectionPool) ExecuteAsync added in v1.9.0 

func (connPool *ConnectionPool) ExecuteAsync(expr string, args interface{}, userMode Mode) *tarantool.Future

ExecuteAsync sends sql expression to Tarantool for execution and returns Future.

func (*ConnectionPool) ExecuteTyped added in v1.9.0 

func (connPool *ConnectionPool) ExecuteTyped(expr string, args interface{}, result interface{}, userMode Mode) (tarantool.SQLInfo, []tarantool.ColumnMetaData, error)

ExecuteTyped passes sql expression to Tarantool for execution.

func (*ConnectionPool) GetAddrs 

func (connPool *ConnectionPool) GetAddrs() []string

GetAddrs gets addresses of connections in pool.

func (*ConnectionPool) GetPoolInfo 

func (connPool *ConnectionPool) GetPoolInfo() map[string]*ConnectionInfo

GetPoolInfo gets information of connections (connected status, ro/rw role).

func (*ConnectionPool) GetTyped 

func (connPool *ConnectionPool) GetTyped(space, index interface{}, key interface{}, result interface{}, userMode ...Mode) (err error)

GetTyped performs select (with limit = 1 and offset = 0) to box space and fills typed result.

func (*ConnectionPool) Insert 

func (connPool *ConnectionPool) Insert(space interface{}, tuple interface{}, userMode ...Mode) (resp *tarantool.Response, err error)

Insert performs insertion to box space. Tarantool will reject Insert when tuple with same primary key exists.

Example 
pool, err := examplePool(testRoles)
if err != nil {
	fmt.Println(err)
}
defer pool.Close()

// Insert a new tuple {"key1", "value1"}.
resp, err := pool.Insert(spaceNo, []interface{}{"key1", "value1"})
fmt.Println("Insert key1")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)
// Insert a new tuple {"key2", "value2"}.
resp, err = pool.Insert(spaceName, &Tuple{Key: "key2", Value: "value2"}, connection_pool.PreferRW)
fmt.Println("Insert key2")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)

// Connect to servers[2] to check if tuple
// was inserted on RW instance
conn, err := tarantool.Connect(servers[2], connOpts)
if err != nil || conn == nil {
	fmt.Printf("failed to connect to %s", servers[2])
	return
}

// Delete tuple with primary key "key1".
_, err = conn.Delete(spaceName, indexName, []interface{}{"key1"})
if err != nil {
	fmt.Printf("Failed to delete: %s", err.Error())
}
// Delete tuple with primary key "key2".
_, err = conn.Delete(spaceNo, indexNo, []interface{}{"key2"})
if err != nil {
	fmt.Printf("Failed to delete: %s", err.Error())
}

Output:

Insert key1
Error <nil>
Code 0
Data [[key1 value1]]
Insert key2
Error <nil>
Code 0
Data [[key2 value2]]

func (*ConnectionPool) InsertAsync 

func (connPool *ConnectionPool) InsertAsync(space interface{}, tuple interface{}, userMode ...Mode) *tarantool.Future

InsertAsync sends insert action to Tarantool and returns Future. Tarantool will reject Insert when tuple with same primary key exists.

func (*ConnectionPool) InsertTyped 

func (connPool *ConnectionPool) InsertTyped(space interface{}, tuple interface{}, result interface{}, userMode ...Mode) (err error)

InsertTyped performs insertion to box space. Tarantool will reject Insert when tuple with same primary key exists.

func (*ConnectionPool) NewPrepared added in v1.7.0 

func (connPool *ConnectionPool) NewPrepared(expr string, userMode Mode) (*tarantool.Prepared, error)

NewPrepared passes a sql statement to Tarantool for preparation synchronously.

Example 
pool, err := examplePool(testRoles)
if err != nil {
	fmt.Println(err)
}
defer pool.Close()

stmt, err := pool.NewPrepared("SELECT 1", connection_pool.ANY)
if err != nil {
	fmt.Println(err)
}

executeReq := tarantool.NewExecutePreparedRequest(stmt)
unprepareReq := tarantool.NewUnprepareRequest(stmt)

_, err = pool.Do(executeReq, connection_pool.ANY).Get()
if err != nil {
	fmt.Printf("Failed to execute prepared stmt")
}
_, err = pool.Do(unprepareReq, connection_pool.ANY).Get()
if err != nil {
	fmt.Printf("Failed to prepare")
}

func (*ConnectionPool) NewStream added in v1.7.0 

func (connPool *ConnectionPool) NewStream(userMode Mode) (*tarantool.Stream, error)

NewStream creates new Stream object for connection selected by userMode from connPool.

Since v. 2.10.0, Tarantool supports streams and interactive transactions over them. To use interactive transactions, memtx_use_mvcc_engine box option should be set to true. Since 1.7.0

func (*ConnectionPool) Ping 

func (connPool *ConnectionPool) Ping(userMode Mode) (*tarantool.Response, error)

Ping sends empty request to Tarantool to check connection.

Example 
pool, err := examplePool(testRoles)
if err != nil {
	fmt.Println(err)
}
defer pool.Close()

// Ping a Tarantool instance to check connection.
resp, err := pool.Ping(connection_pool.ANY)
fmt.Println("Ping Code", resp.Code)
fmt.Println("Ping Data", resp.Data)
fmt.Println("Ping Error", err)

Output:

Ping Code 0
Ping Data []
Ping Error <nil>

func (*ConnectionPool) Replace 

func (connPool *ConnectionPool) Replace(space interface{}, tuple interface{}, userMode ...Mode) (resp *tarantool.Response, err error)

Replace performs "insert or replace" action to box space. If tuple with same primary key exists, it will be replaced.

Example 
pool, err := examplePool(testRoles)
if err != nil {
	fmt.Println(err)
}
defer pool.Close()

// Connect to servers[2] to check if tuple
// was inserted on RW instance
conn, err := tarantool.Connect(servers[2], connOpts)
if err != nil || conn == nil {
	fmt.Printf("failed to connect to %s", servers[2])
	return
}

// Insert a new tuple {"key1", "value1"}.
_, err = conn.Insert(spaceNo, []interface{}{"key1", "value1"})
if err != nil {
	fmt.Printf("Failed to insert: %s", err.Error())
	return
}

// Replace a tuple with primary key ""key1.
// Note, Tuple is defined within tests, and has EncdodeMsgpack and
// DecodeMsgpack methods.
resp, err := pool.Replace(spaceNo, []interface{}{"key1", "new_value"})
fmt.Println("Replace key1")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)
resp, err = pool.Replace(spaceName, []interface{}{"key1", "another_value"})
fmt.Println("Replace key1")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)
resp, err = pool.Replace(spaceName, &Tuple{Key: "key1", Value: "value2"})
fmt.Println("Replace key1")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)
resp, err = pool.Replace(spaceName, &Tuple{Key: "key1", Value: "new_value2"}, connection_pool.PreferRW)
fmt.Println("Replace key1")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)

// Delete tuple with primary key "key1".
_, err = conn.Delete(spaceName, indexName, []interface{}{"key1"})
if err != nil {
	fmt.Printf("Failed to delete: %s", err.Error())
}

Output:

Replace key1
Error <nil>
Code 0
Data [[key1 new_value]]
Replace key1
Error <nil>
Code 0
Data [[key1 another_value]]
Replace key1
Error <nil>
Code 0
Data [[key1 value2]]
Replace key1
Error <nil>
Code 0
Data [[key1 new_value2]]

func (*ConnectionPool) ReplaceAsync 

func (connPool *ConnectionPool) ReplaceAsync(space interface{}, tuple interface{}, userMode ...Mode) *tarantool.Future

ReplaceAsync sends "insert or replace" action to Tarantool and returns Future. If tuple with same primary key exists, it will be replaced.

func (*ConnectionPool) ReplaceTyped 

func (connPool *ConnectionPool) ReplaceTyped(space interface{}, tuple interface{}, result interface{}, userMode ...Mode) (err error)

ReplaceTyped performs "insert or replace" action to box space. If tuple with same primary key exists, it will be replaced.

func (*ConnectionPool) Select 

func (connPool *ConnectionPool) Select(space, index interface{}, offset, limit, iterator uint32, key interface{}, userMode ...Mode) (resp *tarantool.Response, err error)

Select performs select to box space.

Example 
pool, err := examplePool(testRoles)
if err != nil {
	fmt.Println(err)
}
defer pool.Close()

// Connect to servers[2] to check if tuple
// was inserted on RW instance
conn, err := tarantool.Connect(servers[2], connOpts)
if err != nil || conn == nil {
	fmt.Printf("failed to connect to %s", servers[2])
	return
}

// Insert a new tuple {"key1", "value1"}.
_, err = conn.Insert(spaceNo, []interface{}{"key1", "value1"})
if err != nil {
	fmt.Printf("Failed to insert: %s", err.Error())
	return
}
// Insert a new tuple {"key2", "value2"}.
_, err = conn.Insert(spaceName, &Tuple{Key: "key2", Value: "value2"})
if err != nil {
	fmt.Printf("Failed to insert: %s", err.Error())
	return
}

resp, err := pool.Select(
	spaceNo, indexNo, 0, 100, tarantool.IterEq,
	[]interface{}{"key1"}, connection_pool.PreferRW)
if err != nil {
	fmt.Printf("error in select is %v", err)
	return
}
fmt.Printf("response is %#v\n", resp.Data)
resp, err = pool.Select(
	spaceNo, indexNo, 0, 100, tarantool.IterEq,
	[]interface{}{"key2"}, connection_pool.PreferRW)
if err != nil {
	fmt.Printf("error in select is %v", err)
	return
}
fmt.Printf("response is %#v\n", resp.Data)

// Delete tuple with primary key "key1".
_, err = conn.Delete(spaceName, indexName, []interface{}{"key1"})
if err != nil {
	fmt.Printf("Failed to delete: %s", err.Error())
}
// Delete tuple with primary key "key2".
_, err = conn.Delete(spaceNo, indexNo, []interface{}{"key2"})
if err != nil {
	fmt.Printf("Failed to delete: %s", err.Error())
}

Output:

response is []interface {}{[]interface {}{"key1", "value1"}}
response is []interface {}{[]interface {}{"key2", "value2"}}

func (*ConnectionPool) SelectAsync 

func (connPool *ConnectionPool) SelectAsync(space, index interface{}, offset, limit, iterator uint32, key interface{}, userMode ...Mode) *tarantool.Future

SelectAsync sends select request to Tarantool and returns Future.

Example 
pool, err := examplePool(testRoles)
if err != nil {
	fmt.Println(err)
}
defer pool.Close()

// Connect to servers[2] to check if tuple
// was inserted on RW instance
conn, err := tarantool.Connect(servers[2], connOpts)
if err != nil || conn == nil {
	fmt.Printf("failed to connect to %s", servers[2])
	return
}

// Insert a new tuple {"key1", "value1"}.
_, err = conn.Insert(spaceNo, []interface{}{"key1", "value1"})
if err != nil {
	fmt.Printf("Failed to insert: %s", err.Error())
	return
}
// Insert a new tuple {"key2", "value2"}.
_, err = conn.Insert(spaceName, &Tuple{Key: "key2", Value: "value2"})
if err != nil {
	fmt.Printf("Failed to insert: %s", err.Error())
	return
}
// Insert a new tuple {"key3", "value3"}.
_, err = conn.Insert(spaceNo, []interface{}{"key3", "value3"})
if err != nil {
	fmt.Printf("Failed to insert: %s", err.Error())
	return
}

var futs [3]*tarantool.Future
futs[0] = pool.SelectAsync(
	spaceName, indexName, 0, 2, tarantool.IterEq,
	[]interface{}{"key1"}, connection_pool.PreferRW)
futs[1] = pool.SelectAsync(
	spaceName, indexName, 0, 1, tarantool.IterEq,
	[]interface{}{"key2"}, connection_pool.RW)
futs[2] = pool.SelectAsync(
	spaceName, indexName, 0, 1, tarantool.IterEq,
	[]interface{}{"key3"}, connection_pool.RW)
var t []Tuple
err = futs[0].GetTyped(&t)
fmt.Println("Future", 0, "Error", err)
fmt.Println("Future", 0, "Data", t)

resp, err := futs[1].Get()
fmt.Println("Future", 1, "Error", err)
fmt.Println("Future", 1, "Data", resp.Data)

resp, err = futs[2].Get()
fmt.Println("Future", 2, "Error", err)
fmt.Println("Future", 2, "Data", resp.Data)

// Delete tuple with primary key "key1".
_, err = conn.Delete(spaceName, indexName, []interface{}{"key1"})
if err != nil {
	fmt.Printf("Failed to delete: %s", err.Error())
}
// Delete tuple with primary key "key2".
_, err = conn.Delete(spaceNo, indexNo, []interface{}{"key2"})
if err != nil {
	fmt.Printf("Failed to delete: %s", err.Error())
}
// Delete tuple with primary key "key3".
_, err = conn.Delete(spaceNo, indexNo, []interface{}{"key3"})
if err != nil {
	fmt.Printf("Failed to delete: %s", err.Error())
}

Output:

Future 0 Error <nil>
Future 0 Data [{{} key1 value1}]
Future 1 Error <nil>
Future 1 Data [[key2 value2]]
Future 2 Error <nil>
Future 2 Data [[key3 value3]]
Example (Err) 
roles := []bool{true, true, true, true, true}
pool, err := examplePool(roles)
if err != nil {
	fmt.Println(err)
}
defer pool.Close()

var futs [3]*tarantool.Future
futs[0] = pool.SelectAsync(
	spaceName, indexName, 0, 2, tarantool.IterEq,
	[]interface{}{"key1"}, connection_pool.RW)

err = futs[0].Err()
fmt.Println("Future", 0, "Error", err)

Output:

Future 0 Error can't find rw instance in pool

func (*ConnectionPool) SelectTyped 

func (connPool *ConnectionPool) SelectTyped(space, index interface{}, offset, limit, iterator uint32, key interface{}, result interface{}, userMode ...Mode) (err error)

SelectTyped performs select to box space and fills typed result.

Example 
pool, err := examplePool(testRoles)
if err != nil {
	fmt.Println(err)
}
defer pool.Close()

// Connect to servers[2] to check if tuple
// was inserted on RW instance
conn, err := tarantool.Connect(servers[2], connOpts)
if err != nil || conn == nil {
	fmt.Printf("failed to connect to %s", servers[2])
	return
}

// Insert a new tuple {"key1", "value1"}.
_, err = conn.Insert(spaceNo, []interface{}{"key1", "value1"})
if err != nil {
	fmt.Printf("Failed to insert: %s", err.Error())
	return
}
// Insert a new tuple {"key2", "value2"}.
_, err = conn.Insert(spaceName, &Tuple{Key: "key2", Value: "value2"})
if err != nil {
	fmt.Printf("Failed to insert: %s", err.Error())
	return
}

var res []Tuple
err = pool.SelectTyped(
	spaceNo, indexNo, 0, 100, tarantool.IterEq,
	[]interface{}{"key1"}, &res, connection_pool.PreferRW)
if err != nil {
	fmt.Printf("error in select is %v", err)
	return
}
fmt.Printf("response is %v\n", res)
err = pool.SelectTyped(
	spaceName, indexName, 0, 100, tarantool.IterEq,
	[]interface{}{"key2"}, &res, connection_pool.PreferRW)
if err != nil {
	fmt.Printf("error in select is %v", err)
	return
}
fmt.Printf("response is %v\n", res)

// Delete tuple with primary key "key1".
_, err = conn.Delete(spaceName, indexName, []interface{}{"key1"})
if err != nil {
	fmt.Printf("Failed to delete: %s", err.Error())
}
// Delete tuple with primary key "key2".
_, err = conn.Delete(spaceNo, indexNo, []interface{}{"key2"})
if err != nil {
	fmt.Printf("Failed to delete: %s", err.Error())
}

Output:

response is [{{} key1 value1}]
response is [{{} key2 value2}]

func (*ConnectionPool) Update 

func (connPool *ConnectionPool) Update(space, index interface{}, key, ops interface{}, userMode ...Mode) (resp *tarantool.Response, err error)

Update performs update of a tuple by key. Result will contain array with updated tuple.

Example 
pool, err := examplePool(testRoles)
if err != nil {
	fmt.Println(err)
}
defer pool.Close()

// Connect to servers[2] to check if tuple
// was inserted on RW instance
conn, err := tarantool.Connect(servers[2], connOpts)
if err != nil || conn == nil {
	fmt.Printf("failed to connect to %s", servers[2])
	return
}

// Insert a new tuple {"key1", "value1"}.
_, err = conn.Insert(spaceNo, []interface{}{"key1", "value1"})
if err != nil {
	fmt.Printf("Failed to insert: %s", err.Error())
	return
}

// Update tuple with primary key { "key1" }.
resp, err := pool.Update(
	spaceName, indexName, []interface{}{"key1"},
	[]interface{}{[]interface{}{"=", 1, "new_value"}}, connection_pool.PreferRW)
fmt.Println("Update key1")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)

// Delete tuple with primary key "key1".
_, err = conn.Delete(spaceName, indexName, []interface{}{"key1"})
if err != nil {
	fmt.Printf("Failed to delete: %s", err.Error())
}

Output:

Update key1
Error <nil>
Code 0
Data [[key1 new_value]]

func (*ConnectionPool) UpdateAsync 

func (connPool *ConnectionPool) UpdateAsync(space, index interface{}, key, ops interface{}, userMode ...Mode) *tarantool.Future

UpdateAsync sends deletion of a tuple by key and returns Future. Future's result will contain array with updated tuple.

func (*ConnectionPool) UpdateTyped 

func (connPool *ConnectionPool) UpdateTyped(space, index interface{}, key, ops interface{}, result interface{}, userMode ...Mode) (err error)

UpdateTyped performs update of a tuple by key and fills result with updated tuple.

func (*ConnectionPool) Upsert 

func (connPool *ConnectionPool) Upsert(space interface{}, tuple, ops interface{}, userMode ...Mode) (resp *tarantool.Response, err error)

Upsert performs "update or insert" action of a tuple by key. Result will not contain any tuple.

func (*ConnectionPool) UpsertAsync 

func (connPool *ConnectionPool) UpsertAsync(space interface{}, tuple interface{}, ops interface{}, userMode ...Mode) *tarantool.Future

UpsertAsync sends "update or insert" action to Tarantool and returns Future. Future's sesult will not contain any tuple.

type ConnectorAdapter added in v1.9.0 

type ConnectorAdapter struct {
	// contains filtered or unexported fields
}

ConnectorAdapter allows to use Pooler as Connector.

Example 
pool, err := examplePool(testRoles)
if err != nil {
	fmt.Println(err)
}
defer pool.Close()

adapter := connection_pool.NewConnectorAdapter(pool, connection_pool.RW)
var connector tarantool.Connector = adapter

// Ping an RW instance to check connection.
resp, err := connector.Ping()
fmt.Println("Ping Code", resp.Code)
fmt.Println("Ping Data", resp.Data)
fmt.Println("Ping Error", err)

Output:

Ping Code 0
Ping Data []
Ping Error <nil>

func NewConnectorAdapter added in v1.9.0 

func NewConnectorAdapter(pool Pooler, mode Mode) *ConnectorAdapter

NewConnectorAdapter creates a new ConnectorAdapter object for a pool and with a mode. All requests to the pool will be executed in the specified mode.

func (*ConnectorAdapter) Call added in v1.9.0 

func (c *ConnectorAdapter) Call(functionName string,
	args interface{}) (*tarantool.Response, error)

Call calls registered Tarantool function. It uses request code for Tarantool >= 1.7 if go-tarantool was build with go_tarantool_call_17 tag. Otherwise, uses request code for Tarantool 1.6.

func (*ConnectorAdapter) Call16 added in v1.9.0 

func (c *ConnectorAdapter) Call16(functionName string,
	args interface{}) (*tarantool.Response, error)

Call16 calls registered Tarantool function. It uses request code for Tarantool 1.6, so result is converted to array of arrays Deprecated since Tarantool 1.7.2.

func (*ConnectorAdapter) Call16Async added in v1.9.0 

func (c *ConnectorAdapter) Call16Async(functionName string,
	args interface{}) *tarantool.Future

Call16Async sends a call to registered Tarantool function and returns Future. It uses request code for Tarantool 1.6, so future's result is always array of arrays. Deprecated since Tarantool 1.7.2.

func (*ConnectorAdapter) Call16Typed added in v1.9.0 

func (c *ConnectorAdapter) Call16Typed(functionName string,
	args interface{}, result interface{}) error

Call16Typed calls registered function. It uses request code for Tarantool 1.6, so result is converted to array of arrays Deprecated since Tarantool 1.7.2.

func (*ConnectorAdapter) Call17 added in v1.9.0 

func (c *ConnectorAdapter) Call17(functionName string,
	args interface{}) (*tarantool.Response, error)

Call17 calls registered Tarantool function. It uses request code for Tarantool >= 1.7, so result is not converted (though, keep in mind, result is always array)

func (*ConnectorAdapter) Call17Async added in v1.9.0 

func (c *ConnectorAdapter) Call17Async(functionName string,
	args interface{}) *tarantool.Future

Call17Async sends a call to registered Tarantool function and returns Future. It uses request code for Tarantool >= 1.7, so future's result will not be converted (though, keep in mind, result is always array)

func (*ConnectorAdapter) Call17Typed added in v1.9.0 

func (c *ConnectorAdapter) Call17Typed(functionName string,
	args interface{}, result interface{}) error

Call17Typed calls registered function. It uses request code for Tarantool >= 1.7, so result is not converted (though, keep in mind, result is always array)

func (*ConnectorAdapter) CallAsync added in v1.9.0 

func (c *ConnectorAdapter) CallAsync(functionName string,
	args interface{}) *tarantool.Future

CallAsync sends a call to registered Tarantool function and returns Future. It uses request code for Tarantool >= 1.7 if go-tarantool was build with go_tarantool_call_17 tag. Otherwise, uses request code for Tarantool 1.6.

func (*ConnectorAdapter) CallTyped added in v1.9.0 

func (c *ConnectorAdapter) CallTyped(functionName string,
	args interface{}, result interface{}) error

CallTyped calls registered function. It uses request code for Tarantool >= 1.7 if go-tarantool was build with go_tarantool_call_17 tag. Otherwise, uses request code for Tarantool 1.6.

func (*ConnectorAdapter) Close added in v1.9.0 

func (c *ConnectorAdapter) Close() error

ClosedNow reports if the connector is closed by user or all connections in the specified mode closed.

func (*ConnectorAdapter) ConfiguredTimeout added in v1.9.0 

func (c *ConnectorAdapter) ConfiguredTimeout() time.Duration

ConfiguredTimeout returns a timeout from connections config.

func (*ConnectorAdapter) ConnectedNow added in v1.9.0 

func (c *ConnectorAdapter) ConnectedNow() bool

ConnectedNow reports if connections is established at the moment.

func (*ConnectorAdapter) Delete added in v1.9.0 

func (c *ConnectorAdapter) Delete(space, index interface{},
	key interface{}) (*tarantool.Response, error)

Delete performs deletion of a tuple by key.

func (*ConnectorAdapter) DeleteAsync added in v1.9.0 

func (c *ConnectorAdapter) DeleteAsync(space, index interface{},
	key interface{}) *tarantool.Future

DeleteAsync sends deletion action to Tarantool and returns Future.

func (*ConnectorAdapter) DeleteTyped added in v1.9.0 

func (c *ConnectorAdapter) DeleteTyped(space, index interface{},
	key interface{}, result interface{}) error

DeleteTyped performs deletion of a tuple by key and fills result with deleted tuple.

func (*ConnectorAdapter) Do added in v1.9.0 

func (c *ConnectorAdapter) Do(req tarantool.Request) *tarantool.Future

Do performs a request asynchronously on the connection.

func (*ConnectorAdapter) Eval added in v1.9.0 

func (c *ConnectorAdapter) Eval(expr string,
	args interface{}) (*tarantool.Response, error)

Eval passes Lua expression for evaluation.

func (*ConnectorAdapter) EvalAsync added in v1.9.0 

func (c *ConnectorAdapter) EvalAsync(expr string,
	args interface{}) *tarantool.Future

EvalAsync sends a Lua expression for evaluation and returns Future.

func (*ConnectorAdapter) EvalTyped added in v1.9.0 

func (c *ConnectorAdapter) EvalTyped(expr string, args interface{},
	result interface{}) error

EvalTyped passes Lua expression for evaluation.

func (*ConnectorAdapter) Execute added in v1.9.0 

func (c *ConnectorAdapter) Execute(expr string,
	args interface{}) (*tarantool.Response, error)

Execute passes sql expression to Tarantool for execution.

func (*ConnectorAdapter) ExecuteAsync added in v1.9.0 

func (c *ConnectorAdapter) ExecuteAsync(expr string,
	args interface{}) *tarantool.Future

ExecuteAsync sends a sql expression for execution and returns Future.

func (*ConnectorAdapter) ExecuteTyped added in v1.9.0 

func (c *ConnectorAdapter) ExecuteTyped(expr string, args interface{},
	result interface{}) (tarantool.SQLInfo, []tarantool.ColumnMetaData, error)

ExecuteTyped passes sql expression to Tarantool for execution.

func (*ConnectorAdapter) GetTyped added in v1.9.0 

func (c *ConnectorAdapter) GetTyped(space, index interface{},
	key interface{}, result interface{}) error

GetTyped performs select (with limit = 1 and offset = 0) to box space and fills typed result.

func (*ConnectorAdapter) Insert added in v1.9.0 

func (c *ConnectorAdapter) Insert(space interface{},
	tuple interface{}) (*tarantool.Response, error)

Insert performs insertion to box space.

func (*ConnectorAdapter) InsertAsync added in v1.9.0 

func (c *ConnectorAdapter) InsertAsync(space interface{},
	tuple interface{}) *tarantool.Future

InsertAsync sends insert action to Tarantool and returns Future.

func (*ConnectorAdapter) InsertTyped added in v1.9.0 

func (c *ConnectorAdapter) InsertTyped(space interface{},
	tuple interface{}, result interface{}) error

InsertTyped performs insertion to box space.

func (*ConnectorAdapter) NewPrepared added in v1.9.0 

func (c *ConnectorAdapter) NewPrepared(expr string) (*tarantool.Prepared, error)

NewPrepared passes a sql statement to Tarantool for preparation synchronously.

func (*ConnectorAdapter) NewStream added in v1.9.0 

func (c *ConnectorAdapter) NewStream() (*tarantool.Stream, error)

NewStream creates new Stream object for connection.

Since v. 2.10.0, Tarantool supports streams and interactive transactions over them. To use interactive transactions, memtx_use_mvcc_engine box option should be set to true. Since 1.7.0

func (*ConnectorAdapter) Ping added in v1.9.0 

func (c *ConnectorAdapter) Ping() (*tarantool.Response, error)

Ping sends empty request to Tarantool to check connection.

func (*ConnectorAdapter) Replace added in v1.9.0 

func (c *ConnectorAdapter) Replace(space interface{},
	tuple interface{}) (*tarantool.Response, error)

Replace performs "insert or replace" action to box space.

func (*ConnectorAdapter) ReplaceAsync added in v1.9.0 

func (c *ConnectorAdapter) ReplaceAsync(space interface{},
	tuple interface{}) *tarantool.Future

ReplaceAsync sends "insert or replace" action to Tarantool and returns Future.

func (*ConnectorAdapter) ReplaceTyped added in v1.9.0 

func (c *ConnectorAdapter) ReplaceTyped(space interface{},
	tuple interface{}, result interface{}) error

ReplaceTyped performs "insert or replace" action to box space.

func (*ConnectorAdapter) Select added in v1.9.0 

func (c *ConnectorAdapter) Select(space, index interface{},
	offset, limit, iterator uint32,
	key interface{}) (*tarantool.Response, error)

Select performs select to box space.

func (*ConnectorAdapter) SelectAsync added in v1.9.0 

func (c *ConnectorAdapter) SelectAsync(space, index interface{},
	offset, limit, iterator uint32, key interface{}) *tarantool.Future

SelectAsync sends select request to Tarantool and returns Future.

func (*ConnectorAdapter) SelectTyped added in v1.9.0 

func (c *ConnectorAdapter) SelectTyped(space, index interface{},
	offset, limit, iterator uint32,
	key interface{}, result interface{}) error

SelectTyped performs select to box space and fills typed result.

func (*ConnectorAdapter) Update added in v1.9.0 

func (c *ConnectorAdapter) Update(space, index interface{},
	key, ops interface{}) (*tarantool.Response, error)

Update performs update of a tuple by key.

func (*ConnectorAdapter) UpdateAsync added in v1.9.0 

func (c *ConnectorAdapter) UpdateAsync(space, index interface{},
	key, ops interface{}) *tarantool.Future

Update sends deletion of a tuple by key and returns Future.

func (*ConnectorAdapter) UpdateTyped added in v1.9.0 

func (c *ConnectorAdapter) UpdateTyped(space, index interface{},
	key, ops interface{}, result interface{}) error

UpdateTyped performs update of a tuple by key and fills result with updated tuple.

func (*ConnectorAdapter) Upsert added in v1.9.0 

func (c *ConnectorAdapter) Upsert(space interface{},
	tuple, ops interface{}) (*tarantool.Response, error)

Upsert performs "update or insert" action of a tuple by key.

func (*ConnectorAdapter) UpsertAsync added in v1.9.0 

func (c *ConnectorAdapter) UpsertAsync(space interface{}, tuple interface{},
	ops interface{}) *tarantool.Future

UpsertAsync sends "update or insert" action to Tarantool and returns Future.

type Mode 

type Mode uint32

Default mode for each request table: 

  Request   Default mode
---------- --------------
| call    | no default  |
| eval    | no default  |
| execute | no default  |
| ping    | no default  |
| insert  | RW          |
| delete  | RW          |
| replace | RW          |
| update  | RW          |
| upsert  | RW          |
| select  | ANY         |
| get     | ANY         |

const (
	ANY      Mode = iota // The request can be executed on any instance (master or replica).
	RW                   // The request can only be executed on master.
	RO                   // The request can only be executed on replica.
	PreferRW             // If there is one, otherwise fallback to a writeable one (master).
	PreferRO             // If there is one, otherwise fallback to a read only one (replica).
)

type OptsPool 

type OptsPool struct {
	// Timeout for timer to reopen connections that have been closed by some
	// events and to relocate connection between subpools if ro/rw role has
	// been updated.
	CheckTimeout time.Duration
	// ConnectionHandler provides an ability to handle connection updates.
	ConnectionHandler ConnectionHandler
}

OptsPool provides additional options (configurable via ConnectWithOpts).

type Pooler added in v1.9.0 

type Pooler interface {
	ConnectedNow(mode Mode) (bool, error)
	Close() []error
	Ping(mode Mode) (*tarantool.Response, error)
	ConfiguredTimeout(mode Mode) (time.Duration, error)

	Select(space, index interface{}, offset, limit, iterator uint32,
		key interface{}, mode ...Mode) (*tarantool.Response, error)
	Insert(space interface{}, tuple interface{},
		mode ...Mode) (*tarantool.Response, error)
	Replace(space interface{}, tuple interface{},
		mode ...Mode) (*tarantool.Response, error)
	Delete(space, index interface{}, key interface{},
		mode ...Mode) (*tarantool.Response, error)
	Update(space, index interface{}, key, ops interface{},
		mode ...Mode) (*tarantool.Response, error)
	Upsert(space interface{}, tuple, ops interface{},
		mode ...Mode) (*tarantool.Response, error)
	Call(functionName string, args interface{},
		mode Mode) (*tarantool.Response, error)
	Call16(functionName string, args interface{},
		mode Mode) (*tarantool.Response, error)
	Call17(functionName string, args interface{},
		mode Mode) (*tarantool.Response, error)
	Eval(expr string, args interface{},
		mode Mode) (*tarantool.Response, error)
	Execute(expr string, args interface{},
		mode Mode) (*tarantool.Response, error)

	GetTyped(space, index interface{}, key interface{}, result interface{},
		mode ...Mode) error
	SelectTyped(space, index interface{}, offset, limit, iterator uint32,
		key interface{}, result interface{}, mode ...Mode) error
	InsertTyped(space interface{}, tuple interface{}, result interface{},
		mode ...Mode) error
	ReplaceTyped(space interface{}, tuple interface{}, result interface{},
		mode ...Mode) error
	DeleteTyped(space, index interface{}, key interface{}, result interface{},
		mode ...Mode) error
	UpdateTyped(space, index interface{}, key, ops interface{},
		result interface{}, mode ...Mode) error
	CallTyped(functionName string, args interface{}, result interface{},
		mode Mode) error
	Call16Typed(functionName string, args interface{}, result interface{},
		mode Mode) error
	Call17Typed(functionName string, args interface{}, result interface{},
		mode Mode) error
	EvalTyped(expr string, args interface{}, result interface{},
		mode Mode) error
	ExecuteTyped(expr string, args interface{}, result interface{},
		mode Mode) (tarantool.SQLInfo, []tarantool.ColumnMetaData, error)

	SelectAsync(space, index interface{}, offset, limit, iterator uint32,
		key interface{}, mode ...Mode) *tarantool.Future
	InsertAsync(space interface{}, tuple interface{},
		mode ...Mode) *tarantool.Future
	ReplaceAsync(space interface{}, tuple interface{},
		mode ...Mode) *tarantool.Future
	DeleteAsync(space, index interface{}, key interface{},
		mode ...Mode) *tarantool.Future
	UpdateAsync(space, index interface{}, key, ops interface{},
		mode ...Mode) *tarantool.Future
	UpsertAsync(space interface{}, tuple interface{}, ops interface{},
		mode ...Mode) *tarantool.Future
	CallAsync(functionName string, args interface{},
		mode Mode) *tarantool.Future
	Call16Async(functionName string, args interface{},
		mode Mode) *tarantool.Future
	Call17Async(functionName string, args interface{},
		mode Mode) *tarantool.Future
	EvalAsync(expr string, args interface{},
		mode Mode) *tarantool.Future
	ExecuteAsync(expr string, args interface{},
		mode Mode) *tarantool.Future

	NewPrepared(expr string, mode Mode) (*tarantool.Prepared, error)
	NewStream(mode Mode) (*tarantool.Stream, error)

	Do(req tarantool.Request, mode Mode) (fut *tarantool.Future)
}

Pooler is the interface that must be implemented by a connection pool.

type Role 

type Role uint32

Role describes a role of an instance by its mode. 

const (
	UnknownRole Role = iota // A connection pool failed to discover mode of the instance.
	MasterRole              // The instance is read-write mode.
	ReplicaRole             // The instance is in read-only mode.
)

type RoundRobinStrategy 

type RoundRobinStrategy struct {
	// contains filtered or unexported fields
}

func NewEmptyRoundRobin 

func NewEmptyRoundRobin(size int) *RoundRobinStrategy

func (*RoundRobinStrategy) AddConn 

func (r *RoundRobinStrategy) AddConn(addr string, conn *tarantool.Connection)

func (*RoundRobinStrategy) DeleteConnByAddr 

func (r *RoundRobinStrategy) DeleteConnByAddr(addr string) *tarantool.Connection

func (*RoundRobinStrategy) GetConnByAddr 

func (r *RoundRobinStrategy) GetConnByAddr(addr string) *tarantool.Connection

func (*RoundRobinStrategy) GetNextConnection 

func (r *RoundRobinStrategy) GetNextConnection() *tarantool.Connection

func (*RoundRobinStrategy) IsEmpty 

func (r *RoundRobinStrategy) IsEmpty() bool

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.