Pushdown simplest sorting for find command

cmd/ferretdb/main.go

@@ -82,6 +82,7 @@ var cli struct {
 	Test struct {
 		RecordsDir            string `default:"" help:"Experimental: directory for record files."`
 		DisableFilterPushdown bool   `default:"false" help:"Experimental: disable filter pushdown."`
+		EnableSortingPushdown bool   `default:"false" help:"Experimental: enable sorting pushdown."`
 		EnableCursors         bool   `default:"false" help:"Experimental: enable cursors."`
 
 		//nolint:lll // for readability
@@ -339,6 +340,7 @@ func run() {
 
 		TestOpts: registry.TestOpts{
 			DisableFilterPushdown: cli.Test.DisableFilterPushdown,
+			EnableSortPushdown:    cli.Test.EnableSortingPushdown,
 			EnableCursors:         cli.Test.EnableCursors,
 		},
 	})

internal/handlers/common/sort.go

@@ -42,7 +42,7 @@ func SortDocuments(docs []*types.Document, sortDoc *types.Document) error {
 	for i, sortKey := range sortDoc.Keys() {
 		sortField := must.NotFail(sortDoc.Get(sortKey))
 
-		sortType, err := getSortType(sortKey, sortField)
+		sortType, err := GetSortType(sortKey, sortField)
 		if err != nil {
 			return err
 		}
@@ -125,8 +125,8 @@ func (ds *docsSorter) Less(i, j int) bool {
 	return ds.sorts[k](p, q)
 }
 
-// getSortType determines SortType from input sort value.
-func getSortType(key string, value any) (types.SortType, error) {
+// GetSortType determines SortType from input sort value.
+func GetSortType(key string, value any) (types.SortType, error) {
 	sortValue, err := GetWholeNumberParam(value)
 	if err != nil {
 		switch {

internal/handlers/pg/msg_aggregate.go

@@ -190,7 +190,7 @@ func processStagesDocuments(ctx context.Context, p *stagesDocumentsParams) ([]*t
 
 	if err := p.dbPool.InTransaction(ctx, func(tx pgx.Tx) error {
 		var err error
-		iter, err := pgdb.QueryDocuments(ctx, tx, p.qp)
+		iter, _, err := pgdb.QueryDocuments(ctx, tx, p.qp)
 		if err != nil {
 			return err
 		}

internal/handlers/pg/msg_delete.go

@@ -199,7 +199,7 @@ func execDelete(ctx context.Context, dp *execDeleteParams) (int32, error) {
 	}
 
 	err := dp.dbPool.InTransaction(ctx, func(tx pgx.Tx) error {
-		iter, err := pgdb.QueryDocuments(ctx, tx, dp.qp)
+		iter, _, err := pgdb.QueryDocuments(ctx, tx, dp.qp)
 		if err != nil {
 			return err
 		}

internal/handlers/pg/msg_explain.go

@@ -73,6 +73,11 @@
 		return nil, lazyerrors.Error(err)
 	}
 
+	qp.Sort, err = common.GetOptionalParam[*types.Document](explain, "sort", nil)
+	if err != nil {
+		return nil, lazyerrors.Error(err)
+	}
+
 	if command.Command() == "aggregate" {
 		var pipeline *types.Array
 		pipeline, err = common.GetRequiredParam[*types.Array](explain, "pipeline")
@@ -103,20 +108,22 @@
 		qp.Filter = nil
 	}
 
+	if !h.EnableSortPushdown {
+		qp.Sort = nil
+	}
+
 	var queryPlanner *types.Document
+	var results pgdb.QueryResults
+
 	err = dbPool.InTransaction(ctx, func(tx pgx.Tx) error {
 		var err error
-		queryPlanner, err = pgdb.Explain(ctx, tx, &qp)
+		queryPlanner, results, err = pgdb.Explain(ctx, tx, &qp)
 		return err
 	})
 	if err != nil {
 		return nil, err
 	}
 
-	// if the plan returned filter info or index info, it means that pushdown had been done
-	pushdown := queryPlanner.HasByPath(types.NewStaticPath("Plan", "Filter")) ||
-		queryPlanner.HasByPath(types.NewStaticPath("Plan", "Index Cond"))
-
 	hostname, err := os.Hostname()
 	if err != nil {
 		return nil, lazyerrors.Error(err)
@@ -138,7 +145,8 @@
 			"queryPlanner", queryPlanner,
 			"explainVersion", "1",
 			"command", cmd,
-			"pushdown", pushdown,
+			"pushdown", results.FilterPushdown,
+			"sortingPushdown", results.SortPushdown,
 			"serverInfo", serverInfo,
 			"ok", float64(1),
 		))},

internal/handlers/pg/msg_find.go

@@ -74,15 +74,20 @@
 		qp.Filter = params.Filter
 	}
 
+	if h.EnableSortPushdown && params.Projection == nil {
+		qp.Sort = params.Sort
+	}
+
 	var resDocs []*types.Document
 	err = dbPool.InTransaction(ctx, func(tx pgx.Tx) error {
 		if params.BatchSize == 0 {
 			return nil
 		}
 
 		var iter types.DocumentsIterator
+		var queryRes pgdb.QueryResults
 
-		iter, err = pgdb.QueryDocuments(ctx, tx, qp)
+		iter, queryRes, err = pgdb.QueryDocuments(ctx, tx, qp)
 		if err != nil {
 			return lazyerrors.Error(err)
 		}
@@ -92,18 +97,20 @@
 
 		iter = common.FilterIterator(iter, closer, params.Filter)
 
-		iter, err = common.SortIterator(iter, closer, params.Sort)
-		if err != nil {
-			var pathErr *types.DocumentPathError
-			if errors.As(err, &pathErr) && pathErr.Code() == types.ErrDocumentPathEmptyKey {
-				return commonerrors.NewCommandErrorMsgWithArgument(
-					commonerrors.ErrPathContainsEmptyElement,
-					"Empty field names in path are not allowed",
-					document.Command(),
-				)
+		if !queryRes.SortPushdown {
+			iter, err = common.SortIterator(iter, closer, params.Sort)
+			if err != nil {
+				var pathErr *types.DocumentPathError
+				if errors.As(err, &pathErr) && pathErr.Code() == types.ErrDocumentPathEmptyKey {
+					return commonerrors.NewCommandErrorMsgWithArgument(
+						commonerrors.ErrPathContainsEmptyElement,
+						"Empty field names in path are not allowed",
+						document.Command(),
+					)
+				}
+
+				return lazyerrors.Error(err)
 			}
-
-			return lazyerrors.Error(err)
 		}
 
 		iter = common.SkipIterator(iter, closer, params.Skip)
@@ -181,7 +188,7 @@
 		fp.qp.Filter = nil
 	}
 
-	iter, err := pgdb.QueryDocuments(ctx, fp.tx, fp.qp)
+	iter, _, err := pgdb.QueryDocuments(ctx, fp.tx, fp.qp)
 	if err != nil {
 		return nil, err
 	}

internal/handlers/pg/pg.go

@@ -54,6 +54,7 @@ type NewOpts struct {
 
 	// test options
 	DisableFilterPushdown bool
+	EnableSortPushdown    bool
 	EnableCursors         bool
 }
 

internal/handlers/pg/pgdb/collections.go

@@ -50,7 +50,7 @@ func Collections(ctx context.Context, tx pgx.Tx, db string) ([]string, error) {
 		return []string{}, nil
 	}
 
-	iter, err := buildIterator(ctx, tx, &iteratorParams{
+	iter, _, err := buildIterator(ctx, tx, &iteratorParams{
 		schema: db,
 		table:  dbMetadataTableName,
 	})

internal/handlers/pg/pgdb/database_metadata.go

@@ -200,7 +200,7 @@ func (ms *metadataStorage) get(ctx context.Context, forUpdate bool) (*metadata,
 		forUpdate: forUpdate,
 	}
 
-	iter, err := buildIterator(ctx, ms.tx, iterParams)
+	iter, _, err := buildIterator(ctx, ms.tx, iterParams)
 	if err != nil {
 		return nil, lazyerrors.Error(err)
 	}