Schema lookups for spaces and indexes

Author: tehmaze

Diff for: schema.go

@@ -0,0 +1,260 @@
+package tarantool
+
+import "errors"
+
+const (
+	SpaceSchema  = 272
+	SpaceSpace   = 280
+	SpaceIndex   = 288
+	SpaceFunc    = 296
+	SpaceVSpace  = 281
+	SpaceVIndex  = 289
+	SpaceVFunc   = 297
+	SpaceUser    = 304
+	SpacePriv    = 312
+	SpaceCluster = 320
+)
+
+const (
+	IndexSpacePrimary = 0
+	IndexSpaceName    = 2
+	IndexIndexPrimary = 0
+	IndexIndexName    = 2
+)
+
+// Space implements lookups on a box.space
+type Space struct {
+	No      uint32
+	Name    string
+	Type    string
+	schema  *Schema
+	index   map[string]*Index
+	indexNo map[uint32]*Index
+}
+
+func newSpace(schema *Schema, no uint32, name, kind string) *Space {
+	return &Space{
+		No:      no,
+		Name:    name,
+		Type:    kind,
+		schema:  schema,
+		index:   make(map[string]*Index),
+		indexNo: make(map[uint32]*Index),
+	}
+}
+
+// Index resolves an index by name
+func (space *Space) Index(name string) (index *Index, err error) {
+	var ok bool
+	if index, ok = space.index[name]; ok {
+		return
+	}
+
+	var res *Response
+	if res, err = space.schema.conn.Select(SpaceVIndex, IndexIndexName, 0, 1, 0, []interface{}{space.No, name}); err != nil {
+		return
+	}
+	if res.Data == nil || len(res.Data) == 0 {
+		if res, err = space.schema.conn.Select(SpaceIndex, IndexIndexName, 0, 1, 0, []interface{}{space.No, name}); err != nil {
+			return
+		}
+	}
+
+	var row []interface{}
+	if res.Data == nil || len(res.Data) == 0 {
+		return nil, errors.New(`no such space`)
+	}
+	if row, ok = res.Data[0].([]interface{}); !ok {
+		return nil, errors.New(`unexpected result`)
+	}
+
+	return space.add(row)
+}
+
+func (space *Space) IndexNo(no uint32) (index *Index, err error) {
+	var ok bool
+	if index, ok = space.indexNo[no]; ok {
+		return
+	}
+
+	var res *Response
+	if res, err = space.schema.conn.Select(SpaceVIndex, IndexIndexPrimary, 0, 1, 0, []interface{}{space.No, no}); err != nil {
+		return
+	}
+	if res.Data == nil || len(res.Data) == 0 {
+		if res, err = space.schema.conn.Select(SpaceIndex, IndexIndexPrimary, 0, 1, 0, []interface{}{space.No, no}); err != nil {
+			return
+		}
+	}
+
+	var row []interface{}
+	if res.Data == nil || len(res.Data) == 0 {
+		return nil, errors.New(`no such index`)
+	}
+	if row, ok = res.Data[0].([]interface{}); !ok {
+		return nil, errors.New(`unexpected result`)
+	}
+
+	return space.add(row)
+}
+
+func (space *Space) Indexes() ([]*Index, error) {
+	var (
+		res   *Response
+		row   []interface{}
+		index *Index
+		err   error
+		ok    bool
+	)
+
+	if res, err = space.schema.conn.Select(SpaceIndex, IndexIndexPrimary, 0, 0xffffffff, 0, []interface{}{space.No}); err != nil {
+		return nil, err
+	}
+
+	indexes := make([]*Index, len(res.Data))
+	for i, raw := range res.Data {
+		if row, ok = raw.([]interface{}); !ok {
+			return nil, errors.New("unexpected result")
+		}
+
+		if index, err = space.add(row); err != nil {
+			return nil, err
+		}
+
+		indexes[i] = index
+	}
+
+	return indexes, nil
+}
+
+func (space *Space) add(row []interface{}) (index *Index, err error) {
+	if row == nil || len(row) == 0 {
+		return nil, errors.New(`no such index`)
+	}
+
+	index = &Index{Space: space, No: uint32(row[1].(uint64)), Name: row[2].(string)}
+	space.index[index.Name] = index
+	space.indexNo[index.No] = index
+
+	return
+}
+
+type Index struct {
+	Space *Space
+	No    uint32
+	Name  string
+}
+
+// Schema gives access to the schema definition, such as indexes and spaces.
+type Schema struct {
+	conn    *Connection
+	space   map[string]*Space
+	spaceNo map[uint32]*Space
+}
+
+func (conn *Connection) NewSchema() *Schema {
+	return &Schema{
+		conn:    conn,
+		space:   make(map[string]*Space),
+		spaceNo: make(map[uint32]*Space),
+	}
+}
+
+// Space resolves a space by name
+func (schema *Schema) Space(name string) (space *Space, err error) {
+	var ok bool
+	if space, ok = schema.space[name]; ok {
+		return
+	}
+
+	var res *Response
+	if res, err = schema.conn.Select(SpaceVSpace, IndexSpaceName, 0, 1, 0, []interface{}{name}); err != nil {
+		return
+	}
+	if res.Data == nil || len(res.Data) == 0 {
+		if res, err = schema.conn.Select(SpaceSpace, IndexSpaceName, 0, 1, 0, []interface{}{name}); err != nil {
+			return
+		}
+	}
+
+	var row []interface{}
+	if res.Data == nil || len(res.Data) == 0 {
+		return nil, errors.New(`no such space`)
+	}
+	if row, ok = res.Data[0].([]interface{}); !ok {
+		return nil, errors.New(`unexpected result`)
+	}
+
+	return schema.add(row)
+}
+
+// SpaceNo resolves a space by number
+func (schema *Schema) SpaceNo(no uint32) (space *Space, err error) {
+	var ok bool
+
+	if space, ok = schema.spaceNo[no]; ok {
+		return
+	}
+
+	var res *Response
+	if res, err = schema.conn.Select(SpaceVSpace, IndexSpacePrimary, 0, 1, 0, []interface{}{no}); err != nil {
+		return
+	}
+	if res.Data == nil || len(res.Data) == 0 {
+		if res, err = schema.conn.Select(SpaceSpace, IndexSpacePrimary, 0, 1, 0, []interface{}{no}); err != nil {
+			return
+		}
+	}
+
+	var row []interface{}
+	if res.Data == nil || len(res.Data) == 0 {
+		return nil, errors.New(`no such space`)
+	}
+	if row, ok = res.Data[0].([]interface{}); !ok {
+		return nil, errors.New(`unexpected result`)
+	}
+
+	return schema.add(row)
+}
+
+// Spaces retrieves all spaces for a schema
+func (schema *Schema) Spaces() ([]*Space, error) {
+	var (
+		res   *Response
+		row   []interface{}
+		space *Space
+		err   error
+		ok    bool
+	)
+
+	if res, err = schema.conn.Select(SpaceSpace, 0, 0, 0xffffffff, 0, []interface{}{}); err != nil {
+		return nil, err
+	}
+
+	spaces := make([]*Space, len(res.Data))
+	for i, raw := range res.Data {
+		if row, ok = raw.([]interface{}); !ok {
+			return nil, errors.New("unexpected result")
+		}
+
+		if space, err = schema.add(row); err != nil {
+			return nil, err
+		}
+
+		spaces[i] = space
+	}
+
+	return spaces, nil
+}
+
+func (schema *Schema) add(row []interface{}) (space *Space, err error) {
+	if row == nil || len(row) == 0 {
+		return nil, errors.New(`no such space`)
+	}
+
+	space = newSpace(schema, uint32(row[0].(uint64)), row[2].(string), row[3].(string))
+	schema.space[space.Name] = space
+	schema.spaceNo[space.No] = space
+
+	return
+}