MongoDB
 sql >> डेटाबेस >  >> NoSQL >> MongoDB

शर्तों के साथ मौजूदा फ़ील्ड से स्कोर की गणना करें

आपके कार्यान्वयन के साथ कई मुद्दे हैं। सबसे पहले, आप find() का उपयोग कर रहे हैं विधि गलत है क्योंकि आप क्वेरी के लिए बहुत अधिक तर्क निर्दिष्ट कर रहे हैं:

MyModel.find(
    { Mkt_Al : Mkt_Air }, 
    { Orig : Origin }, 
    { Dest : Thru_Point }, 
    { Eff_Date : Effective_Date }
).lean().exec(function(err, docs) { .. }

होना चाहिए

MyModel.find({ 
    Mkt_Al: Mkt_Air, 
    Orig: Origin, 
    Dest: Thru_Point, 
    Eff_Date: Effective_Date 
}).lean().exec(function(err, docs) { ... }

दोबारा, आपको find()<का उपयोग नहीं करना चाहिए /कोड> इस उदाहरण में विधि क्योंकि आपको केवल एक दस्तावेज़ की आवश्यकता है जो आपकी गणना में उपयोग करने के लिए क्वेरी से मेल खाता हो। अपने पिछले बंद प्रश्न से जटिल एल्गोरिथम लेना:

MyModel.findOne() का उपयोग करना उपरोक्त कार्यों 3, 4 और 5 के लिए पर्याप्त होना चाहिए। हालाँकि, कॉल की अतुल्यकालिक प्रकृति के कारण, आपको प्रश्नों को नेस्ट करने की आवश्यकता होगी लेकिन सौभाग्य से नेस्टेड कॉल की गहराई 3 से अधिक नहीं है अन्यथा आप अपने आप को कॉलबैक हेल के लिए एक तरफ़ा टिकट के साथ पाएंगे। इन सामान्य नुकसानों से बचने के लिए, Promises (चूंकि नेवला क्वेरी डिफ़ॉल्ट रूप से एक Promise ) या node-async का उपयोग करें पैकेज जिसमें इस तरह की स्थितियों से निपटने के लिए कई कार्य शामिल हैं।

अगर async का इस्तेमाल कर रहे हैं पुस्तकालय, यह कुशलतापूर्वक आपको कई अतुल्यकालिक कार्यों को चलाने की अनुमति देता है (जैसे MyModel.findOne() कॉल) जो एक दूसरे पर निर्भर करते हैं और जब वे सभी समाप्त हो जाते हैं तो कुछ और करते हैं। उपरोक्त में, आप async.series() विधि।

निम्नलिखित उदाहरण उपरोक्त अवधारणा को प्रदर्शित करता है जहां आप Qsi . की गणना कर सकते हैं परीक्षण डीबी में निम्नलिखित नमूना दस्तावेजों से।

टेस्ट डीबी के वॉल्यूम संग्रह को पॉप्युलेट करें:

db.vols.insert([
    {    
        "Mkt_Al" : "2G",
        "Stops" : 0,
        "Seats" : 169,
        "Block_Mins" : 230,                
        "Ops_Week" : 3,        
        "Orig" : "AGP",
        "Dest" : "OTP",
        "Thru_Point" : "",
    },
    {    
        "Mkt_Al" : "2G",
        "Stops" : 1,
        "Seats" : 260,              
        "Block_Mins" : 260,
        "Ops_Week" : 2,  
        "Orig" : "CEK",
        "Dest" : "IKT",
        "Thru_Point" : "OVB",
    },
    {    
        "Mkt_Al" : "2G",
        "Stops" : 0,
        "Seats" : 140,
        "Block_Mins" : 60,
        "Ops_Week" : 2,        
        "Orig" : "BEK",
        "Dest" : "OTP",
        "Thru_Point" : "",
    },
    {    
        "Mkt_Al" : "2G",
        "Stops" : 0,
        "Seats" : 160,
        "Block_Mins" : 90,
        "Ops_Week" : 3,        
        "Orig" : "CEK",
        "Dest" : "OVB",
        "Thru_Point" : "",
    },
    {    
        "Mkt_Al" : "2G",        
        "Stops" : 0,
        "Seats" : 60,
        "Block_Mins" : 50,
        "Ops_Week" : 3,        
        "Orig" : "OVB",
        "Dest" : "IKT",
        "Thru_Point" : "",
    }
])

Node.js ऐप:

var mongoose = require('mongoose'),
    express = require('express'),
    async = require('async'),
    Schema = mongoose.Schema;

mongoose.connect('mongodb://localhost/test');
var volSchema = new Schema({},{ strict: false, collection: 'vols' }),    
    Vol = mongoose.model("Vol", volSchema);

mongoose.set('debug', false);

mongoose.connection.on("open", function (err) {
    if (err) throw err;  
    var bulkUpdateOps = Vol.collection.initializeUnorderedBulkOp(), 
        counter = 0;

    Vol.find({}).lean().exec(function (err, docs) {
        if (err) throw err; 
        var locals = {};

        docs.forEach(function(doc) {            
            locals.c1 = 0.3728 + (0.00454 * doc.Seats);         
            locals.c3 = doc.Ops_Week;

            if (doc.Stops == 1) {               
                async.series([
                    // Load doc with first leg first
                    function(callback) {
                        Vol.findOne({ 
                            Mkt_Al: doc.Mkt_Al,
                            Orig: doc.Orig,
                            Dest: doc.Dest                          
                        }).lean().exec(function (err, flight) {
                            if (err) return callback(err);
                            locals.first_leg = flight.Block_Mins;
                            callback();
                        });
                    },
                    // Load second leg doc 
                    // (won't be called before task 1's "task callback" 
                    // has been called)
                    function(callback) {                    
                        Vol.findOne({ 
                            Mkt_Al: doc.Mkt_Al,
                            Orig: doc.Thru_Point,
                            Dest: doc.Dest                          
                        }).lean().exec(function (err, flight) {
                            if (err) return callback(err);
                            locals.second_leg = flight.Block_Mins;
                            callback();
                        });
                    }
                ], function(err) { // This function gets called after the
                    // two tasks have called their "task callbacks"
                    if (err) throw err;
                    // Here locals will be populated with `first_leg` 
                    // and `second_leg`
                    // Just like in the previous example
                    var total_flight = locals.second_leg + locals.first_leg;                    
                    locals.c2 = 0.03;
                    locals.c4 = Math.pow((doc.Block_Mins / total_flight), -0.675);                    

                }); 
            } else {
                locals.c2 = 1;
                locals.c4 = 1;
            }

            counter++;
            console.log(locals);
            bulkUpdateOps.find({ "_id" : doc._id }).updateOne({ 
                "$set": { 
                    "Qsi": (locals.c1 * locals.c2 * locals.c3 * locals.c4) 
                } 
            });

            if (counter % 500 == 0) {
               bulkUpdateOps.execute(function(err, result) {          
                    if (err) throw err; 
                    bulkUpdateOps = Vol.collection.initializeUnorderedBulkOp();                        
                });
            } 
        });

        if (counter % 500 != 0) {
            bulkUpdateOps.execute(function(err, result) {
                if (err) throw err; 
                console.log(result.nModified);                
            });
        }   
    });
});

नमूना आउटपुट:

db.vols.find()

/* 1 */
{
    "_id" : ObjectId("5767e7549ebce6d574702221"),
    "Mkt_Al" : "2G",
    "Stops" : 0,
    "Seats" : 169,
    "Block_Mins" : 230,
    "Ops_Week" : 3,
    "Orig" : "AGP",
    "Dest" : "OTP",
    "Thru_Point" : "",
    "Qsi" : 3.42018
}

/* 2 */
{
    "_id" : ObjectId("5767e7549ebce6d574702222"),
    "Mkt_Al" : "2G",
    "Stops" : 1,
    "Seats" : 260,
    "Block_Mins" : 260,
    "Ops_Week" : 2,
    "Orig" : "CEK",
    "Dest" : "IKT",
    "Thru_Point" : "OVB",
    "Qsi" : 3.1064
}

/* 3 */
{
    "_id" : ObjectId("5767e7549ebce6d574702223"),
    "Mkt_Al" : "2G",
    "Stops" : 0,
    "Seats" : 140,
    "Block_Mins" : 60,
    "Ops_Week" : 2,
    "Orig" : "BEK",
    "Dest" : "OTP",
    "Thru_Point" : "",
    "Qsi" : 2.0168
}

/* 4 */
{
    "_id" : ObjectId("5767e7549ebce6d574702224"),
    "Mkt_Al" : "2G",
    "Stops" : 0,
    "Seats" : 160,
    "Block_Mins" : 90,
    "Ops_Week" : 3,
    "Orig" : "CEK",
    "Dest" : "OVB",
    "Thru_Point" : "",
    "Qsi" : 3.2976
}

/* 5 */
{
    "_id" : ObjectId("5767e7549ebce6d574702225"),
    "Mkt_Al" : "2G",
    "Stops" : 0,
    "Seats" : 60,
    "Block_Mins" : 50,
    "Ops_Week" : 3,
    "Orig" : "OVB",
    "Dest" : "IKT",
    "Thru_Point" : "",
    "Qsi" : 1.9356
}


  1. Redis
  2.   
  3. MongoDB
  4.   
  5. Memcached
  6.   
  7. HBase
  8.   
  9. CouchDB
  1. EPEL MongoDB EC2 Amazon AMI पर शुरू नहीं होगा

  2. सुनिश्चित करें कि सूचकांक काम नहीं कर रहा है - MongoDB

  3. MongoDB के साथ पुनरावर्ती रूप से वृक्ष संरचना को कैसे क्वेरी करें?

  4. MongoDB में एक डेटाबेस से दूसरे डेटाबेस में संग्रह की प्रतिलिपि कैसे करें

  5. MongoDB ts.t निर्दिष्ट करके प्रविष्टि नहीं ढूँढ सकता (ts एक टाइमस्टैम्प प्रकार है)

© कॉपीराइट http://hi.sqldat.com सर्वाधिकार सुरक्षित