tarantool

package module
v1.6.0 Latest Latest
Warning

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

 Go to latest Published: Jun 2, 2022 License: BSD-2-Clause Imports: 16 Imported by: 151

README

Go Reference Actions Status Code Coverage Telegram GitHub Discussions Stack Overflow

Client in Go for Tarantool

The package go-tarantool contains everything you need to connect to Tarantool 1.6+.

The advantage of integrating Go with Tarantool, which is an application server plus a DBMS, is that Go programmers can handle databases and perform on-the-fly recompilations of embedded Lua routines, just as in C, with responses that are faster than other packages according to public benchmarks.

Table of contents

Installation

We assume that you have Tarantool version 1.6+ and a modern Linux or BSD operating system.

You need a current version of go, version 1.13 or later (use go version to check the version number). Do not use gccgo-go.

Note: If your go version is older than 1.13 or if go is not installed, download and run the latest tarball from golang.org.

The package go-tarantool is located in tarantool/go-tarantool repository. To download and install, say:

$ go get github.com/tarantool/go-tarantool

This should put the source and binary files in subdirectories of /usr/local/go, so that you can access them by adding github.com/tarantool/go-tarantool to the import {...} section at the start of any Go program.

Documentation

Read the Tarantool documentation to find descriptions of terms such as "connect", "space", "index", and the requests to create and manipulate database objects or Lua functions.

In general, connector methods can be divided into two main parts:

  • Connect() function and functions related to connecting, and
  • Data manipulation functions and Lua invocations such as Insert() or Call().

The supported requests have parameters and results equivalent to requests in the Tarantool CRUD operations. There are also Typed and Async versions of each data-manipulation function.

API Reference

Learn API documentation and examples at pkg.go.dev.

Walking-through example

We can now have a closer look at the example and make some observations about what it does.

package tarantool

import (
	"fmt"
	"github.com/tarantool/go-tarantool"
)

func main() {
	opts := tarantool.Opts{User: "guest"}
	conn, err := tarantool.Connect("127.0.0.1:3301", opts)
	if err != nil {
		fmt.Println("Connection refused:", err)
	}
	resp, err := conn.Insert(999, []interface{}{99999, "BB"})
	if err != nil {
		fmt.Println("Error", err)
		fmt.Println("Code", resp.Code)
	}
}

Observation 1: The line "github.com/tarantool/go-tarantool" in the import(...) section brings in all Tarantool-related functions and structures.

Observation 2: The line starting with "Opts :=" sets up the options for Connect(). In this example, the structure contains only a single value, the username. The structure may also contain other settings, see more in documentation for the "Opts" structure.

Observation 3: The line containing "tarantool.Connect" is essential for starting a session. There are two parameters:

  • a string with host:port format, and
  • the option structure that was set up earlier.

Observation 4: The err structure will be nil if there is no error, otherwise it will have a description which can be retrieved with err.Error().

Observation 5: The Insert request, like almost all requests, is preceded by "conn." which is the name of the object that was returned by Connect(). There are two parameters:

  • a space number (it could just as easily have been a space name), and
  • a tuple.

Contributing

See the contributing guide for detailed instructions on how to get started with our project.

Alternative connectors

There are two other connectors available from the open source community:

See feature comparison in the documentation.

Documentation

Overview

Package with implementation of methods and structures for work with Tarantool instance.

Example (CustomUnpacking)

Example demonstrates how to use custom (un)packing with typed selects and function calls.

You can specify user-defined packing/unpacking functions for your types. This allows you to store complex structures within a tuple and may speed up your requests.

Alternatively, you can just instruct the msgpack library to encode your structure as an array. This is safe "magic". It is easier to implement than a custom packer/unpacker, but it will work slower. 

package main

import (
	"fmt"
	"github.com/tarantool/go-tarantool"
	"gopkg.in/vmihailenco/msgpack.v2"
	"log"
	"time"
)

type Tuple2 struct {
	Cid     uint
	Orig    string
	Members []Member
}

// Same effect in a "magic" way, but slower.
type Tuple3 struct {
	_msgpack struct{} `msgpack:",asArray"` //nolint: structcheck,unused

	Cid     uint
	Orig    string
	Members []Member
}

func (c *Tuple2) EncodeMsgpack(e *msgpack.Encoder) error {
	if err := e.EncodeSliceLen(3); err != nil {
		return err
	}
	if err := e.EncodeUint(c.Cid); err != nil {
		return err
	}
	if err := e.EncodeString(c.Orig); err != nil {
		return err
	}
	e.Encode(c.Members)
	return nil
}

func (c *Tuple2) DecodeMsgpack(d *msgpack.Decoder) error {
	var err error
	var l int
	if l, err = d.DecodeSliceLen(); err != nil {
		return err
	}
	if l != 3 {
		return fmt.Errorf("array len doesn't match: %d", l)
	}
	if c.Cid, err = d.DecodeUint(); err != nil {
		return err
	}
	if c.Orig, err = d.DecodeString(); err != nil {
		return err
	}
	if l, err = d.DecodeSliceLen(); err != nil {
		return err
	}
	c.Members = make([]Member, l)
	for i := 0; i < l; i++ {
		d.Decode(&c.Members[i])
	}
	return nil
}

// Example demonstrates how to use custom (un)packing with typed selects and
// function calls.
//
// You can specify user-defined packing/unpacking functions for your types.
// This allows you to store complex structures within a tuple and may speed up
// your requests.
//
// Alternatively, you can just instruct the msgpack library to encode your
// structure as an array. This is safe "magic". It is easier to implement than
// a custom packer/unpacker, but it will work slower.
func main() {
	// Establish a connection.
	server := "127.0.0.1:3013"
	opts := tarantool.Opts{
		Timeout:       500 * time.Millisecond,
		Reconnect:     1 * time.Second,
		MaxReconnects: 3,
		User:          "test",
		Pass:          "test",
	}
	conn, err := tarantool.Connect(server, opts)
	if err != nil {
		log.Fatalf("Failed to connect: %s", err.Error())
	}

	spaceNo := uint32(517)
	indexNo := uint32(0)

	tuple := Tuple2{Cid: 777, Orig: "orig", Members: []Member{{"lol", "", 1}, {"wut", "", 3}}}
	resp, err := conn.Replace(spaceNo, &tuple) // NOTE: insert a structure itself.
	if err != nil {
		log.Fatalf("Failed to insert: %s", err.Error())
		return
	}
	fmt.Println("Data", resp.Data)
	fmt.Println("Code", resp.Code)

	var tuples1 []Tuple2
	err = conn.SelectTyped(spaceNo, indexNo, 0, 1, tarantool.IterEq, []interface{}{777}, &tuples1)
	if err != nil {
		log.Fatalf("Failed to SelectTyped: %s", err.Error())
		return
	}
	fmt.Println("Tuples (tuples1)", tuples1)

	// Same result in a "magic" way.
	var tuples2 []Tuple3
	err = conn.SelectTyped(spaceNo, indexNo, 0, 1, tarantool.IterEq, []interface{}{777}, &tuples2)
	if err != nil {
		log.Fatalf("Failed to SelectTyped: %s", err.Error())
		return
	}
	fmt.Println("Tuples (tuples2):", tuples2)

	// Call a function "func_name" returning a table of custom tuples.
	var tuples3 []Tuple3
	err = conn.CallTyped("func_name", []interface{}{}, &tuples3)
	if err != nil {
		log.Fatalf("Failed to CallTyped: %s", err.Error())
		return
	}
	fmt.Println("Tuples (tuples3):", tuples3)

}

Output:

Data [[777 orig [[lol 1] [wut 3]]]]
Code 0
Tuples (tuples1) [{777 orig [{lol  1} {wut  3}]}]
Tuples (tuples2): [{{} 777 orig [{lol  1} {wut  3}]}]
Tuples (tuples3): [{{} 221  [{Moscow  34} {Minsk  23} {Kiev  31}]}]

Index

Examples

Constants

View Source 
const (
	// Connected signals that connection is established or reestablished.
	Connected ConnEventKind = iota + 1
	// Disconnected signals that connection is broken.
	Disconnected
	// ReconnectFailed signals that attempt to reconnect has failed.
	ReconnectFailed
	// Either reconnect attempts exhausted, or explicit Close is called.
	Closed

	// LogReconnectFailed is logged when reconnect attempt failed.
	LogReconnectFailed ConnLogKind = iota + 1
	// LogLastReconnectFailed is logged when last reconnect attempt failed,
	// connection will be closed after that.
	LogLastReconnectFailed
	// LogUnexpectedResultId is logged when response with unknown id was received.
	// Most probably it is due to request timeout.
	LogUnexpectedResultId
)
View Source 
const (
	SelectRequest    = 1
	InsertRequest    = 2
	ReplaceRequest   = 3
	UpdateRequest    = 4
	DeleteRequest    = 5
	CallRequest      = 6 /* call in 1.6 format */
	AuthRequest      = 7
	EvalRequest      = 8
	UpsertRequest    = 9
	Call17Request    = 10
	ExecuteRequest   = 11
	PingRequest      = 64
	SubscribeRequest = 66

	KeyCode         = 0x00
	KeySync         = 0x01
	KeySpaceNo      = 0x10
	KeyIndexNo      = 0x11
	KeyLimit        = 0x12
	KeyOffset       = 0x13
	KeyIterator     = 0x14
	KeyKey          = 0x20
	KeyTuple        = 0x21
	KeyFunctionName = 0x22
	KeyUserName     = 0x23
	KeyExpression   = 0x27
	KeyDefTuple     = 0x28
	KeyData         = 0x30
	KeyError        = 0x31
	KeyMetaData     = 0x32
	KeySQLText      = 0x40
	KeySQLBind      = 0x41
	KeySQLInfo      = 0x42

	KeyFieldName               = 0x00
	KeyFieldType               = 0x01
	KeyFieldColl               = 0x02
	KeyFieldIsNullable         = 0x03
	KeyIsAutoincrement         = 0x04
	KeyFieldSpan               = 0x05
	KeySQLInfoRowCount         = 0x00
	KeySQLInfoAutoincrementIds = 0x01

	IterEq            = uint32(0) // key == x ASC order
	IterReq           = uint32(1) // key == x DESC order
	IterAll           = uint32(2) // all tuples
	IterLt            = uint32(3) // key < x
	IterLe            = uint32(4) // key <= x
	IterGe            = uint32(5) // key >= x
	IterGt            = uint32(6) // key > x
	IterBitsAllSet    = uint32(7) // all bits from x are set in key
	IterBitsAnySet    = uint32(8) // at least one x's bit is set
	IterBitsAllNotSet = uint32(9) // all bits are not set

	RLimitDrop = 1
	RLimitWait = 2

	OkCode            = uint32(0)
	ErrorCodeBit      = 0x8000
	PacketLengthBytes = 5
	ErSpaceExistsCode = 0xa
	IteratorCode      = 0x14
)
View Source 
const (
	ErrConnectionNotReady = 0x4000 + iota
	ErrConnectionClosed   = 0x4000 + iota
	ErrProtocolError      = 0x4000 + iota
	ErrTimeouted          = 0x4000 + iota
	ErrRateLimited        = 0x4000 + iota
)

Tarantool client error codes.

View Source 
const (
	ErrUnknown                       = 0   // Unknown error
	ErrIllegalParams                 = 1   // Illegal parameters, %s
	ErrMemoryIssue                   = 2   // Failed to allocate %u bytes in %s for %s
	ErrTupleFound                    = 3   // Duplicate key exists in unique index '%s' in space '%s'
	ErrTupleNotFound                 = 4   // Tuple doesn't exist in index '%s' in space '%s'
	ErrUnsupported                   = 5   // %s does not support %s
	ErrNonmaster                     = 6   // Can't modify data on a replication slave. My master is: %s
	ErrReadonly                      = 7   // Can't modify data because this server is in read-only mode.
	ErrInjection                     = 8   // Error injection '%s'
	ErrCreateSpace                   = 9   // Failed to create space '%s': %s
	ErrSpaceExists                   = 10  // Space '%s' already exists
	ErrDropSpace                     = 11  // Can't drop space '%s': %s
	ErrAlterSpace                    = 12  // Can't modify space '%s': %s
	ErrIndexType                     = 13  // Unsupported index type supplied for index '%s' in space '%s'
	ErrModifyIndex                   = 14  // Can't create or modify index '%s' in space '%s': %s
	ErrLastDrop                      = 15  // Can't drop the primary key in a system space, space '%s'
	ErrTupleFormatLimit              = 16  // Tuple format limit reached: %u
	ErrDropPrimaryKey                = 17  // Can't drop primary key in space '%s' while secondary keys exist
	ErrKeyPartType                   = 18  // Supplied key type of part %u does not match index part type: expected %s
	ErrExactMatch                    = 19  // Invalid key part count in an exact match (expected %u, got %u)
	ErrInvalidMsgpack                = 20  // Invalid MsgPack - %s
	ErrProcRet                       = 21  // msgpack.encode: can not encode Lua type '%s'
	ErrTupleNotArray                 = 22  // Tuple/Key must be MsgPack array
	ErrFieldType                     = 23  // Tuple field %u type does not match one required by operation: expected %s
	ErrFieldTypeMismatch             = 24  // Ambiguous field type in index '%s', key part %u. Requested type is %s but the field has previously been defined as %s
	ErrSplice                        = 25  // SPLICE error on field %u: %s
	ErrArgType                       = 26  // Argument type in operation '%c' on field %u does not match field type: expected a %s
	ErrTupleIsTooLong                = 27  // Tuple is too long %u
	ErrUnknownUpdateOp               = 28  // Unknown UPDATE operation
	ErrUpdateField                   = 29  // Field %u UPDATE error: %s
	ErrFiberStack                    = 30  // Can not create a new fiber: recursion limit reached
	ErrKeyPartCount                  = 31  // Invalid key part count (expected [0..%u], got %u)
	ErrProcLua                       = 32  // %s
	ErrNoSuchProc                    = 33  // Procedure '%.*s' is not defined
	ErrNoSuchTrigger                 = 34  // Trigger is not found
	ErrNoSuchIndex                   = 35  // No index #%u is defined in space '%s'
	ErrNoSuchSpace                   = 36  // Space '%s' does not exist
	ErrNoSuchField                   = 37  // Field %d was not found in the tuple
	ErrSpaceFieldCount               = 38  // Tuple field count %u does not match space '%s' field count %u
	ErrIndexFieldCount               = 39  // Tuple field count %u is less than required by a defined index (expected %u)
	ErrWalIo                         = 40  // Failed to write to disk
	ErrMoreThanOneTuple              = 41  // More than one tuple found by get()
	ErrAccessDenied                  = 42  // %s access denied for user '%s'
	ErrCreateUser                    = 43  // Failed to create user '%s': %s
	ErrDropUser                      = 44  // Failed to drop user '%s': %s
	ErrNoSuchUser                    = 45  // User '%s' is not found
	ErrUserExists                    = 46  // User '%s' already exists
	ErrPasswordMismatch              = 47  // Incorrect password supplied for user '%s'
	ErrUnknownRequestType            = 48  // Unknown request type %u
	ErrUnknownSchemaObject           = 49  // Unknown object type '%s'
	ErrCreateFunction                = 50  // Failed to create function '%s': %s
	ErrNoSuchFunction                = 51  // Function '%s' does not exist
	ErrFunctionExists                = 52  // Function '%s' already exists
	ErrFunctionAccessDenied          = 53  // %s access denied for user '%s' to function '%s'
	ErrFunctionMax                   = 54  // A limit on the total number of functions has been reached: %u
	ErrSpaceAccessDenied             = 55  // %s access denied for user '%s' to space '%s'
	ErrUserMax                       = 56  // A limit on the total number of users has been reached: %u
	ErrNoSuchEngine                  = 57  // Space engine '%s' does not exist
	ErrReloadCfg                     = 58  // Can't set option '%s' dynamically
	ErrCfg                           = 59  // Incorrect value for option '%s': %s
	ErrSophia                        = 60  // %s
	ErrLocalServerIsNotActive        = 61  // Local server is not active
	ErrUnknownServer                 = 62  // Server %s is not registered with the cluster
	ErrClusterIdMismatch             = 63  // Cluster id of the replica %s doesn't match cluster id of the master %s
	ErrInvalidUUID                   = 64  // Invalid UUID: %s
	ErrClusterIdIsRo                 = 65  // Can't reset cluster id: it is already assigned
	ErrReserved66                    = 66  // Reserved66
	ErrServerIdIsReserved            = 67  // Can't initialize server id with a reserved value %u
	ErrInvalidOrder                  = 68  // Invalid LSN order for server %u: previous LSN = %llu, new lsn = %llu
	ErrMissingRequestField           = 69  // Missing mandatory field '%s' in request
	ErrIdentifier                    = 70  // Invalid identifier '%s' (expected letters, digits or an underscore)
	ErrDropFunction                  = 71  // Can't drop function %u: %s
	ErrIteratorType                  = 72  // Unknown iterator type '%s'
	ErrReplicaMax                    = 73  // Replica count limit reached: %u
	ErrInvalidXlog                   = 74  // Failed to read xlog: %lld
	ErrInvalidXlogName               = 75  // Invalid xlog name: expected %lld got %lld
	ErrInvalidXlogOrder              = 76  // Invalid xlog order: %lld and %lld
	ErrNoConnection                  = 77  // Connection is not established
	ErrTimeout                       = 78  // Timeout exceeded
	ErrActiveTransaction             = 79  // Operation is not permitted when there is an active transaction
	ErrNoActiveTransaction           = 80  // Operation is not permitted when there is no active transaction
	ErrCrossEngineTransaction        = 81  // A multi-statement transaction can not use multiple storage engines
	ErrNoSuchRole                    = 82  // Role '%s' is not found
	ErrRoleExists                    = 83  // Role '%s' already exists
	ErrCreateRole                    = 84  // Failed to create role '%s': %s
	ErrIndexExists                   = 85  // Index '%s' already exists
	ErrTupleRefOverflow              = 86  // Tuple reference counter overflow
	ErrRoleLoop                      = 87  // Granting role '%s' to role '%s' would create a loop
	ErrGrant                         = 88  // Incorrect grant arguments: %s
	ErrPrivGranted                   = 89  // User '%s' already has %s access on %s '%s'
	ErrRoleGranted                   = 90  // User '%s' already has role '%s'
	ErrPrivNotGranted                = 91  // User '%s' does not have %s access on %s '%s'
	ErrRoleNotGranted                = 92  // User '%s' does not have role '%s'
	ErrMissingSnapshot               = 93  // Can't find snapshot
	ErrCantUpdatePrimaryKey          = 94  // Attempt to modify a tuple field which is part of index '%s' in space '%s'
	ErrUpdateIntegerOverflow         = 95  // Integer overflow when performing '%c' operation on field %u
	ErrGuestUserPassword             = 96  // Setting password for guest user has no effect
	ErrTransactionConflict           = 97  // Transaction has been aborted by conflict
	ErrUnsupportedRolePriv           = 98  // Unsupported role privilege '%s'
	ErrLoadFunction                  = 99  // Failed to dynamically load function '%s': %s
	ErrFunctionLanguage              = 100 // Unsupported language '%s' specified for function '%s'
	ErrRtreeRect                     = 101 // RTree: %s must be an array with %u (point) or %u (rectangle/box) numeric coordinates
	ErrProcC                         = 102 // ???
	ErrUnknownRtreeIndexDistanceType = 103 //Unknown RTREE index distance type %s
	ErrProtocol                      = 104 // %s
	ErrUpsertUniqueSecondaryKey      = 105 // Space %s has a unique secondary index and does not support UPSERT
	ErrWrongIndexRecord              = 106 // Wrong record in _index space: got {%s}, expected {%s}
	ErrWrongIndexParts               = 107 // Wrong index parts (field %u): %s; expected field1 id (number), field1 type (string), ...
	ErrWrongIndexOptions             = 108 // Wrong index options (field %u): %s
	ErrWrongSchemaVaersion           = 109 // Wrong schema version, current: %d, in request: %u
	ErrSlabAllocMax                  = 110 // Failed to allocate %u bytes for tuple in the slab allocator: tuple is too large. Check 'slab_alloc_maximal' configuration option.
)

Tarantool server error codes.

Variables

This section is empty.

Functions

This section is empty.

Types

type ClientError 

type ClientError struct {
	Code uint32
	Msg  string
}

ClientError is connection error produced by this client, i.e. connection failures or timeouts.

func (ClientError) Error 

func (clierr ClientError) Error() string

Error converts a ClientError to a string.

func (ClientError) Temporary 

func (clierr ClientError) Temporary() bool

Temporary returns true if next attempt to perform request may succeeed.

Currently it returns true when:

- Connection is not connected at the moment

- request is timeouted

- request is aborted due to rate limit

type ColumnMetaData 

type ColumnMetaData struct {
	FieldName            string
	FieldType            string
	FieldCollation       string
	FieldIsNullable      bool
	FieldIsAutoincrement bool
	FieldSpan            string
}

func (*ColumnMetaData) DecodeMsgpack 

func (meta *ColumnMetaData) DecodeMsgpack(d *msgpack.Decoder) error

type ConnEvent 

type ConnEvent struct {
	Conn *Connection
	Kind ConnEventKind
	When time.Time
}

ConnEvent is sent throw Notify channel specified in Opts.

type ConnEventKind 

type ConnEventKind int

type ConnLogKind 

type ConnLogKind int

type Connection 

type Connection struct {

	// Schema contains schema loaded on connection.
	Schema *Schema

	// Greeting contains first message sent by Tarantool.
	Greeting *Greeting
	// contains filtered or unexported fields
}

Connection is a handle with a single connection to a Tarantool instance.

It is created and configured with Connect function, and could not be reconfigured later.

Connection could be in three possible states:

- In "Connected" state it sends queries to Tarantool.

- In "Disconnected" state it rejects queries with ClientError{Code: ErrConnectionNotReady}

- In "Closed" state it rejects queries with ClientError{Code: ErrConnectionClosed}. Connection could become "Closed" when Connection.Close() method called, or when Tarantool disconnected and Reconnect pause is not specified or MaxReconnects is specified and MaxReconnect reconnect attempts already performed.

You may perform data manipulation operation by calling its methods: Call*, Insert*, Replace*, Update*, Upsert*, Call*, Eval*.

In any method that accepts space you my pass either space number or space name (in this case it will be looked up in schema). Same is true for index.

ATTENTION: tuple, key, ops and args arguments for any method should be and array or should serialize to msgpack array.

ATTENTION: result argument for *Typed methods should deserialize from msgpack array, cause Tarantool always returns result as an array. For all space related methods and Call* (but not Call17*) methods Tarantool always returns array of array (array of tuples for space related methods). For Eval* and Call17* Tarantool always returns array, but does not forces array of arrays.

func Connect 

func Connect(addr string, opts Opts) (conn *Connection, err error)

Connect creates and configures a new Connection.

Address could be specified in following ways:

- TCP connections (tcp://192.168.1.1:3013, tcp://my.host:3013, tcp:192.168.1.1:3013, tcp:my.host:3013, 192.168.1.1:3013, my.host:3013)

- Unix socket, first '/' or '.' indicates Unix socket (unix:///abs/path/tnt.sock, unix:path/tnt.sock, /abs/path/tnt.sock, ./rel/path/tnt.sock, unix/:path/tnt.sock)

Notes:

- If opts.Reconnect is zero (default), then connection either already connected or error is returned.

- If opts.Reconnect is non-zero, then error will be returned only if authorization fails. But if Tarantool is not reachable, then it will make an attempt to reconnect later and will not finish to make attempts on authorization failures.

Example 
conn, err := tarantool.Connect("127.0.0.1:3013", tarantool.Opts{
	Timeout:     500 * time.Millisecond,
	User:        "test",
	Pass:        "test",
	Concurrency: 32,
})
if err != nil {
	fmt.Println("No connection available")
	return
}
defer conn.Close()
if conn != nil {
	fmt.Println("Connection is ready")
}

Output:

Connection is ready

func (*Connection) Addr 

func (conn *Connection) Addr() string

Addr returns a configured address of Tarantool socket.

func (*Connection) Call 

func (conn *Connection) Call(functionName string, args interface{}) (resp *Response, err error)

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

It is equal to conn.CallAsync(functionName, args).Get().

func (*Connection) Call17 

func (conn *Connection) Call17(functionName string, args interface{}) (resp *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)

It is equal to conn.Call17Async(functionName, args).Get().

Example 
conn := example_connect()
defer conn.Close()

// Call a function 'simple_incr' with arguments.
resp, err := conn.Call17("simple_incr", []interface{}{1})
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 (*Connection) Call17Async 

func (conn *Connection) Call17Async(functionName string, args interface{}) *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 (*Connection) Call17Typed 

func (conn *Connection) Call17Typed(functionName string, args interface{}, result interface{}) (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)

It is equal to conn.Call17Async(functionName, args).GetTyped(&result).

func (*Connection) CallAsync 

func (conn *Connection) CallAsync(functionName string, args interface{}) *Future

CallAsync 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

func (*Connection) CallTyped 

func (conn *Connection) CallTyped(functionName string, args interface{}, result interface{}) (err error)

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

It is equal to conn.CallAsync(functionName, args).GetTyped(&result).

func (*Connection) Close 

func (conn *Connection) Close() error

Close closes Connection. After this method called, there is no way to reopen this Connection.

func (*Connection) ClosedNow 

func (conn *Connection) ClosedNow() bool

ClosedNow reports if connection is closed by user or after reconnect.

func (*Connection) ConfiguredTimeout 

func (conn *Connection) ConfiguredTimeout() time.Duration

ConfiguredTimeout returns a timeout from connection config.

func (*Connection) ConnectedNow 

func (conn *Connection) ConnectedNow() bool

ConnectedNow reports if connection is established at the moment.

func (*Connection) Delete 

func (conn *Connection) Delete(space, index interface{}, key interface{}) (resp *Response, err error)

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

It is equal to conn.DeleteAsync(space, tuple).Get().

Example 
conn := example_connect()
defer conn.Close()

// Insert a new tuple { 35, 1 }.
conn.Insert(spaceNo, []interface{}{uint(35), "test", "one"})
// Insert a new tuple { 36, 1 }.
conn.Insert("test", &Tuple{Id: 36, Msg: "test", Name: "one"})

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

// Delete tuple with primary key { 36 }.
resp, err = conn.Delete("test", "primary", []interface{}{uint(36)})
fmt.Println("Delete 36")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)

Output:

Delete 35
Error <nil>
Code 0
Data [[35 test one]]
Delete 36
Error <nil>
Code 0
Data [[36 test one]]

func (*Connection) DeleteAsync 

func (conn *Connection) DeleteAsync(space, index interface{}, key interface{}) *Future

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

func (*Connection) DeleteTyped 

func (conn *Connection) DeleteTyped(space, index interface{}, key interface{}, result interface{}) (err error)

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

It is equal to conn.DeleteAsync(space, tuple).GetTyped(&result).

func (*Connection) Eval 

func (conn *Connection) Eval(expr string, args interface{}) (resp *Response, err error)

Eval passes Lua expression for evaluation.

It is equal to conn.EvalAsync(space, tuple).Get().

Example 
conn := example_connect()
defer conn.Close()

// Run raw Lua code.
resp, err := conn.Eval("return 1 + 2", []interface{}{})
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 (*Connection) EvalAsync 

func (conn *Connection) EvalAsync(expr string, args interface{}) *Future

EvalAsync sends a Lua expression for evaluation and returns Future.

func (*Connection) EvalTyped 

func (conn *Connection) EvalTyped(expr string, args interface{}, result interface{}) (err error)

EvalTyped passes Lua expression for evaluation.

It is equal to conn.EvalAsync(space, tuple).GetTyped(&result).

func (*Connection) Execute 

func (conn *Connection) Execute(expr string, args interface{}) (resp *Response, err error)

Execute passes sql expression to Tarantool for execution.

It is equal to conn.ExecuteAsync(expr, args).Get(). Since 1.6.0

Example

To use SQL to query a tarantool instance, call Execute.

Pay attention that with different types of queries (DDL, DQL, DML etc.) some fields of the response structure (MetaData and InfoAutoincrementIds in SQLInfo) may be nil. 

// Tarantool supports SQL since version 2.0.0
isLess, _ := test_helpers.IsTarantoolVersionLess(2, 0, 0)
if isLess {
	return
}
server := "127.0.0.1:3013"
opts := tarantool.Opts{
	Timeout:       500 * time.Millisecond,
	Reconnect:     1 * time.Second,
	MaxReconnects: 3,
	User:          "test",
	Pass:          "test",
}
client, err := tarantool.Connect(server, opts)
if err != nil {
	fmt.Printf("Failed to connect: %s", err.Error())
}

resp, err := client.Execute("CREATE TABLE SQL_TEST (id INTEGER PRIMARY KEY, name STRING)", []interface{}{})
fmt.Println("Execute")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)
fmt.Println("MetaData", resp.MetaData)
fmt.Println("SQL Info", resp.SQLInfo)

// there are 4 options to pass named parameters to an SQL query
// the simple map:
sqlBind1 := map[string]interface{}{
	"id":   1,
	"name": "test",
}

// any type of structure
sqlBind2 := struct {
	Id   int
	Name string
}{1, "test"}

// it is possible to use []tarantool.KeyValueBind
sqlBind3 := []interface{}{
	tarantool.KeyValueBind{Key: "id", Value: 1},
	tarantool.KeyValueBind{Key: "name", Value: "test"},
}

// or []interface{} slice with tarantool.KeyValueBind items inside
sqlBind4 := []tarantool.KeyValueBind{
	{"id", 1},
	{"name", "test"},
}

// the next usage
resp, err = client.Execute("SELECT id FROM SQL_TEST WHERE id=:id AND name=:name", sqlBind1)
fmt.Println("Execute")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)
fmt.Println("MetaData", resp.MetaData)
fmt.Println("SQL Info", resp.SQLInfo)

// the same as
resp, err = client.Execute("SELECT id FROM SQL_TEST WHERE id=:id AND name=:name", sqlBind2)
fmt.Println("Execute")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)
fmt.Println("MetaData", resp.MetaData)
fmt.Println("SQL Info", resp.SQLInfo)

// the same as
resp, err = client.Execute("SELECT id FROM SQL_TEST WHERE id=:id AND name=:name", sqlBind3)
fmt.Println("Execute")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)
fmt.Println("MetaData", resp.MetaData)
fmt.Println("SQL Info", resp.SQLInfo)

// the same as
resp, err = client.Execute("SELECT id FROM SQL_TEST WHERE id=:id AND name=:name", sqlBind4)
fmt.Println("Execute")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)
fmt.Println("MetaData", resp.MetaData)
fmt.Println("SQL Info", resp.SQLInfo)

// the way to pass positional arguments to an SQL query
resp, err = client.Execute("SELECT id FROM SQL_TEST WHERE id=? AND name=?", []interface{}{2, "test"})
fmt.Println("Execute")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)
fmt.Println("MetaData", resp.MetaData)
fmt.Println("SQL Info", resp.SQLInfo)

// the way to pass SQL expression with using custom packing/unpacking for a type
var res []Tuple
sqlInfo, metaData, err := client.ExecuteTyped("SELECT id, name, name FROM SQL_TEST WHERE id=?", []interface{}{2}, &res)
fmt.Println("ExecuteTyped")
fmt.Println("Error", err)
fmt.Println("Data", res)
fmt.Println("MetaData", metaData)
fmt.Println("SQL Info", sqlInfo)

// for using different types of parameters (positioned/named), collect all items in []interface{}
// all "named" items must be passed with tarantool.KeyValueBind{}
resp, err = client.Execute("SELECT id FROM SQL_TEST WHERE id=:id AND name=?",
	[]interface{}{tarantool.KeyValueBind{"id", 1}, "test"})
fmt.Println("Execute")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)
fmt.Println("MetaData", resp.MetaData)
fmt.Println("SQL Info", resp.SQLInfo)

func (*Connection) ExecuteAsync 

func (conn *Connection) ExecuteAsync(expr string, args interface{}) *Future

ExecuteAsync sends a sql expression for execution and returns Future. Since 1.6.0

func (*Connection) ExecuteTyped 

func (conn *Connection) ExecuteTyped(expr string, args interface{}, result interface{}) (SQLInfo, []ColumnMetaData, error)

ExecuteTyped passes sql expression to Tarantool for execution.

In addition to error returns sql info and columns meta data Since 1.6.0

func (*Connection) GetTyped 

func (conn *Connection) GetTyped(space, index interface{}, key interface{}, result interface{}) (err error)

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

It is equal to conn.SelectAsync(space, index, 0, 1, IterEq, key).GetTyped(&result)

func (*Connection) Handle 

func (conn *Connection) Handle() interface{}

Handle returns a user-specified handle from Opts.

func (*Connection) Insert 

func (conn *Connection) Insert(space interface{}, tuple interface{}) (resp *Response, err error)

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

It is equal to conn.InsertAsync(space, tuple).Get().

Example 
conn := example_connect()
defer conn.Close()

// Insert a new tuple { 31, 1 }.
resp, err := conn.Insert(spaceNo, []interface{}{uint(31), "test", "one"})
fmt.Println("Insert 31")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)
// Insert a new tuple { 32, 1 }.
resp, err = conn.Insert("test", &Tuple{Id: 32, Msg: "test", Name: "one"})
fmt.Println("Insert 32")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)

// Delete tuple with primary key { 31 }.
conn.Delete("test", "primary", []interface{}{uint(31)})
// Delete tuple with primary key { 32 }.
conn.Delete(spaceNo, indexNo, []interface{}{uint(32)})

Output:

Insert 31
Error <nil>
Code 0
Data [[31 test one]]
Insert 32
Error <nil>
Code 0
Data [[32 test one]]

func (*Connection) InsertAsync 

func (conn *Connection) InsertAsync(space interface{}, tuple interface{}) *Future

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

func (*Connection) InsertTyped 

func (conn *Connection) InsertTyped(space interface{}, tuple interface{}, result interface{}) (err error)

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

It is equal to conn.InsertAsync(space, tuple).GetTyped(&result).

func (*Connection) LocalAddr 

func (conn *Connection) LocalAddr() string

LocalAddr returns an address of outgoing socket.

func (*Connection) OverrideSchema 

func (conn *Connection) OverrideSchema(s *Schema)

OverrideSchema sets Schema for the connection.

func (*Connection) Ping 

func (conn *Connection) Ping() (resp *Response, err error)

Ping sends empty request to Tarantool to check connection.

Example 
conn := example_connect()
defer conn.Close()

// Ping a Tarantool instance to check connection.
resp, err := conn.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 (*Connection) RemoteAddr 

func (conn *Connection) RemoteAddr() string

RemoteAddr returns an address of Tarantool socket.

func (*Connection) Replace 

func (conn *Connection) Replace(space interface{}, tuple interface{}) (resp *Response, err error)

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

It is equal to conn.ReplaceAsync(space, tuple).Get().

Example 
conn := example_connect()
defer conn.Close()

// Insert a new tuple { 13, 1 }.
conn.Insert(spaceNo, []interface{}{uint(13), "test", "one"})

// Replace a tuple with primary key 13.
// Note, Tuple is defined within tests, and has EncdodeMsgpack and
// DecodeMsgpack methods.
resp, err := conn.Replace(spaceNo, []interface{}{uint(13), 1})
fmt.Println("Replace 13")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)
resp, err = conn.Replace("test", []interface{}{uint(13), 1})
fmt.Println("Replace 13")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)
resp, err = conn.Replace("test", &Tuple{Id: 13, Msg: "test", Name: "eleven"})
fmt.Println("Replace 13")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)
resp, err = conn.Replace("test", &Tuple{Id: 13, Msg: "test", Name: "twelve"})
fmt.Println("Replace 13")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)

Output:

Replace 13
Error <nil>
Code 0
Data [[13 1]]
Replace 13
Error <nil>
Code 0
Data [[13 1]]
Replace 13
Error <nil>
Code 0
Data [[13 test eleven]]
Replace 13
Error <nil>
Code 0
Data [[13 test twelve]]

func (*Connection) ReplaceAsync 

func (conn *Connection) ReplaceAsync(space interface{}, tuple interface{}) *Future

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

func (*Connection) ReplaceTyped 

func (conn *Connection) ReplaceTyped(space interface{}, tuple interface{}, result interface{}) (err error)

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

It is equal to conn.ReplaceAsync(space, tuple).GetTyped(&result).

func (*Connection) Select 

func (conn *Connection) Select(space, index interface{}, offset, limit, iterator uint32, key interface{}) (resp *Response, err error)

Select performs select to box space.

It is equal to conn.SelectAsync(...).Get().

Example 
conn := example_connect()
defer conn.Close()

conn.Replace(spaceNo, []interface{}{uint(1111), "hello", "world"})
conn.Replace(spaceNo, []interface{}{uint(1112), "hallo", "werld"})

resp, err := conn.Select(517, 0, 0, 100, tarantool.IterEq, []interface{}{uint(1111)})

if err != nil {
	fmt.Printf("error in select is %v", err)
	return
}
fmt.Printf("response is %#v\n", resp.Data)
resp, err = conn.Select("test", "primary", 0, 100, tarantool.IterEq, tarantool.IntKey{1111})
if err != nil {
	fmt.Printf("error in select is %v", err)
	return
}
fmt.Printf("response is %#v\n", resp.Data)

Output:

response is []interface {}{[]interface {}{0x457, "hello", "world"}}
response is []interface {}{[]interface {}{0x457, "hello", "world"}}

func (*Connection) SelectAsync 

func (conn *Connection) SelectAsync(space, index interface{}, offset, limit, iterator uint32, key interface{}) *Future

SelectAsync sends select request to Tarantool and returns Future.

Example 
conn := example_connect()
defer conn.Close()
spaceNo := uint32(517)

conn.Insert(spaceNo, []interface{}{uint(16), "test", "one"})
conn.Insert(spaceNo, []interface{}{uint(17), "test", "one"})
conn.Insert(spaceNo, []interface{}{uint(18), "test", "one"})

var futs [3]*tarantool.Future
futs[0] = conn.SelectAsync("test", "primary", 0, 2, tarantool.IterLe, tarantool.UintKey{16})
futs[1] = conn.SelectAsync("test", "primary", 0, 1, tarantool.IterEq, tarantool.UintKey{17})
futs[2] = conn.SelectAsync("test", "primary", 0, 1, tarantool.IterEq, tarantool.UintKey{18})
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)

Output:

Future 0 Error <nil>
Future 0 Data [{{} 16 val 16 bla} {{} 15 val 15 bla}]
Future 1 Error <nil>
Future 1 Data [[17 val 17 bla]]
Future 2 Error <nil>
Future 2 Data [[18 val 18 bla]]

func (*Connection) SelectTyped 

func (conn *Connection) SelectTyped(space, index interface{}, offset, limit, iterator uint32, key interface{}, result interface{}) (err error)

SelectTyped performs select to box space and fills typed result.

It is equal to conn.SelectAsync(space, index, offset, limit, iterator, key).GetTyped(&result)

Example 
conn := example_connect()
defer conn.Close()
var res []Tuple

err := conn.SelectTyped(517, 0, 0, 100, tarantool.IterEq, tarantool.IntKey{1111}, &res)

if err != nil {
	fmt.Printf("error in select is %v", err)
	return
}
fmt.Printf("response is %v\n", res)
err = conn.SelectTyped("test", "primary", 0, 100, tarantool.IterEq, tarantool.IntKey{1111}, &res)
if err != nil {
	fmt.Printf("error in select is %v", err)
	return
}
fmt.Printf("response is %v\n", res)

Output:

response is [{{} 1111 hello world}]
response is [{{} 1111 hello world}]

func (*Connection) Update 

func (conn *Connection) Update(space, index interface{}, key, ops interface{}) (resp *Response, err error)

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

It is equal to conn.UpdateAsync(space, tuple).Get().

Example 
conn := example_connect()
defer conn.Close()

// Insert a new tuple { 14, 1 }.
conn.Insert(spaceNo, []interface{}{uint(14), "test", "one"})

// Update tuple with primary key { 14 }.
resp, err := conn.Update(spaceName, indexName, []interface{}{uint(14)}, []interface{}{[]interface{}{"=", 1, "bye"}})
fmt.Println("Update 14")
fmt.Println("Error", err)
fmt.Println("Code", resp.Code)
fmt.Println("Data", resp.Data)

Output:

Update 14
Error <nil>
Code 0
Data [[14 bye bla]]

func (*Connection) UpdateAsync 

func (conn *Connection) UpdateAsync(space, index interface{}, key, ops interface{}) *Future

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

func (*Connection) UpdateTyped 

func (conn *Connection) UpdateTyped(space, index interface{}, key, ops interface{}, result interface{}) (err error)

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

It is equal to conn.UpdateAsync(space, tuple, ops).GetTyped(&result).

func (*Connection) Upsert 

func (conn *Connection) Upsert(space interface{}, tuple, ops interface{}) (resp *Response, err error)

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

It is equal to conn.UpsertAsync(space, tuple, ops).Get().

func (*Connection) UpsertAsync 

func (conn *Connection) UpsertAsync(space interface{}, tuple interface{}, ops interface{}) *Future

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

type Connector 

type Connector interface {
	ConnectedNow() bool
	Close() error
	Ping() (resp *Response, err error)
	ConfiguredTimeout() time.Duration

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

	GetTyped(space, index interface{}, key interface{}, result interface{}) (err error)
	SelectTyped(space, index interface{}, offset, limit, iterator uint32, key interface{}, result interface{}) (err error)
	InsertTyped(space interface{}, tuple interface{}, result interface{}) (err error)
	ReplaceTyped(space interface{}, tuple interface{}, result interface{}) (err error)
	DeleteTyped(space, index interface{}, key interface{}, result interface{}) (err error)
	UpdateTyped(space, index interface{}, key, ops interface{}, result interface{}) (err error)
	CallTyped(functionName string, args interface{}, result interface{}) (err error)
	Call17Typed(functionName string, args interface{}, result interface{}) (err error)
	EvalTyped(expr string, args interface{}, result interface{}) (err error)

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

type DeadlineIO 

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

func (*DeadlineIO) Read 

func (d *DeadlineIO) Read(b []byte) (n int, err error)

func (*DeadlineIO) Write 

func (d *DeadlineIO) Write(b []byte) (n int, err error)

type Error 

type Error struct {
	Code uint32
	Msg  string
}

Error is wrapper around error returned by Tarantool.

func (Error) Error 

func (tnterr Error) Error() string

Error converts an Error to a string.

type Field 

type Field struct {
	Id   uint32
	Name string
	Type string
}

type Future 

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

Future is a handle for asynchronous request.

func NewErrorFuture 

func NewErrorFuture(err error) *Future

NewErrorFuture returns new set empty Future with filled error field.

func (*Future) Err 

func (fut *Future) Err() error

Err returns error set on Future. It waits for future to be set. Note: it doesn't decode body, therefore decoding error are not set here.

func (*Future) Get 

func (fut *Future) Get() (*Response, error)

Get waits for Future to be filled and returns Response and error.

Response will contain deserialized result in Data field. It will be []interface{}, so if you want more performace, use GetTyped method.

Note: Response could be equal to nil if ClientError is returned in error.

"error" could be Error, if it is error returned by Tarantool, or ClientError, if something bad happens in a client process.

func (*Future) GetTyped 

func (fut *Future) GetTyped(result interface{}) error

GetTyped waits for Future and calls msgpack.Decoder.Decode(result) if no error happens. It is could be much faster than Get() function.

Note: Tarantool usually returns array of tuples (except for Eval and Call17 actions)

func (*Future) WaitChan 

func (fut *Future) WaitChan() <-chan struct{}

WaitChan returns channel which becomes closed when response arrived or error occured.

type Greeting 

type Greeting struct {
	Version string
	// contains filtered or unexported fields
}

Greeting is a message sent by Tarantool on connect.

type Index 

type Index struct {
	Id     uint32
	Name   string
	Type   string
	Unique bool
	Fields []*IndexField
}

Index contains information about index.

type IndexField 

type IndexField struct {
	Id   uint32
	Type string
}

type IntIntKey 

type IntIntKey struct {
	I1, I2 int
}

IntIntKey is utility type for passing two integer keys to Select*, Update* and Delete*. It serializes to array with two integer elements.

func (IntIntKey) EncodeMsgpack 

func (k IntIntKey) EncodeMsgpack(enc *msgpack.Encoder) error

type IntKey 

type IntKey struct {
	I int
}

IntKey is utility type for passing integer key to Select*, Update* and Delete*. It serializes to array with single integer element.

func (IntKey) EncodeMsgpack 

func (k IntKey) EncodeMsgpack(enc *msgpack.Encoder) error

type KeyValueBind 

type KeyValueBind struct {
	Key   string
	Value interface{}
}

KeyValueBind is a type for encoding named SQL parameters

type Logger 

type Logger interface {
	Report(event ConnLogKind, conn *Connection, v ...interface{})
}

Logger is logger type expected to be passed in options.

type Op 

type Op struct {
	Op    string
	Field int
	Arg   interface{}
}

Op - is update operation.

func (Op) EncodeMsgpack 

func (o Op) EncodeMsgpack(enc *msgpack.Encoder) error

type OpSplice 

type OpSplice struct {
	Op      string
	Field   int
	Pos     int
	Len     int
	Replace string
}

func (OpSplice) EncodeMsgpack 

func (o OpSplice) EncodeMsgpack(enc *msgpack.Encoder) error

type Opts 

type Opts struct {
	// Timeout for any particular request. If Timeout is zero request, any
	// request can be blocked infinitely.
	// Also used to setup net.TCPConn.Set(Read|Write)Deadline.
	Timeout time.Duration
	// Timeout between reconnect attempts. If Reconnect is zero, no
	// reconnect attempts will be made.
	// If specified, then when Tarantool is not reachable or disconnected,
	// new connect attempt is performed after pause.
	// By default, no reconnection attempts are performed,
	// so once disconnected, connection becomes Closed.
	Reconnect time.Duration
	// Maximum number of reconnect failures; after that we give it up to
	// on. If MaxReconnects is zero, the client will try to reconnect
	// endlessly.
	// After MaxReconnects attempts Connection becomes closed.
	MaxReconnects uint
	// Username for logging in to Tarantool.
	User string
	// User password for logging in to Tarantool.
	Pass string
	// RateLimit limits number of 'in-fly' request, i.e. already put into
	// requests queue, but not yet answered by server or timeouted.
	// It is disabled by default.
	// See RLimitAction for possible actions when RateLimit.reached.
	RateLimit uint
	// RLimitAction tells what to do when RateLimit reached:
	//   RLimitDrop - immediatly abort request,
	//   RLimitWait - wait during timeout period for some request to be answered.
	//                If no request answered during timeout period, this request
	//                is aborted.
	//                If no timeout period is set, it will wait forever.
	// It is required if RateLimit is specified.
	RLimitAction uint
	// Concurrency is amount of separate mutexes for request
	// queues and buffers inside of connection.
	// It is rounded upto nearest power of 2.
	// By default it is runtime.GOMAXPROCS(-1) * 4
	Concurrency uint32
	// SkipSchema disables schema loading. Without disabling schema loading,
	// there is no way to create Connection for currently not accessible Tarantool.
	SkipSchema bool
	// Notify is a channel which receives notifications about Connection status
	// changes.
	Notify chan<- ConnEvent
	// Handle is user specified value, that could be retrivied with
	// Handle() method.
	Handle interface{}
	// Logger is user specified logger used for error messages.
	Logger Logger
}

Opts is a way to configure Connection

type Response 

type Response struct {
	RequestId uint32
	Code      uint32
	Error     string // error message
	// Data contains deserialized data for untyped requests
	Data     []interface{}
	MetaData []ColumnMetaData
	SQLInfo  SQLInfo
	// contains filtered or unexported fields
}

func (*Response) String 

func (resp *Response) String() (str string)

String implements Stringer interface.

func (*Response) Tuples 

func (resp *Response) Tuples() (res [][]interface{})

Tuples converts result of Eval and Call17 to same format as other actions returns (i.e. array of arrays).

type SQLInfo 

type SQLInfo struct {
	AffectedCount        uint64
	InfoAutoincrementIds []uint64
}

func (*SQLInfo) DecodeMsgpack 

func (info *SQLInfo) DecodeMsgpack(d *msgpack.Decoder) error

type Schema 

type Schema struct {
	Version uint
	// Spaces is map from space names to spaces.
	Spaces map[string]*Space
	// SpacesById is map from space numbers to spaces.
	SpacesById map[uint32]*Space
}

Schema contains information about spaces and indexes.

Example

Example demonstrates how to retrieve information with space schema. 

conn := example_connect()
defer conn.Close()

schema := conn.Schema
if schema.SpacesById == nil {
	fmt.Println("schema.SpacesById is nil")
}
if schema.Spaces == nil {
	fmt.Println("schema.Spaces is nil")
}

space1 := schema.Spaces["test"]
space2 := schema.SpacesById[516]
fmt.Printf("Space 1 ID %d %s\n", space1.Id, space1.Name)
fmt.Printf("Space 2 ID %d %s\n", space2.Id, space2.Name)

Output:

Space 1 ID 517 test
Space 2 ID 516 schematest

type Space 

type Space struct {
	Id   uint32
	Name string
	// Could be "memtx" or "vinyl".
	Engine    string
	Temporary bool // Is this space temporary?
	// Field configuration is not mandatory and not checked by Tarantool.
	FieldsCount uint32
	Fields      map[string]*Field
	FieldsById  map[uint32]*Field
	// Indexes is map from index names to indexes.
	Indexes map[string]*Index
	// IndexesById is map from index numbers to indexes.
	IndexesById map[uint32]*Index
}

Space contains information about Tarantool's space.

Example

Example demonstrates how to retrieve information with space schema. 

conn := example_connect()
defer conn.Close()

// Save Schema to a local variable to avoid races
schema := conn.Schema
if schema.SpacesById == nil {
	fmt.Println("schema.SpacesById is nil")
}
if schema.Spaces == nil {
	fmt.Println("schema.Spaces is nil")
}

// Access Space objects by name or ID.
space1 := schema.Spaces["test"]
space2 := schema.SpacesById[516] // It's a map.
fmt.Printf("Space 1 ID %d %s %s\n", space1.Id, space1.Name, space1.Engine)
fmt.Printf("Space 1 ID %d %t\n", space1.FieldsCount, space1.Temporary)

// Access index information by name or ID.
index1 := space1.Indexes["primary"]
index2 := space2.IndexesById[3] // It's a map.
fmt.Printf("Index %d %s\n", index1.Id, index1.Name)

// Access index fields information by index.
indexField1 := index1.Fields[0] // It's a slice.
indexField2 := index2.Fields[1] // It's a slice.
fmt.Println(indexField1, indexField2)

// Access space fields information by name or id (index).
spaceField1 := space2.Fields["name0"]
spaceField2 := space2.FieldsById[3]
fmt.Printf("SpaceField 1 %s %s\n", spaceField1.Name, spaceField1.Type)
fmt.Printf("SpaceField 2 %s %s\n", spaceField2.Name, spaceField2.Type)

Output:

Space 1 ID 517 test memtx
Space 1 ID 0 false
Index 0 primary
&{0 unsigned} &{2 string}
SpaceField 1 name0 unsigned
SpaceField 2 name3 unsigned

type StringKey 

type StringKey struct {
	S string
}

UintKey is utility type for passing string key to Select*, Update* and Delete*. It serializes to array with single string element.

func (StringKey) EncodeMsgpack 

func (k StringKey) EncodeMsgpack(enc *msgpack.Encoder) error

type UintKey 

type UintKey struct {
	I uint
}

UintKey is utility type for passing unsigned integer key to Select*, Update* and Delete*. It serializes to array with single integer element.

func (UintKey) EncodeMsgpack 

func (k UintKey) EncodeMsgpack(enc *msgpack.Encoder) error

Source Files

View all Source files

Directories

Path Synopsis
Package with methods to work with a Tarantool cluster considering master discovery.
 Package with methods to work with a Tarantool cluster considering master discovery.
Package with methods to work with a Tarantool cluster.
 Package with methods to work with a Tarantool cluster.
Package with implementation of methods for work with a Tarantool's queue implementations.
 Package with implementation of methods for work with a Tarantool's queue implementations.
Helpers for managing Tarantool process for testing purposes.
 Helpers for managing Tarantool process for testing purposes.
Package with support of Tarantool's UUID data type.
 Package with support of Tarantool's UUID data type.

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.