sql >> Databasteknik >  >> NoSQL >> MongoDB

Mongoose Populera efter Aggregate

Så du saknar faktiskt några begrepp här när du ber om att "befolka" på ett aggregeringsresultat. Vanligtvis är detta inte vad du faktiskt gör, utan för att förklara poängen:

  1. Utdata från aggregate() är till skillnad från en Model.find() eller liknande åtgärd eftersom syftet här är att "omforma resultaten". Detta betyder i princip att modellen du använder som källa för aggregeringen inte längre anses vara den modellen vid produktion. Detta är till och med sant om du fortfarande bibehöll exakt samma dokumentstruktur vid utmatning, men i ditt fall skiljer sig utmatningen klart från källdokumentet ändå.

    Det är i alla fall inte längre en instans av Garanti modell du köper från, men bara ett vanligt föremål. Vi kan komma runt det när vi berör senare.

  2. Förmodligen är huvudpoängen här att populate() är något "gammal hatt" i alla fall. Detta är egentligen bara en bekvämlighetsfunktion som lades till i Mongoose redan i början av implementeringen. Allt det egentligen gör är att köra "en annan fråga" på relaterade data i en separat samling och slår sedan samman resultaten i minnet till den ursprungliga samlingsutdatan.

    Av många skäl är det inte riktigt effektivt eller ens önskvärt i de flesta fall. Och i motsats till den populära missuppfattningen är detta INTE faktiskt en "join".

    För en riktig "join" använder du faktiskt $lookup aggregeringspipeline-stadiet, som MongoDB använder för att returnera de matchande föremålen från en annan samling. Till skillnad från populate() detta görs faktiskt i en enda begäran till servern med ett enda svar. Detta undviker nätverkskostnader, är i allmänhet snabbare och som en "real join" kan du göra saker som populate() kan inte göra.

Använd $lookup istället

Den mycket snabba version av det som saknas här är att istället för att försöka populate() i .then() efter att resultatet har returnerats, vad du gör istället är att lägga till $lookup till pipelinen:

  { "$lookup": {
    "from": Account.collection.name,
    "localField": "_id",
    "foreignField": "_id",
    "as": "accounts"
  }},
  { "$unwind": "$accounts" },
  { "$project": {
    "_id": "$accounts",
    "total": 1,
    "lineItems": 1
  }}

Observera att det finns en begränsning här i att utdata från $ uppslag är alltid en uppsättning. Det spelar ingen roll om det bara finns en relaterad artikel eller många som ska hämtas som utdata. Pipelinesteget letar efter värdet för "localField" från det aktuella dokumentet som presenteras och använd det för att matcha värden i "foreignField" specificerad. I det här fallet är det _id från sammanställningen $group mål till _id av den utländska samlingen.

Eftersom utdata alltid är en array som nämnts skulle det mest effektiva sättet att arbeta med detta i det här fallet vara att helt enkelt lägga till en $unwind steg direkt efter $lookup . Allt detta kommer att göra det returnerar ett nytt dokument för varje artikel som returneras i målarrayen, och i det här fallet förväntar du dig att det ska vara ett. I fallet där _id inte matchas i den utländska samlingen, skulle resultaten utan matchningar tas bort.

Som en liten notering är detta faktiskt ett optimerat mönster som beskrivs i $lookup + $unwind Coalescence inom kärndokumentationen. En speciell sak händer här där $unwind instruktionen är faktiskt sammanfogad med $lookup driften på ett effektivt sätt. Du kan läsa mer om det där.

Med fylla

Från ovanstående innehåll bör du i princip kunna förstå varför populate() här är fel sak att göra. Bortsett från det grundläggande faktum att utgången inte längre består av Garanti modellobjekt, den modellen känner egentligen bara till främmande objekt som beskrivs på _accountId egenskap som ändå inte finns i utdata.

Nu kan faktiskt definiera en modell som kan användas för att explicit gjuta ut objekten till en definierad utdatatyp. En kort demonstration av en skulle innebära att lägga till kod till din ansökan för detta som:

// Special models

const outputSchema = new Schema({
  _id: { type: Schema.Types.ObjectId, ref: "Account" },
  total: Number,
  lineItems: [{ address: String }]
});

const Output = mongoose.model('Output', outputSchema, 'dontuseme');

Denna nya Output modell kan sedan användas för att "casta" de resulterande vanliga JavaScript-objekten till Mongoose Documents så att metoder som Model.populate() kan faktiskt kallas:

// excerpt
result2 = result2.map(r => new Output(r));   // Cast to Output Mongoose Documents

// Call populate on the list of documents
result2 = await Output.populate(result2, { path: '_id' })
log(result2);

Sedan Output har ett schema definierat som är medvetet om "referensen" på _id fältet för dess dokument Model.populate() är medveten om vad den behöver göra och returnerar föremålen.

Var dock försiktig eftersom detta faktiskt genererar en annan fråga. dvs:

Mongoose: warranties.aggregate([ { '$match': { payStatus: 'Invoiced Next Billing Cycle' } }, { '$group': { _id: '$_accountId', total: { '$sum': '$warrantyFee' }, lineItems: { '$push': { _id: '$_id', address: { '$trim': { input: { '$reduce': { input: { '$objectToArray': '$address' }, initialValue: '', in: { '$concat': [ '$$value', ' ', [Object] ] } } }, chars: ' ' } } } } } } ], {})
Mongoose: accounts.find({ _id: { '$in': [ ObjectId("5bf4b591a06509544b8cf75c"), ObjectId("5bf4b591a06509544b8cf75b") ] } }, { projection: {} })

Där den första raden är den sammanlagda utdata, och sedan kontaktar du servern igen för att returnera det relaterade Kontot modellposter.

Sammanfattning

Så det är dina alternativ, men det borde vara ganska tydligt att den moderna inställningen till detta istället är att använda $lookup och få en riktig "join" vilket inte är vad populate() faktiskt gör.

Inkluderat är en lista som en fullständig demonstration av hur var och en av dessa tillvägagångssätt faktiskt fungerar i praktiken. Någon konstnärlig licens tas här, så de representerade modellerna kanske inte är exakt samma som vad du har, men det finns tillräckligt för att demonstrera de grundläggande begreppen på ett reproducerbart sätt:

const { Schema } = mongoose = require('mongoose');

const uri = 'mongodb://localhost:27017/joindemo';
const opts = { useNewUrlParser: true };

// Sensible defaults
mongoose.Promise = global.Promise;
mongoose.set('debug', true);
mongoose.set('useFindAndModify', false);
mongoose.set('useCreateIndex', true);

// Schema defs

const warrantySchema = new Schema({
  address: {
    street: String,
    city: String,
    state: String,
    zip: Number
  },
  warrantyFee: Number,
  _accountId: { type: Schema.Types.ObjectId, ref: "Account" },
  payStatus: String
});

const accountSchema = new Schema({
  name: String,
  contactName: String,
  contactEmail: String
});

// Special models


const outputSchema = new Schema({
  _id: { type: Schema.Types.ObjectId, ref: "Account" },
  total: Number,
  lineItems: [{ address: String }]
});

const Output = mongoose.model('Output', outputSchema, 'dontuseme');

const Warranty = mongoose.model('Warranty', warrantySchema);
const Account = mongoose.model('Account', accountSchema);


// log helper
const log = data => console.log(JSON.stringify(data, undefined, 2));

// main
(async function() {

  try {

    const conn = await mongoose.connect(uri, opts);

    // clean models
    await Promise.all(
      Object.entries(conn.models).map(([k,m]) => m.deleteMany())
    )

    // set up data
    let [first, second, third] = await Account.insertMany(
      [
        ['First Account', 'First Person', '[email protected]'],
        ['Second Account', 'Second Person', '[email protected]'],
        ['Third Account', 'Third Person', '[email protected]']
      ].map(([name, contactName, contactEmail]) =>
        ({ name, contactName, contactEmail })
      )
    );

    await Warranty.insertMany(
      [
        {
          address: {
            street: '1 Some street',
            city: 'Somewhere',
            state: 'TX',
            zip: 1234
          },
          warrantyFee: 100,
          _accountId: first,
          payStatus: 'Invoiced Next Billing Cycle'
        },
        {
          address: {
            street: '2 Other street',
            city: 'Elsewhere',
            state: 'CA',
            zip: 5678
          },
          warrantyFee: 100,
          _accountId: first,
          payStatus: 'Invoiced Next Billing Cycle'
        },
        {
          address: {
            street: '3 Other street',
            city: 'Elsewhere',
            state: 'NY',
            zip: 1928
          },
          warrantyFee: 100,
          _accountId: first,
          payStatus: 'Invoiced Already'
        },
        {
          address: {
            street: '21 Jump street',
            city: 'Anywhere',
            state: 'NY',
            zip: 5432
          },
          warrantyFee: 100,
          _accountId: second,
          payStatus: 'Invoiced Next Billing Cycle'
        }
      ]
    );

    // Aggregate $lookup
    let result1 = await Warranty.aggregate([
      { "$match": {
        "payStatus": "Invoiced Next Billing Cycle"
      }},
      { "$group": {
        "_id": "$_accountId",
        "total": { "$sum": "$warrantyFee" },
        "lineItems": {
          "$push": {
            "_id": "$_id",
            "address": {
              "$trim": {
                "input": {
                  "$reduce": {
                    "input": { "$objectToArray": "$address" },
                    "initialValue": "",
                    "in": {
                      "$concat": [ "$$value", " ", { "$toString": "$$this.v" } ] }
                  }
                },
                "chars": " "
              }
            }
          }
        }
      }},
      { "$lookup": {
        "from": Account.collection.name,
        "localField": "_id",
        "foreignField": "_id",
        "as": "accounts"
      }},
      { "$unwind": "$accounts" },
      { "$project": {
        "_id": "$accounts",
        "total": 1,
        "lineItems": 1
      }}
    ])

    log(result1);

    // Convert and populate
    let result2 = await Warranty.aggregate([
      { "$match": {
        "payStatus": "Invoiced Next Billing Cycle"
      }},
      { "$group": {
        "_id": "$_accountId",
        "total": { "$sum": "$warrantyFee" },
        "lineItems": {
          "$push": {
            "_id": "$_id",
            "address": {
              "$trim": {
                "input": {
                  "$reduce": {
                    "input": { "$objectToArray": "$address" },
                    "initialValue": "",
                    "in": {
                      "$concat": [ "$$value", " ", { "$toString": "$$this.v" } ] }
                  }
                },
                "chars": " "
              }
            }
          }
        }
      }}
    ]);

    result2 = result2.map(r => new Output(r));

    result2 = await Output.populate(result2, { path: '_id' })
    log(result2);

  } catch(e) {
    console.error(e)
  } finally {
    process.exit()
  }

})()

Och hela resultatet:

Mongoose: dontuseme.deleteMany({}, {})
Mongoose: warranties.deleteMany({}, {})
Mongoose: accounts.deleteMany({}, {})
Mongoose: accounts.insertMany([ { _id: 5bf4b591a06509544b8cf75b, name: 'First Account', contactName: 'First Person', contactEmail: '[email protected]', __v: 0 }, { _id: 5bf4b591a06509544b8cf75c, name: 'Second Account', contactName: 'Second Person', contactEmail: '[email protected]', __v: 0 }, { _id: 5bf4b591a06509544b8cf75d, name: 'Third Account', contactName: 'Third Person', contactEmail: '[email protected]', __v: 0 } ], {})
Mongoose: warranties.insertMany([ { _id: 5bf4b591a06509544b8cf75e, address: { street: '1 Some street', city: 'Somewhere', state: 'TX', zip: 1234 }, warrantyFee: 100, _accountId: 5bf4b591a06509544b8cf75b, payStatus: 'Invoiced Next Billing Cycle', __v: 0 }, { _id: 5bf4b591a06509544b8cf75f, address: { street: '2 Other street', city: 'Elsewhere', state: 'CA', zip: 5678 }, warrantyFee: 100, _accountId: 5bf4b591a06509544b8cf75b, payStatus: 'Invoiced Next Billing Cycle', __v: 0 }, { _id: 5bf4b591a06509544b8cf760, address: { street: '3 Other street', city: 'Elsewhere', state: 'NY', zip: 1928 }, warrantyFee: 100, _accountId: 5bf4b591a06509544b8cf75b, payStatus: 'Invoiced Already', __v: 0 }, { _id: 5bf4b591a06509544b8cf761, address: { street: '21 Jump street', city: 'Anywhere', state: 'NY', zip: 5432 }, warrantyFee: 100, _accountId: 5bf4b591a06509544b8cf75c, payStatus: 'Invoiced Next Billing Cycle', __v: 0 } ], {})
Mongoose: warranties.aggregate([ { '$match': { payStatus: 'Invoiced Next Billing Cycle' } }, { '$group': { _id: '$_accountId', total: { '$sum': '$warrantyFee' }, lineItems: { '$push': { _id: '$_id', address: { '$trim': { input: { '$reduce': { input: { '$objectToArray': '$address' }, initialValue: '', in: { '$concat': [ '$$value', ' ', [Object] ] } } }, chars: ' ' } } } } } }, { '$lookup': { from: 'accounts', localField: '_id', foreignField: '_id', as: 'accounts' } }, { '$unwind': '$accounts' }, { '$project': { _id: '$accounts', total: 1, lineItems: 1 } } ], {})
[
  {
    "total": 100,
    "lineItems": [
      {
        "_id": "5bf4b591a06509544b8cf761",
        "address": "21 Jump street Anywhere NY 5432"
      }
    ],
    "_id": {
      "_id": "5bf4b591a06509544b8cf75c",
      "name": "Second Account",
      "contactName": "Second Person",
      "contactEmail": "[email protected]",
      "__v": 0
    }
  },
  {
    "total": 200,
    "lineItems": [
      {
        "_id": "5bf4b591a06509544b8cf75e",
        "address": "1 Some street Somewhere TX 1234"
      },
      {
        "_id": "5bf4b591a06509544b8cf75f",
        "address": "2 Other street Elsewhere CA 5678"
      }
    ],
    "_id": {
      "_id": "5bf4b591a06509544b8cf75b",
      "name": "First Account",
      "contactName": "First Person",
      "contactEmail": "[email protected]",
      "__v": 0
    }
  }
]
Mongoose: warranties.aggregate([ { '$match': { payStatus: 'Invoiced Next Billing Cycle' } }, { '$group': { _id: '$_accountId', total: { '$sum': '$warrantyFee' }, lineItems: { '$push': { _id: '$_id', address: { '$trim': { input: { '$reduce': { input: { '$objectToArray': '$address' }, initialValue: '', in: { '$concat': [ '$$value', ' ', [Object] ] } } }, chars: ' ' } } } } } } ], {})
Mongoose: accounts.find({ _id: { '$in': [ ObjectId("5bf4b591a06509544b8cf75c"), ObjectId("5bf4b591a06509544b8cf75b") ] } }, { projection: {} })
[
  {
    "_id": {
      "_id": "5bf4b591a06509544b8cf75c",
      "name": "Second Account",
      "contactName": "Second Person",
      "contactEmail": "[email protected]",
      "__v": 0
    },
    "total": 100,
    "lineItems": [
      {
        "_id": "5bf4b591a06509544b8cf761",
        "address": "21 Jump street Anywhere NY 5432"
      }
    ]
  },
  {
    "_id": {
      "_id": "5bf4b591a06509544b8cf75b",
      "name": "First Account",
      "contactName": "First Person",
      "contactEmail": "[email protected]",
      "__v": 0
    },
    "total": 200,
    "lineItems": [
      {
        "_id": "5bf4b591a06509544b8cf75e",
        "address": "1 Some street Somewhere TX 1234"
      },
      {
        "_id": "5bf4b591a06509544b8cf75f",
        "address": "2 Other street Elsewhere CA 5678"
      }
    ]
  }
]


  1. MongoDB Replica Set Medlemsstat är ANDRA

  2. ställa in utgångsdatum för Hashmap-värden i Redis?

  3. mongoengine-anslutning och flera databaser

  4. Hur man returnerar flera värden med Go Mongo Distinct