Go MongoDB嵌套查询与$lookup开发者社区

link管理

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

文章/答案/技术大牛

发布

type Match struct {
    ID        primitive.ObjectID `json:"_id,omitempty" bson:"_id,omitempty"`
    PartnerA  Partner            `json:"partnerA" bson:"partnerA"`
    PartnerB  Partner            `json:"partnerB" bson:"partnerB"`
    Unlocked  bool               `json:"unlocked" bson:"unlocked"`
    DeletedAt time.Time          `json:"deletedAt,omitempty" bson:"deletedAt,omitempty"`
type Partner struct {
    ID               primitive.ObjectID `json:"id,omitempty" bson:"id,omitempty"`
    Offer            LiteOffer          `json:"offer,omitempty" bson:"offer,omitempty"`
    LooksInteresting bool               `json:"looksInteresting" bson:"looksInteresting"`
    Unlocked         bool               `json:"unlocked" bson:"unlocked"`
type LiteOffer struct {
    ID           primitive.ObjectID `json:"id,omitempty" bson:"id,omitempty"`
    Tags         []Tag              `json:"tags" bson:"tags,omitempty"`
    Profile      Profile            `json:"profile,omitempty" bson:"profile,omitempty"`
type Profile struct {
    ID          primitive.ObjectID `json:"id,omitempty" bson:"id" diff:"-"`
    Name        string             `json:"name,omitempty" bson:"name,omitempty" diff:"-"`
    Surname     string             `json:"surname,omitempty" bson:"surname,omitempty" 
}

func getMatchesByProfileId(id primitive.ObjectID) (*[]Match, error) {
    var matches []Match
    filter := bson.M{
        "$or": []bson.M{
                "partnerA.id":               id,
                "partnerA.looksInteresting": false,
                "partnerB.id":               id,
                "partnerB.looksInteresting": false,
        "unlocked":  false,
        "deletedAt": nil,
    ctx, _ := db.GetTimeoutContext()
    result, err := getMatchCollection().Find(ctx, filter)
    if err != nil {
        log.Error("Could not find matches, Error: ", err)
        return nil, err
    for result.Next(ctx) {
        var m Match
        if err = result.Decode(&m); err != nil {
            log.Error("Could not decode offer in getMatchesByProfileId", err)
            return nil, err
        matches = append(matches, m)
    return &matches, nil
}

    pipeline := mongo.Pipeline{
        {{"$match", match}},
        {{"$lookup", bson.M{
            "from":         "profile",
            "localField":   "partnerA.id",
            "foreignField": "_id",
            "as":           "profile",
        {{"$unwind", "$profile"}},
    }

func getMatchesByProfileId(id primitive.ObjectID) (*[]Match, error) {
    var matches []Match
    match := bson.D{
        {"unlocked", false},
        {"deletedAt", nil},
        {"$or", []bson.M{
                "partnerA.id":               id,
                "partnerA.looksInteresting": false,
                "partnerB.id":               id,
                "partnerB.looksInteresting": false,
    pipeline := mongo.Pipeline{
        {{"$match", match}},
        {{"$lookup", bson.M{
            "from":         "profile",
            "localField":   "partnerA.id",
            "foreignField": "_id",
            "as":           "partnerA.offer.profile",
        {{"$unwind", "$partnerA.offer.profile"}},
        {{"$lookup", bson.M{
            "from":         "profile",
            "localField":   "partnerB.id",
            "foreignField": "_id",
            "as":           "partnerB.offer.profile",
        {{"$unwind", "$partnerB.offer.profile"}},
    ctx, _ := db.GetTimeoutContext()
    cursor, err := getMatchCollection().Aggregate(ctx, pipeline)
    if err != nil {
        log.Error("Could not aggregate matches, Error: ", err)
        return nil, err
    defer cursor.Close(ctx)
    for cursor.Next(ctx) {
        var m Match
        if err = cursor.Decode(&m); err != nil {
            log.Error("Could not decode matches in getMatchesByProfileId error: ", err)

问 Go MongoDB嵌套查询与$lookup EN

Stack Overflow用户