MongoDB: उप-दस्तावेज़ आईडी द्वारा कैसे खोजें?

Question

मैं games की अवधारणा को मॉडल करने की कोशिश कर रहा हूं जहां teamsplayers मोंगोडीबी में एक दूसरे के खिलाफ प्रतिस्पर्धा करता है।

मेरे पास दो संग्रह हैं: players और games।

इस प्रकार games में एक दस्तावेज़ जैसा दिखता है।

{ 
    "_id": { "$oid": "1" }, 
    "teams": [ 
     { 
      "players": [ 
       { 
        "player": { "$oid": "2" }, 
        "score": 500, 
       }, 
       { 
        "player": { "$oid": "3" }, 
        "score": 550, 
       } 
      ] 
     }, 
     { 
      "players": [ 
       { 
        "player": { "$oid": "4" }, 
        "score": 500, 
       }, 
       { 
        "player": { "$oid": "5" }, 
        "score": 550, 
       } 
      ] 
     } 
    ] 
} 

यहां कार्य है: एक खिलाड़ी आईडी दिया गया है, जिसमें मैं इस गेम में भाग लेने वाले सभी गेम ढूंढना चाहता हूं।

मैं क्या कोशिश की है:

db.games.find({ "teams.players.player._id": "2" }) 

बहरहाल, यह कुछ भी वापस नहीं करता है। निम्नलिखित CoffeeScript क्वेरी के साथ

playerSchema = Schema 
    player: { type: Schema.ObjectId, ref: 'Player' } 
    score: { type: Number } 

teamSchema = Schema 
    players: [ playerSchema ] 

gameSchema = Schema 
    teams: [ teamSchema ] 

:

वैसे, मैं निम्नलिखित स्कीमा के साथ नेवला उपयोग कर रहा हूँ

Game.find 'teams.players.player._id': playerId 

जो किसी भी खिलाड़ी आईडी के लिए कोई परिणाम देता है।

Answer 1

अपने दस्तावेज़ में:

"players": [ 
      { 
       "player": { "$oid": "4" }, 
       "score": 500, 
      }, 
      { 
       "player": { "$oid": "5" }, 
       "score": 550, 
      } 
     ] 

players के एम्बेडेड संग्रह में player क्षेत्र एक BSON आईडी है (यानी यह ObjectId("4e208e070347a90001000008") तरह दिखता है), इसलिए मुझे लगता है कि तुम इतनी तरह आपकी क्वेरी की संरचना करना चाहिए:

db.games.find({ "teams.players.player": ObjectId("2") }) 

नोट, मैंने _id छोड़ दिया है - बशर्ते कि एक मोंगो कंसोल में काम करता है, तो मुझे संदेह है कि कॉफी क्वेरी समान होगी (_id भाग ड्रॉप करें)।

Answer 2

मैंने इस उदाहरण को घर और दूर टीम तक सीमित करने के लिए आपकी प्रतिक्रिया का उपयोग किया। याद रखें कि मोंगो एक संबंधपरक डेटाबेस नहीं है और संबंधों का उपयोग अक्सर एक संबंधपरक डेटाबेस मानसिकता का संकेत होता है। डुप्लिकेशंस कुंजी है।

खेल से विशिष्ट प्लेयर दस्तावेज़ों के संदर्भों के बजाय, मैंने प्लेयर का नाम संग्रहीत किया है। मुझे लगता है कि यह एक अपरिवर्तनीय अद्वितीय सूचकांक है। खिलाड़ी को एक गेम एरे दिया गया है जिसमें उन्होंने खेले गए प्रत्येक गेम के संदर्भ शामिल हैं। यह वास्तव में काफी बुरा है क्योंकि हमें फिर से पूछना है और इस सरणी को पॉप्युलेट करना है। यहां एक नाम भी स्टोर करना बेहतर होगा, लेकिन चूंकि मुझे आपकी स्थिति नहीं पता है, इसलिए मुझे यकीन नहीं है कि किसी गेम में एक अपरिवर्तनीय प्रतिनिधित्व योग्य नाम है या नहीं।

यह मूल विचार त्रुटि जांच (जैसे मिडलवेयर) के साथ सुधारना है, लेकिन मैं इसे आपके पास छोड़ देता हूं।

// Schemas 
var playerSchema = new Schema({ 
    name: {type: String, index: true, unique: true}, 
    games: {type: [Schema.ObjectId], ref: 'Game'} 
}); 

var gameSchema = new Schema({ 
    homeTeam: [{player: {name: String}, score: Number}] 
    awayTeam: [{player: {name: String}, score: Number}] 
}); 

// Models 
var Player = mongoose.model('Player', playerSchema); 
var Team = mongoose.model('Team', teamSchema); 
var Game = mongoose.model('Game', gameSchema); 

// Middleware 
gameSchema.post('save', function (game) { 
    var addMatchToPlayer = function(name) { 
     Player.findOne({name: name}, function(err, player) { 
      if (!err && player && player.games.indexOf(game._id) === -1) { 
       player.games.push(game._id); 
       player.save(); 
      } 
     }); 
    } 
    for (var i = 0; i < game.homeTeam.length; i++) { 
     addMatchToPlayer(game.homeTeam[i].name); 
    } 
    for (var i = 0; i < game.awayTeam.length; i++) { 
     addMatchToPlayer(game.awayTeam[i].name); 
    } 
}); 

// Queries 
Player.findOne({name: 'Roel van Uden'}).populate('games').exec(function (err, player) { 
});