使用 golang for MongoDB 创建分页过滤器

我有一个很大的过滤器，我将提供它的一个片段。我试图通过异教化过滤器的映射，但收到错误消息

the match filter must be an expression in an object

获取过滤器

func (app *courses) getfilter(filter *filter) ([]bson.m, error) {
    
        pipeline := make([]bson.m, 0)
    
        if filter.all {
            // include all items
        } else {
            // filter items based on the provided criteria
            if filter.beginner {
                pipeline = append(pipeline, bson.m{"tags": "beginner"})
            }
            if filter.advanced {
                pipeline = append(pipeline, bson.m{"tags": "advanced"})
            }
            if filter.Go {
                pipeline = append(pipeline, bson.m{"tags": "go"})
            }
        }
    
        return pipeline, nil
    }

处理程序

func (app *courses) coursesallhandler(w Http.responsewriter, r *http.request) {
    ctx := context.background()

    clog := log.getloggerfromcontext(ctx)

    p := r.url.query().get("page")
    ps := r.url.query().get("pagesize")

    var filter filter
    err := JSON.newdecoder(r.body).decode(&filter)
    if err != nil {
        http.error(w, "failed to parse request body", http.statusbadrequest)
        return
    }

    pipeline := make([]bson.m, 0)

    page, _ := strconv.atoi(p)
    pagesize, _ := strconv.atoi(ps)

    // pagination
    skip := (page - 1) * pagesize
    limit := pagesize

    // add filter
    pipeline, err = app.getfilter(&filter)
    if err != nil {
        clog.error(err)
    }
    pipeline = append(pipeline, bson.m{"$match": pipeline})

    // add pagination stages to the pipeline
    pipeline = append(pipeline, bson.m{"$skip": skip})
    pipeline = append(pipeline, bson.m{"$limit": limit})

    res, err := app.repo.getall(ctx, pipeline)
    if err != nil {
        clog.error(err)

        return
    }

    err = app.helper.writejson(w, http.statusok, envelope{"data": res, "metadata": "none"}, nil)
    if err != nil {
        clog.errorctx(err, log.ctx{
            "header":      w.header(),
            "request_url": r.url.string(),
        })
    }

}

如何获取设置为“true”或“false”的值，将它们放入地图中并在查询中提交它们以匹配数据库，就像我在这里尝试做的那样。

// add filter
pipeline, err = app.getfilter(&filter)
if err != nil {
    clog.error(err)
}
pipeline = append(pipeline, bson.m{"$match": pipeline})

----更新----

我现在有：

func (app *courses) coursesallhandler(w http.responsewriter, r *http.request) {
    ctx := context.background()

clog := log.getloggerfromcontext(ctx)

var filter filter
err := json.newdecoder(r.body).decode(&filter)
if err != nil {
    http.error(w, "failed to parse request body", http.statusbadrequest)
    return
}

filter.all = true

pipeline := make([]bson.m, 3)

// add filter
matches, err := app.getfilter(&filter)
if err != nil {
    clog.error(err)
}

pipeline[0] = bson.m{"$skip": 1}
pipeline[1] = bson.m{"$limit": 5}
pipeline[2] = bson.m{"$match": matches}


res, err := app.repo.getall(ctx, pipeline)
if err != nil {
    clog.error(err)

    return
}

err = app.helper.writejson(w, http.statusok, envelope{"data": res, "metadata": "none"}, nil)
if err != nil {
    clog.errorctx(err, log.ctx{
        "header":      w.header(),
        "request_url": r.url.string(),
    })
 }

}

过滤器看起来像

func (app *courses) getfilter(filter *filter) (bson.m, error) {

    match := bson.m{}
    tags := []string{}

    if filter.all {
        // include all items
        tags = append(tags, "beginner")
        tags = append(tags, "intermediate")
        .....
    } else {
        // filter items based on the provided criteria
        if filter.beginner {
            tags = append(tags, "beginner")
        }
        if filter.advanced {
            tags = append(tags, "advanced")
        }
        if filter.go {
            tags = append(tags, "go")
        }
        ........

    }

    match = bson.m{
        "tags": bson.m{"$in": tags},
    }

    return match, nil
}

稍后将在这里使用..

func (r *CourseRepo) GetAll(ctx context.Context, pipeline []bson.M) ([]Course, error) {
    clog := log.GetLoggerFromContext(ctx)

    cur, err := r.collection.Aggregate(ctx, pipeline)

    ...

但是它是空的。过滤器中的所有内容均已选择，没有错误。

正确答案

您得到的 匹配过滤器必须是对象 中的表达式，因为 $match 需要一个对象 (bson.m)，但您已经给了 slice 对象 ([]bson.m)。

试试这个

func (app *Courses) getFilter(filter *Filter) (bson.M, error) {
    match := bson.M{}
    tags := []string{}

    if filter.All {
        // Include all items
    } else {
        // Filter items based on the provided criteria
        if filter.Beginner {
            tags = append(tags, "beginner")
        }
        if filter.Advanced {
            tags = append(tags, "advanced")

        }
        if filter.Go {
            tags = append(tags, "go")
        }

        match = bson.M{
            "tags": bson.M{"$in": tags},
        }
    }

    return match, nil
}

以上就是使用 golang for mongoDB 创建分页过滤器的详细内容，更多请关注编程网其它相关文章！