नोड के लिए अगली कड़ी का उपयोग करके रिकॉर्ड कैसे अपडेट करें?

Question

मैं NodeJS, एक्सप्रेस, एक्सप्रेस-संसाधन, और Sequelize के साथ RESTful API बना रहा हूं जिसका उपयोग MySQL डेटाबेस में संग्रहीत डेटासेट को प्रबंधित करने के लिए किया जाता है।

मैं यह पता लगाने की कोशिश कर रहा हूं कि सीक्लाइज़ का उपयोग करके रिकॉर्ड को ठीक से कैसे अपडेट किया जाए।

मैं एक मॉडल बनाता हूं:

module.exports = function (sequelize, DataTypes) {
  return sequelize.define('Locale', {
    id: {
      type: DataTypes.INTEGER,
      autoIncrement: true,
      primaryKey: true
    },
    locale: {
      type: DataTypes.STRING,
      allowNull: false,
      unique: true,
      validate: {
        len: 2
      }
    },
    visible: {
      type: DataTypes.BOOLEAN,
      defaultValue: 1
    }
  })
}

फिर, मेरे संसाधन नियंत्रक में, मैं एक अद्यतन कार्रवाई परिभाषित करता हूं।

यहाँ में मैं उस रिकॉर्ड को अपडेट करने में सक्षम होना चाहता हूँ जहाँ आईडी मैच करती है req.params वैरिएबल से ।

पहले मैं एक मॉडल बनाता हूं और फिर मैं updateAttributesरिकॉर्ड को अपडेट करने के लिए विधि का उपयोग करता हूं ।

const Sequelize = require('sequelize')
const { dbconfig } = require('../config.js')

// Initialize database connection
const sequelize = new Sequelize(dbconfig.database, dbconfig.username, dbconfig.password)

// Locale model
const Locales = sequelize.import(__dirname + './models/Locale')

// Create schema if necessary
Locales.sync()


/**
 * PUT /locale/:id
 */

exports.update = function (req, res) {
  if (req.body.name) {
    const loc = Locales.build()

    loc.updateAttributes({
      locale: req.body.name
    })
      .on('success', id => {
        res.json({
          success: true
        }, 200)
      })
      .on('failure', error => {
        throw new Error(error)
      })
  }
  else
    throw new Error('Data not provided')
}

अब, यह वास्तव में अपडेट क्वेरी का उत्पादन नहीं करता है जैसा कि मैं अपेक्षा करता हूं।

इसके बजाय, एक सम्मिलित क्वेरी निष्पादित की जाती है:

INSERT INTO `Locales`(`id`, `locale`, `createdAt`, `updatedAt`, `visible`)
VALUES ('1', 'us', '2011-11-16 05:26:09', '2011-11-16 05:26:15', 1)

तो मेरा सवाल है: सीक्वेलाइज़ ओआरएम का उपयोग करके रिकॉर्ड को अपडेट करने का उचित तरीका क्या है?

Answer 1

मैंने Sequelize का उपयोग नहीं किया है , लेकिन इसके दस्तावेज़ीकरण को पढ़ने के बाद, यह स्पष्ट है कि आप एक नई वस्तु का त्वरित मूल्यांकन कर रहे हैं का त्वरित रूपांतरण , इसीलिए Sequelize db में एक नया रिकॉर्ड सम्मिलित करता है।

पहले आपको उस रिकॉर्ड को खोजना होगा, उसे लाना होगा और उसके बाद ही उसके गुणों को बदलना होगा और उसे अपडेट करना होगा, उदाहरण के लिए:

Project.find({ where: { title: 'aProject' } })
  .on('success', function (project) {
    // Check if record exists in db
    if (project) {
      project.update({
        title: 'a very different title now'
      })
      .success(function () {})
    }
  })

Comments

यह काम करता है, फिर भी मैं बदलने की क्या ज़रूरत थी .successकरने के लिए.then

— एडम एफ

क्या यह होना चाहिए Project.findOne(?

— JBaczuk

पुराना सवाल लेकिन प्रासंगिक अगर आज (जैसा मैंने किया था) खोजना। सीक्वेलाइज़ 5 के अनुसार, रिकॉर्ड खोजने का सही तरीका वह है findByPk(req.params.id)जिसके साथ एक उदाहरण मिलता है।

— cstrutton

यह अनुशंसित नहीं किया जाना चाहिए, यह 2 प्रश्न भेजता है जहां यह एकल क्वेरी द्वारा किया जा सकता है। कृपया नीचे दिए गए अन्य उत्तरों की जाँच करें।

— T

Answer 2

संस्करण 2.0.0 के बाद से आपको एक संपत्ति में जहां अपना खंड लपेटने की आवश्यकता है where:

Project.update(
  { title: 'a very different title now' },
  { where: { _id: 1 } }
)
  .success(result =>
    handleResult(result)
  )
  .error(err =>
    handleError(err)
  )

---

अपडेट 2016-03-09

नवीनतम संस्करण वास्तव में successऔर errorअब और उपयोग नहीं करता है , बल्कि उपयोग करने योग्य thenवादे करता है।

तो ऊपरी कोड निम्नानुसार दिखेगा:

Project.update(
  { title: 'a very different title now' },
  { where: { _id: 1 } }
)
  .then(result =>
    handleResult(result)
  )
  .catch(err =>
    handleError(err)
  )

Async / प्रतीक्षा का उपयोग करना

try {
  const result = await Project.update(
    { title: 'a very different title now' },
    { where: { _id: 1 } }
  )
  handleResult(result)
} catch (err) {
  handleError(err)
}

http://docs.sequelizejs.com/en/latest/api/model/#updatevalues-options-promisearrayaffectedcount-affectedrows

Comments

: दस्तावेज़ में ले जाया गया sequelize.readthedocs.org/en/latest/api/model/...

— Topher

आपके पास पहले थ्रेड उत्तर की तुलना में अधिक अपवोट हैं, मुझे लगता है कि इसे इन उत्तर थ्रेड के पहले उत्तर में ले जाना चाहिए। चीयर्स।

— आनन्धधम

Answer 3

चूंकि v1.7.0 का सीक्वल है, आप अब मॉडल पर एक अपडेट () विधि कह सकते हैं। बहुत क्लीनर

उदाहरण के लिए:

Project.update(

  // Set Attribute values 
        { title:'a very different title now' },

  // Where clause / criteria 
         { _id : 1 }     

 ).success(function() { 

     console.log("Project with id =1 updated successfully!");

 }).error(function(err) { 

     console.log("Project update failed !");
     //handle error here

 });

Comments

क्या यह सत्यापन भी चलेगा?

— मार्कोनी

एपीआई डॉक्स में मैंने जो पढ़ा है, उसमें से यह पसंदीदा तरीका है।

— माइकल जे। कल्किन्स

यह वास्तव में पदावनत किया गया है। मॉडल के लिए आधिकारिक एपीआई संदर्भ देखें ।

— डोमी

यहाँ इस टिप्पणी के समय के अनुसार डॉक्स हैं - वे ReadTheDocs में चले गए हैं।

— क्रिस क्रायो

जैसा कि उल्लेख किया गया है, यह अंकन 2.0.0 के बाद से हटा दिया गया है। कृपया इस उत्तर को भी देखें: stackoverflow.com/a/26303473/831499

— Matthias Dietrich

Answer 4

और दिसंबर 2018 में उत्तर की तलाश कर रहे लोगों के लिए, वादों का उपयोग करके यह सही वाक्यविन्यास है:

Project.update(
    // Values to update
    {
        title:  'a very different title now'
    },
    { // Clause
        where: 
        {
            id: 1
        }
    }
).then(count => {
    console.log('Rows updated ' + count);
});

Comments

यह शीर्ष उत्तर होना चाहिए।

— डिकोडर 7283

2019 में काम नहीं कर रहा: अनहेल्ड रिजेक्ट एरर: अमान्य वैल्यू [फंक्शन]

— बर्फ

Answer 5

जनवरी 2020 उत्तर
समझने की बात यह है कि मॉडल के लिए एक अपडेट विधि और एक इंस्टेंस (रिकॉर्ड) के लिए एक अलग अपडेट विधि है। Model.update()सभी मिलान रिकॉर्ड को अपडेट करता है और एक सरणी देखता है जो सीक्वेलाइज़ प्रलेखन देखता है ।Instance.update()रिकॉर्ड को अपडेट करता है और एक इंस्टेंस ऑब्जेक्ट देता है।

इसलिए प्रश्न के अनुसार एकल रिकॉर्ड अपडेट करने के लिए, कोड कुछ इस तरह दिखाई देगा:

SequlizeModel.findOne({where: {id: 'some-id'}})
.then(record => {
  
  if (!record) {
    throw new Error('No record found')
  }

  console.log(`retrieved record ${JSON.stringify(record,null,2)}`) 

  let values = {
    registered : true,
    email: '[e-mail]',
    name: 'Joe Blogs'
  }
  
  record.update(values).then( updatedRecord => {
    console.log(`updated record ${JSON.stringify(updatedRecord,null,2)}`)
    // login into your DB and confirm update
  })

})
.catch((error) => {
  // do seomthing with the error
  throw new Error(error)
})

तो, एक इंस्टेंस (रिकॉर्ड) को हैंडल करने Model.findOne()या Model.findByPkId()प्राप्त करने के लिए उपयोग करें या फिर उपयोग करेंInstance.update()

Answer 6

मुझे लगता है UPDATE ... WHEREकि यहाँ बताया गया है और यहाँ एक दुबला दृष्टिकोण है

Project.update(
      { title: 'a very different title no' } /* set attributes' value */, 
      { where: { _id : 1 }} /* where criteria */
).then(function(affectedRows) {
Project.findAll().then(function(Projects) {
     console.log(Projects) 
})

Comments

यह बोना स्वीकृत उत्तर होगा। इस तरह आप केवल कुछ फ़ील्ड सेट कर सकते हैं, और आप मापदंड निर्दिष्ट कर सकते हैं। बहुत बहुत धन्यवाद :)

— लुइस काबेरा बेनिटो

Answer 7

यह समाधान पदावनत है

विफलता | विफलता | त्रुटि () पदावनत है और 2.1 में हटा दिया जाएगा, कृपया इसके बजाय वादा-शैली का उपयोग करें।

इसलिए आपको उपयोग करना होगा

Project.update(

    // Set Attribute values 
    {
        title: 'a very different title now'
    },

    // Where clause / criteria 
    {
        _id: 1
    }

).then(function() {

    console.log("Project with id =1 updated successfully!");

}).catch(function(e) {
    console.log("Project update failed !");
})

और अगर आप उपयोग कर सकते हैं .complete()और साथ ही

सादर

Answer 8

Async का उपयोग करना और एक आधुनिक जावास्क्रिप्ट Es6 में इंतजार करना

const title = "title goes here";
const id = 1;

    try{
    const result = await Project.update(
          { title },
          { where: { id } }
        )
    }.catch(err => console.log(err));

आप परिणाम वापस कर सकते हैं ...

Answer 9

सार्वजनिक स्थैतिक अद्यतन (मान: ऑब्जेक्ट, विकल्प: ऑब्जेक्ट): वादा>

प्रलेखन एक बार जाँच http://docs.sequelizejs.com/class/lib/model.js~Model.html#static-method-update

  Project.update(
    // Set Attribute values 
    { title:'a very different title now' },
  // Where clause / criteria 
     { _id : 1 }     
  ).then(function(result) { 

 //it returns an array as [affectedCount, affectedRows]

  })

Answer 10

आप Model.update () विधि का उपयोग कर सकते हैं।

Async / प्रतीक्षा के साथ:

try{
  const result = await Project.update(
    { title: "Updated Title" }, //what going to be updated
    { where: { id: 1 }} // where clause
  )  
} catch (error) {
  // error handling
}

.Then () के साथ। पकड़ ():

Project.update(
    { title: "Updated Title" }, //what going to be updated
    { where: { id: 1 }} // where clause
)
.then(result => {
  // code with result
})
.catch(error => {
  // error handling
})

Answer 11

हाय यह बहुत सरल रिकॉर्ड को अद्यतन करने के लिए

1. सीक्वेल आईडी द्वारा रिकॉर्ड खोजें (या आप क्या चाहते हैं)
2. तो आप के साथ पारित कर देते हैं result.feild = updatedField
3. यदि डेटाबेस में रिकॉर्ड नोटेक्सिस्ट सीक्वेल को पाराम्स के साथ एक नया रिकॉर्ड बनाते हैं
4. अधिक समझने के लिए कोड देखें # 1 परीक्षण जो V4 के तहत सभी संस्करण के लिए कोड है

const sequelizeModel = require("../models/sequelizeModel");
    const id = req.params.id;
            sequelizeModel.findAll(id)
            .then((result)=>{
                result.name = updatedName;
                result.lastname = updatedLastname;
                result.price = updatedPrice;
                result.tele = updatedTele;
                return result.save()
            })
            .then((result)=>{
                    console.log("the data was Updated");
                })
            .catch((err)=>{
                console.log("Error : ",err)
            });

V5 के लिए कोड

const id = req.params.id;
            const name = req.body.name;
            const lastname = req.body.lastname;
            const tele = req.body.tele;
            const price = req.body.price;
    StudentWork.update(
        {
            name        : name,
            lastname    : lastname,
            tele        : tele,
            price       : price
        },
        {returning: true, where: {id: id} }
      )
            .then((result)=>{
                console.log("data was Updated");
                res.redirect('/');
            })
    .catch((err)=>{
        console.log("Error : ",err)
    });

Answer 12

यदि आप एक मॉडल में एक विशिष्ट क्षेत्र मान बढ़ाने के लिए रास्ता खोज रहे हैं ...

इसने मेरे लिए काम किया sequelize@5.21.3

User.increment("field", {by: 1, where: {id: 1});

REF: https://github.com/fterelize/fterelize/issues/7268

Answer 13

ऐसे दो तरीके हैं जिनसे आप सीक्वल में रिकॉर्ड अपडेट कर सकते हैं।

सबसे पहले, यदि आपके पास एक विशिष्ट पहचानकर्ता है, तो आप एक ही पहचानकर्ता के साथ कई रिकॉर्ड अपडेट करना चाहते हैं, जहां आप खंड या अन्य का उपयोग कर सकते हैं।

आप अपडेट करने के लिए या एक विशिष्ट कॉलम या तो बना सकते हैं

const objectToUpdate = {
title: 'Hello World',
description: 'Hello World'
}

models.Locale.update(objectToUpdate, { where: { id: 2}})

केवल एक विशिष्ट कॉलम अपडेट करें

models.Locale.update({ title: 'Hello World'}, { where: { id: 2}})

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

const objectToUpdate = {
title: 'Hello World',
description: 'Hello World'
}

models.Locale.findAll({ where: { title: 'Hello World'}}).then((result) => {
   if(result){
   // Result is array because we have used findAll. We can use findOne as well if you want one row and update that.
        result[0].set(objectToUpdate);
        result[0].save(); // This is a promise
}
})

हमेशा एक नई पंक्ति को अपडेट या बनाते समय लेनदेन का उपयोग करें। यदि कोई त्रुटि है या यदि आप कोई भी एकाधिक अद्यतन कर रहे हैं तो यह किसी भी अद्यतन को वापस लेगा:

models.sequelize.transaction((tx) => {
    models.Locale.update(objectToUpdate, { transaction: t, where: {id: 2}});
})