api: write a connection schema getter

Write a helper function to load the actual schema for the user.

Previously we stored actual schema in a private `schemaResolver`
field and `Schema` field was used only to get a current schema.
But now because of the new function, we don't need to store the
`Schema` as a different field. So `Schema` was also removed.

To update the schema, used needs to use `GetSchema` + `OverrideSchema`
in pair.

Closes #7

Author: DerekBum

CHANGELOG.md

@@ -26,6 +26,7 @@ Versioning](http://semver.org/spec/v2.0.0.html) except to the first release.
 - Support `IPROTO_FEATURE_SPACE_AND_INDEX_NAMES` for Tarantool
   version >= 3.0.0-alpha1 (#338). It allows to use space and index names 
   in requests instead of their IDs.
+- `GetSchema` function to get the actual schema used by the connection (#7)
 
 ### Changed
 
@@ -70,6 +71,7 @@ Versioning](http://semver.org/spec/v2.0.0.html) except to the first release.
 - UUID_extId (#158)
 - IPROTO constants (#158)
 - Code() method from the Request interface (#158)
+- `Schema` field from the `Connection` struct (#7)
 
 ### Fixed
 

README.md

@@ -248,6 +248,12 @@ now does not attempt to reconnect and tries to establish a connection only once.
 Function might be canceled via context. Context accepted as first argument, 
 and user may cancel it in process.
 
+#### Connection Schema
+
+Removed `Schema` field from the `Connection` struct. Instead, new 
+`GetSchema(*Connection)` function was added to get the actual connection 
+schema on demand.
+
 #### Protocol changes
 
 * `iproto.Feature` type used instead of `ProtocolFeature`.

connection.go

@@ -160,8 +160,6 @@ type Connection struct {
 	c     Conn
 	mutex sync.Mutex
 	cond  *sync.Cond
-	// Schema contains schema loaded on connection.
-	Schema *Schema
 	// schemaResolver contains a SchemaResolver implementation.
 	schemaResolver SchemaResolver
 	// requestId contains the last request ID for requests with nil context.
@@ -436,12 +434,14 @@ func Connect(ctx context.Context, addr string, opts Opts) (conn *Connection, err
 
 	// TODO: reload schema after reconnect.
 	if !conn.opts.SkipSchema {
-		if err = conn.loadSchema(); err != nil {
+		schema, err := GetSchema(conn)
+		if err != nil {
 			conn.mutex.Lock()
 			defer conn.mutex.Unlock()
 			conn.closeConnection(err, true)
 			return nil, err
 		}
+		conn.OverrideSchema(schema)
 	}
 
 	return conn, err
@@ -1305,12 +1305,19 @@ func (conn *Connection) ConfiguredTimeout() time.Duration {
 // OverrideSchema sets Schema for the connection.
 func (conn *Connection) OverrideSchema(s *Schema) {
 	if s != nil {
+		spaceAndIndexNamesSupported :=
+			isFeatureInSlice(iproto.IPROTO_FEATURE_SPACE_AND_INDEX_NAMES,
+				conn.serverProtocolInfo.Features)
+
 		conn.mutex.Lock()
 		defer conn.mutex.Unlock()
 		conn.lockShards()
 		defer conn.unlockShards()
 
-		conn.Schema = s
+		conn.schemaResolver = &loadedSchemaResolver{
+			Schema:                      s,
+			SpaceAndIndexNamesSupported: spaceAndIndexNamesSupported,
+		}
 	}
 }
 

example_test.go

@@ -1063,7 +1063,10 @@ func ExampleSchema() {
 	conn := exampleConnect(opts)
 	defer conn.Close()
 
-	schema := conn.Schema
+	schema, err := tarantool.GetSchema(conn)
+	if err != nil {
+		fmt.Printf("unexpected error: %s\n", err.Error())
+	}
 	if schema.SpacesById == nil {
 		fmt.Println("schema.SpacesById is nil")
 	}
@@ -1080,13 +1083,30 @@ func ExampleSchema() {
 	// Space 2 ID 616 schematest
 }
 
+// Example demonstrates how to update the connection schema.
+func ExampleSchema_update() {
+	conn := exampleConnect(opts)
+	defer conn.Close()
+
+	// Get the actual schema, used by the connection.
+	schema, err := tarantool.GetSchema(conn)
+	if err != nil {
+		fmt.Printf("unexpected error: %s\n", err.Error())
+	}
+	// Update the current schema to match the actual one.
+	conn.OverrideSchema(schema)
+}
+
 // Example demonstrates how to retrieve information with space schema.
 func ExampleSpace() {
 	conn := exampleConnect(opts)
 	defer conn.Close()
 
 	// Save Schema to a local variable to avoid races
-	schema := conn.Schema
+	schema, err := tarantool.GetSchema(conn)
+	if err != nil {
+		fmt.Printf("unexpected error: %s\n", err.Error())
+	}
 	if schema.SpacesById == nil {
 		fmt.Println("schema.SpacesById is nil")
 	}

request_test.go

@@ -78,6 +78,10 @@ func (r *ValidSchemeResolver) NamesUseSupported() bool {
 	return r.nameUseSupported
 }
 
+func (r *ValidSchemeResolver) GetSchema() *Schema {
+	return nil
+}
+
 var resolver ValidSchemeResolver
 
 func assertBodyCall(t testing.TB, requests []Request, errorMsg string) {

schema.go

@@ -4,7 +4,6 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/tarantool/go-iproto"
 	"github.com/vmihailenco/msgpack/v5"
 	"github.com/vmihailenco/msgpack/v5/msgpcode"
 )
@@ -52,6 +51,8 @@ type SchemaResolver interface {
 	// IDs, is supported. It must return true if
 	// iproto.IPROTO_FEATURE_SPACE_AND_INDEX_NAMES is supported.
 	NamesUseSupported() bool
+	// GetSchema returns inner Schema.
+	GetSchema() *Schema
 }
 
 // Schema contains information about spaces and indexes.
@@ -340,16 +341,16 @@ func (indexField *IndexField) DecodeMsgpack(d *msgpack.Decoder) error {
 	return errors.New("unexpected schema format (index fields)")
 }
 
-func (conn *Connection) loadSchema() (err error) {
+func GetSchema(conn *Connection) (*Schema, error) {
 	schema := new(Schema)
 	schema.SpacesById = make(map[uint32]*Space)
 	schema.Spaces = make(map[string]*Space)
 
 	// Reload spaces.
 	var spaces []*Space
-	err = conn.SelectTyped(vspaceSpId, 0, 0, maxSchemas, IterAll, []interface{}{}, &spaces)
+	err := conn.SelectTyped(vspaceSpId, 0, 0, maxSchemas, IterAll, []interface{}{}, &spaces)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	for _, space := range spaces {
 		schema.SpacesById[space.Id] = space
@@ -360,31 +361,19 @@ func (conn *Connection) loadSchema() (err error) {
 	var indexes []*Index
 	err = conn.SelectTyped(vindexSpId, 0, 0, maxSchemas, IterAll, []interface{}{}, &indexes)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	for _, index := range indexes {
 		spaceId := index.SpaceId
 		if _, ok := schema.SpacesById[spaceId]; ok {
 			schema.SpacesById[spaceId].IndexesById[index.Id] = index
 			schema.SpacesById[spaceId].Indexes[index.Name] = index
 		} else {
-			return errors.New("concurrent schema update")
+			return nil, errors.New("concurrent schema update")
 		}
 	}
 
-	spaceAndIndexNamesSupported :=
-		isFeatureInSlice(iproto.IPROTO_FEATURE_SPACE_AND_INDEX_NAMES,
-			conn.serverProtocolInfo.Features)
-
-	conn.lockShards()
-	conn.Schema = schema
-	conn.schemaResolver = &loadedSchemaResolver{
-		Schema:                      schema,
-		SpaceAndIndexNamesSupported: spaceAndIndexNamesSupported,
-	}
-	conn.unlockShards()
-
-	return nil
+	return schema, nil
 }
 
 // resolveSpaceNumber tries to resolve a space number.
@@ -502,6 +491,10 @@ func (r *loadedSchemaResolver) NamesUseSupported() bool {
 	return r.SpaceAndIndexNamesSupported
 }
 
+func (r *loadedSchemaResolver) GetSchema() *Schema {
+	return r.Schema
+}
+
 type noSchemaResolver struct {
 	// SpaceAndIndexNamesSupported shows if a current Tarantool version supports
 	// iproto.IPROTO_FEATURE_SPACE_AND_INDEX_NAMES.
@@ -527,3 +520,7 @@ func (*noSchemaResolver) ResolveIndex(i interface{}, spaceNo uint32) (uint32, er
 func (r *noSchemaResolver) NamesUseSupported() bool {
 	return r.SpaceAndIndexNamesSupported
 }
+
+func (r *noSchemaResolver) GetSchema() *Schema {
+	return nil
+}

settings/request_test.go

@@ -28,6 +28,10 @@ func (r *ValidSchemeResolver) NamesUseSupported() bool {
 	return false
 }
 
+func (r *ValidSchemeResolver) GetSchema() *tarantool.Schema {
+	return nil
+}
+
 var resolver ValidSchemeResolver
 
 func TestRequestsAPI(t *testing.T) {

tarantool_test.go

@@ -1851,6 +1851,19 @@ func TestConnection_DoWithStrangerConn(t *testing.T) {
 	}
 }
 
+func TestGetSchema(t *testing.T) {
+	conn := test_helpers.ConnectWithValidation(t, server, opts)
+	defer conn.Close()
+
+	s, err := GetSchema(conn)
+	if err != nil {
+		t.Errorf("unexpected error: %s", err.Error())
+	}
+	if s.Version != 0 || s.Spaces[spaceName].Id != spaceNo {
+		t.Errorf("GetSchema() returns incorrect schema")
+	}
+}
+
 func TestNewPreparedFromResponse(t *testing.T) {
 	var (
 		ErrNilResponsePassed = fmt.Errorf("passed nil response")
@@ -1882,7 +1895,10 @@ func TestSchema(t *testing.T) {
 	defer conn.Close()
 
 	// Schema
-	schema := conn.Schema
+	schema, err := GetSchema(conn)
+	if err != nil {
+		t.Errorf("unexpected error: %s", err.Error())
+	}
 	if schema.SpacesById == nil {
 		t.Errorf("schema.SpacesById is nil")
 	}
@@ -2028,7 +2044,10 @@ func TestSchema_IsNullable(t *testing.T) {
 	conn := test_helpers.ConnectWithValidation(t, server, opts)
 	defer conn.Close()
 
-	schema := conn.Schema
+	schema, err := GetSchema(conn)
+	if err != nil {
+		t.Errorf("unexpected error: %s", err.Error())
+	}
 	if schema.Spaces == nil {
 		t.Errorf("schema.Spaces is nil")
 	}