FerretDB · rumyantseva · Oct 5, 2023 · Sep 26, 2023 · Sep 26, 2023 · Sep 26, 2023
@@ -43,5 +43,8 @@
 // But there are some common tests for all backends that check corner cases in contracts.
 // They also test that all backends adjusted to contract changes.
 //
+// Some backends may have their own tests.
+//
+// Both kinds of tests could be removed over time as they are replaced by integration tests.
 // Prefer integration tests when possible.
 package backends
@@ -72,7 +72,7 @@ func TestDatabaseStats(t *testing.T) {
 		require.NotZero(t, res.SizeCollections)
 		require.Zero(t, res.CountObjects)
 		require.Zero(t, res.CountIndexes)
-		require.Zero(t, res.SizeIndexes)
+		require.NotZero(t, res.SizeIndexes) // includes metadata table's indexes
 	})
 
 	t.Run("DatabaseWithCollections", func(t *testing.T) {

@@ -0,0 +1,21 @@
+// Copyright 2021 FerretDB Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package postgresql
+
+import "testing"
+
+func TestDummy(t *testing.T) {
+	// we need at least one test per package to correctly calculate coverage
+}
@@ -0,0 +1,139 @@
+// Copyright 2021 FerretDB Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package metadata
+
+import (
+	"errors"
+
+	"golang.org/x/exp/slices"
+
+	"github.com/FerretDB/FerretDB/internal/types"
+	"github.com/FerretDB/FerretDB/internal/util/iterator"
+	"github.com/FerretDB/FerretDB/internal/util/lazyerrors"
+	"github.com/FerretDB/FerretDB/internal/util/must"
+)
+
+// Indexes represents information about all indexes in a collection.
+type Indexes []IndexInfo
+
+// IndexInfo represents information about a single index.
+type IndexInfo struct {
+	Name    string
+	PgIndex string
+	Key     []IndexKeyPair
+	Unique  bool
+}
+
+// IndexKeyPair consists of a field name and a sort order that are part of the index.
+type IndexKeyPair struct {
+	Field      string
+	Descending bool
+}
+
+// deepCopy returns a deep copy.
+func (indexes Indexes) deepCopy() Indexes {
+	res := make(Indexes, len(indexes))
+
+	for i, index := range indexes {
+		res[i] = IndexInfo{
+			Name:    index.Name,
+			PgIndex: index.PgIndex,
+			Key:     slices.Clone(index.Key),
+			Unique:  index.Unique,
+		}
+	}
+
+	return res
+}
+
+// marshal returns [*types.Array] for indexes.
+func (indexes Indexes) marshal() *types.Array {
+	res := types.MakeArray(len(indexes))
+
+	for _, index := range indexes {
+		key := types.MakeDocument(len(index.Key))
+
+		for _, pair := range index.Key {
+			order := int32(1)
+			if pair.Descending {
+				order = int32(-1)
+			}
+
+			key.Set(pair.Field, order)
+		}
+
+		res.Append(must.NotFail(types.NewDocument(
+			"pgindex", index.PgIndex,
+			"name", index.Name,
+			"key", key,
+			"unique", index.Unique,
+		)))
+	}
+
+	return res
+}
+
+// unmarshal sets indexes from [*types.Array].
+func (s *Indexes) unmarshal(a *types.Array) error {
+	res := make(Indexes, a.Len())
+
+	iter := a.Iterator()
+	defer iter.Close()
+
+	for {
+		i, v, err := iter.Next()
+		if errors.Is(err, iterator.ErrIteratorDone) {
+			break
+		}
+
+		if err != nil {
+			return lazyerrors.Error(err)
+		}
+
+		index := v.(*types.Document)
+
+		keyDoc := must.NotFail(index.Get("key")).(*types.Document)
+		fields := keyDoc.Keys()
+		orders := keyDoc.Values()
+		key := make([]IndexKeyPair, keyDoc.Len())
+
+		for j, f := range fields {
+			descending := false
+			if orders[j].(int32) == -1 {
+				descending = true
+			}
+
+			key[j] = IndexKeyPair{
+				Field:      f,
+				Descending: descending,
+			}
+		}
+
+		// it was possible for it to be null in pgdb
+		v, _ = index.Get("unique")
+		unique, _ := v.(bool)
+
+		res[i] = IndexInfo{
+			Name:    must.NotFail(index.Get("name")).(string),
+			PgIndex: must.NotFail(index.Get("pgindex")).(string),
+			Key:     key,
+			Unique:  unique,
+		}
+	}
+
+	*s = res
+
+	return nil
+}
@@ -16,7 +16,12 @@
 package metadata
 
 import (
+	"database/sql"
+	"database/sql/driver"
+
+	"github.com/FerretDB/FerretDB/internal/handlers/sjson"
 	"github.com/FerretDB/FerretDB/internal/types"
+	"github.com/FerretDB/FerretDB/internal/util/lazyerrors"
 	"github.com/FerretDB/FerretDB/internal/util/must"
 )
 
@@ -29,10 +34,13 @@
 )
 
 // Collection represents collection metadata.
+//
+// Collection value should be immutable to avoid data races.
+// Use [deepCopy] to replace the whole value instead of modifying fields of existing value.
 type Collection struct {
 	Name      string
 	TableName string
-	// TODO https://github.com/FerretDB/FerretDB/issues/3375
+	Indexes   Indexes
 }
 
 // deepCopy returns a deep copy.
@@ -44,21 +52,89 @@
 	return &Collection{
 		Name:      c.Name,
 		TableName: c.TableName,
+		Indexes:   c.Indexes.deepCopy(),
+	}
+}
+
+// Value implements driver.Valuer interface.
+func (c Collection) Value() (driver.Value, error) {
+	b, err := sjson.Marshal(c.marshal())
+	if err != nil {
+		return nil, lazyerrors.Error(err)
 	}
+
+	return b, nil
 }
 
-// Marshal returns [*types.Document] for that collection.
-func (c *Collection) Marshal() *types.Document {
+// Scan implements sql.Scanner interface.
+func (c *Collection) Scan(src any) error {
+	var doc *types.Document
+	var err error
+
+	switch src := src.(type) {
+	case nil:
+		*c = Collection{}
+		return nil
+	case []byte:
+		doc, err = sjson.Unmarshal(src)
+	case string:
+		doc, err = sjson.Unmarshal([]byte(src))
+	default:
+		panic("can't scan collection")
+	}
+
+	if err != nil {
+		return lazyerrors.Error(err)
+	}
+
+	if err = c.unmarshal(doc); err != nil {
+		return lazyerrors.Error(err)
+	}
+
+	return nil
+}
+
+// marshal returns [*types.Document] for that collection.
+func (c *Collection) marshal() *types.Document {
 	return must.NotFail(types.NewDocument(
 		"_id", c.Name,
 		"table", c.TableName,
+		"indexes", c.Indexes.marshal(),
 	))
 }
 
-// Unmarshal sets collection metadata from [*types.Document].
-func (c *Collection) Unmarshal(doc *types.Document) error {
-	c.Name = must.NotFail(doc.Get("_id")).(string)
-	c.TableName = must.NotFail(doc.Get("table")).(string)
+// unmarshal sets collection metadata from [*types.Document].
+func (c *Collection) unmarshal(doc *types.Document) error {
+	v, _ := doc.Get("_id")
+	c.Name, _ = v.(string)
+
+	if c.Name == "" {
+		return lazyerrors.New("collection name is empty")
+	}
+
+	v, _ = doc.Get("table")
+	c.TableName, _ = v.(string)
+
+	if c.TableName == "" {
+		return lazyerrors.New("table name is empty")
+	}
+
+	v, _ = doc.Get("indexes")
+	i, _ := v.(*types.Array)
+
+	if i == nil {
+		return lazyerrors.New("indexes are empty")
+	}
+
+	if err := c.Indexes.unmarshal(i); err != nil {
+		return lazyerrors.Error(err)
+	}
 
 	return nil
 }
+
+// check interfaces
+var (
+	_ driver.Valuer = Collection{}
+	_ sql.Scanner   = (*Collection)(nil)
+)
@@ -0,0 +1,21 @@
+// Copyright 2021 FerretDB Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pool
+
+import "testing"
+
+func TestDummy(t *testing.T) {
+	// we need at least one test per package to correctly calculate coverage
+}