Sails.js modèle d'insérer ou de mettre à jour des enregistrements

J'ai réécrit Critique Purée de code, donc son chemin à moins de code, et plus générique.
Maintenant, vous pouvez appeler updateOrCreate de la même manière que vous appelez findOrCreate. Et ça ressemble à ça:

module.exports.models = {
    updateOrCreate: function(criteria, values){
        var self = this; //reference for use by callbacks
        //If no values were specified, use criteria
        if (!values) values = criteria.where ? criteria.where : criteria;

        return this.findOne(criteria).then(function (result){
          if(result){
            return self.update(criteria, values);
          }else{
            return self.create(values);
          }
        });
    }
};

De sorte que vous pouvez écrire des critères de la même façon. pas besoin de travailler sur la touche, et le code est beaucoup plus simple.

OriginalL'auteur Stas Arshanski

Votre solution est la bonne. Il n'y a pas d'autre moyen de le faire avec la ligne de flottaison (l'ORM de sails.js).
Mais plusieurs bases de données ont des fonctions pour ce cas:

MySQL

REPLACE INTO table SET id = 42, foo = 'bar';
(avec une clé primaire ou unique. Assez de merde si vous utilisez auto_increment 😉

De la ligne de Flottaison, vous pouvez utiliser le Modèle.query()-Fonction pour exécuter SQL directe (voir: http://sailsjs.org/#/documentation/reference/waterline/models/query.html)

MongoDB

db.collection.update(
  <query>,
  <update>,
  { upsert: true }
)

La upsert drapeau signifie: Si vous ne pouvez pas mettre à jour parce que vous ne trouverez pas n'importe quoi avec la requête de créer cet élément!

De la ligne de Flottaison, vous pouvez utiliser le Modèle.natif()-Fonction pour exécuter directement mongoDB-Commandes (voir: http://sailsjs.org/#/documentation/reference/waterline/models/native.html)

Conclusion

Vous vous avez besoin d'une rapidité d'exécution (et de la corse si vous avez beaucoup de beaucoup de demande) je suggère d'utiliser le natif/sql-fonctions. Mais en général, je suis vraiment fan de la flexibilité d'un ORM-Système et chaque fois que vous utilisez la base de données des fonctions spécifiques, il est plus difficile à manipuler.

OriginalL'auteur mdunisch

C'est comment je le fais: - je prolonger la config/models.js pour inclure la fonctionnalité et il vérifie pour voir si la carte a les bonnes méthodes. Vous pouvez l'appeler comme une promesse ou normalement.

    var normalize = require('sails/node_modules/waterline/lib/waterline/utils/normalize');
var hasOwnProperty = require('sails/node_modules/waterline/lib/waterline/utils/helpers').object.hasOwnProperty;
var defer = require('sails/node_modules/waterline/lib/waterline/utils/defer');
var noop = function() {};
module.exports.models = {
/**
* [updateOrCreate description]
* @param  {[type]}   criteria [description]
* @param  {[type]}   values   [description]
* @param  {Function} cb       [description]
* @return {[type]}            [description]
*/
updateOrCreate: function (criteria, values, cb) {
var self = this; 
var deferred;
//Normalize Arguments
if(typeof cb !== 'function') {
deferred = defer();
}
cb = cb || noop;
criteria = normalize.criteria(criteria);
if (criteria === false) {
if(deferred) {
deferred.resolve(null);
}
return cb(null, []);
}
else if(!criteria) {
if(deferred) {
deferred.reject(new Error('No criteria or id specified!'));
}
return cb(new Error('No criteria or id specified!'));
}
//Build Default Error Message
var errFind = 'No find() method defined in adapter!';
var errUpdate = 'No update() method defined in adapter!';
var errCreate = 'No create() method defined in adapter!';
//Find the connection to run this on
if(!hasOwnProperty(self.adapter.dictionary, 'find')){
if(deferred) {
deferred.reject(errFind);
}
return cb(new Error(errFind));
}
if(!hasOwnProperty(self.adapter.dictionary, 'update')){ 
if(deferred) {
deferred.reject(errUpdate);
}
return cb(new Error(errUpdate));
}
if(!hasOwnProperty(self.adapter.dictionary, 'create')) {
if(deferred) {
deferred.reject(errCreate);
}
return cb(new Error(errCreate));
}
var connNameFind = self.adapter.dictionary.find;
var adapterFind = self.adapter.connections[connNameFind]._adapter;
var connNameUpdate = self.adapter.dictionary.update;
var adapterUpdate = self.adapter.connections[connNameUpdate]._adapter;
var connNameCreate = self.adapter.dictionary.create;
var adapterCreate = self.adapter.connections[connNameCreate]._adapter;
adapterFind.find(connNameFind, self.adapter.collection, criteria, normalize.callback(function before (err, results){
if (err) {
if(deferred) {
deferred.reject(err);
}
return cb(err);
}
if(results && results.length > 0){
adapterUpdate.update(connNameUpdate, self.adapter.collection, criteria, values, normalize.callback(function afterwards (err, updatedRecords) {
if (err) {
if(deferred) {
deferred.reject(err);
}
return cb(err);
}
deferred.resolve(updatedRecords[0]);
return cb(null, updatedRecords[0]);
}));
}else{
adapterCreate.create(connNameCreate, self.adapter.collection, values, normalize.callback(function afterwards (err, createdRecord) {
if (err) {
if(deferred) {
deferred.reject(err);
}
return cb(err);
}
deferred.resolve(createdRecord);
return cb(null, createdRecord);
}));
}
}));
if(deferred) {
return deferred.promise;
}
}
}

OriginalL'auteur scott