Pytanie Mongoose, sortuj zapytanie według wypełnionego pola


O ile mi wiadomo, możliwe jest sortowanie zaludnionych dokumentów z Mongoose (źródło).

Szukam sposobu sortowania zapytania według jednego lub kilku wypełnionych pól.

Rozważ te dwa schematy Mongoose:

var Wizard = new Schema({
    name  : { type: String }
, spells  : { [{ type: Schema.ObjectId, ref: 'Spell' }] }
});

var Spell = new Schema({
    name    : { type: String }
,   damages : { type: Number }
});

Przykładowy JSON:

[{
    name: 'Gandalf',
    spells: [{
            name: 'Fireball',
            damages: 20
        }]
}, {
    name: 'Saruman',
    spells: [{
            name: 'Frozenball',
            damages: 10
        }]
}, {
    name: 'Radagast',
    spells: [{
            name: 'Lightball',
            damages: 15
        }]
}]

Chciałbym posortować tych czarodziejów za pomocą ich zaklęć, używając czegoś takiego jak:

WizardModel
  .find({})
  .populate('spells', myfields, myconditions, { sort: [['damages', 'asc']] })
// Should return in the right order: Saruman, Radagast, Gandalf

Tak naprawdę robię te rodzaje ręcznie po zapytaniu i chciałbym to zoptymalizować.


13
2017-07-16 21:38


pochodzenie


Z jakiej wersji gry Mongoose korzystasz? Wiem, że składnia sortowania zmieniła się całkiem w wersji 3.0. - JohnnyHK
Używam Mongoose 2.5.14. Mam ważną demonstrację mojego projektu za dwa dni, więc nie podejmę ryzyka aktualizacji mojego stosu. - Adrien Schuler


Odpowiedzi:


Zadaj sobie (i tu są odpowiedzi):

Czego chcę? Posortuj czarnoksiężników według ich obrażeń od czaru (powinno to być pole dodatkowe, prawdopodobnie suma obrażeń zaklęć.

Co ja zrobiłem: Posortowałem SPELLS of the wizard.

Co powinieneś zrobić: Wizard.find ({}). Sort ({power: 'asc'}), a następnie wypełnij czary i rób co chcesz. Moc to kolejne pole w kreatorze. Będziesz go potrzebował, ponieważ nawet jeśli zapełnisz swoje czary, otrzymasz szereg zaklęć i to ci nie pomoże.

Mam nadzieję że to pomoże.


3
2017-10-01 13:35





Można niejawnie określić tylko wymagane parametry metody wypełnienia:

WizardModel
  .find({})
  .populate({path: 'spells', options: { sort: [['damages', 'asc']] }})

Spójrz na http://mongoosejs.com/docs/api.html#document_Document-populate Oto przykład z linku powyżej.

doc
.populate('company')
.populate({
  path: 'notes',
  match: /airline/,
  select: 'text',
  model: 'modelName'
  options: opts
}, function (err, user) {
  assert(doc._id == user._id) // the document itself is passed
})

2
2017-08-30 16:57





Mimo że jest to raczej stary post, chciałbym udostępnić rozwiązanie za pośrednictwem potoku wyszukiwania agregacji MongoDB

Ważna jest to:

 {
      $lookup: {
        from: 'spells',
        localField: 'spells',
        foreignField:'_id',
        as: 'spells'
      }
    },
    {
      $project: {
        _id: 1,
        name: 1,
        // project the values from damages in the spells array in a new array called damages
        damages: '$spells.damages',
        spells: {
          name: 1,
          damages: 1
        }
      }
    },
    // take the maximum damage from the damages array
    {
      $project: {
        _id: 1,
        spells: 1,
        name: 1,
        maxDamage: {$max: '$damages'}
      }
    },
    // do the sorting
    {
      $sort: {'maxDamage' : -1}
    }

Znajdź poniżej pełny przykład

'use strict';

const mongoose = require('mongoose');
const Schema = mongoose.Schema;

mongoose.connect('mongodb://localhost/lotr');

const db = mongoose.connection;

db.on('error', console.error.bind(console, 'connection error:'));
db.once('open', () => {



  let SpellSchema = new Schema({
    name    : { type: String },
    damages : { type: Number }
  });

  let Spell = mongoose.model('Spell', SpellSchema);

  let WizardSchema = new Schema({
    name: { type: String },
    spells: [{ type: Schema.Types.ObjectId, ref: 'Spell' }]
  });

  let Wizard = mongoose.model('Wizard', WizardSchema);

  let fireball = new Spell({
    name: 'Fireball',
    damages: 20
  });

  let frozenball = new Spell({
    name: 'Frozenball',
    damages: 10
  });

  let lightball = new Spell({
    name: 'Lightball',
    damages: 15
  });

  let spells = [fireball, frozenball, lightball];

  let wizards = [{
    name: 'Gandalf',
    spells:[fireball]
  }, {

    name: 'Saruman',
    spells:[frozenball]
  }, {
    name: 'Radagast',
    spells:[lightball]
  }];

  let aggregation = [
    {
      $match: {}
    },
    // find all spells in the spells collection related to wizards and fill populate into wizards.spells
    {
      $lookup: {
        from: 'spells',
        localField: 'spells',
        foreignField:'_id',
        as: 'spells'
      }
    },
    {
      $project: {
        _id: 1,
        name: 1,
        // project the values from damages in the spells array in a new array called damages
        damages: '$spells.damages',
        spells: {
          name: 1,
          damages: 1
        }
      }
    },
    // take the maximum damage from the damages array
    {
      $project: {
        _id: 1,
        spells: 1,
        name: 1,
        maxDamage: {$max: '$damages'}
      }
    },
    // do the sorting
    {
      $sort: {'maxDamage' : -1}
    }
  ];
  Spell.create(spells, (err, spells) => {
    if (err) throw(err);
    else {
      Wizard.create(wizards, (err, wizards) =>{
        if (err) throw(err);
        else {
          Wizard.aggregate(aggregation)
          .exec((err, models) => {
            if (err) throw(err);
            else {
              console.log(models[0]); // eslint-disable-line
              console.log(models[1]); // eslint-disable-line
              console.log(models[2]); // eslint-disable-line
              Wizard.remove().exec(() => {
                Spell.remove().exec(() => {
                  process.exit(0);
                });
              });
            }
          });
        }
      });
    }
  });
});

1
2018-01-14 09:02





oto próbka mangusta doc.

var PersonSchema = new Schema({
    name: String,
    band: String
});

var BandSchema = new Schema({
    name: String
});
BandSchema.virtual('members', {
    ref: 'Person', // The model to use
    localField: 'name', // Find people where `localField`
    foreignField: 'band', // is equal to `foreignField`
    // If `justOne` is true, 'members' will be a single doc as opposed to
    // an array. `justOne` is false by default.
    justOne: false,
    options: { sort: { name: -1 }, limit: 5 }
});

0
2017-08-18 18:08