Sails.js Modell - einfügen oder aktualisieren von Datensätzen

Habe ich umgeschrieben, Kritische Mash-code, also seine Art und Weise weniger code und mehr Generika.
Rufen Sie nun updateOrCreate die gleiche Weise rufen Sie findOrCreate. Und es sieht so aus, dass:

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);
          }
        });
    }
};

So, dass die Art und Weise, die Sie schreiben können Kriterien auf die gleiche Weise. keine Notwendigkeit, die Arbeit auf die Taste, und der code ist so viel einfacher.

Ihre Lösung richtig ist. Es gibt keinen anderen Weg, dies zu tun mit der Wasserlinie (die ORM von sails.js).
Aber mehrere Datenbanken Funktionen für diesen Fall:

MySQL

REPLACE INTO table SET id = 42, foo = 'bar';
(mit primary-oder unique-Schlüssel. Ziemlich beschissen, wenn Sie auto_increment 😉

In der Wasserlinie können Sie das Modell.query()-Funktion ausführen direkten SQL (siehe: http://sailsjs.org/#/documentation/reference/waterline/models/query.html)

MongoDB

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

Den upsert Flagge bedeutet: Wenn Sie nicht aktualisieren Sie es, weil Sie nicht finden, alles, was mit der Abfrage erstellen, die dieses element!

In der Wasserlinie können Sie das Modell.native()-Funktion ausführen direkten mongoDB-Befehle (siehe: http://sailsjs.org/#/documentation/reference/waterline/models/native.html)

Abschluss

Müssen Sie schnelle Ausführung (und von corse, wenn Sie haben viele viele Anfrage), würde ich vorschlagen, die Verwendung der Muttersprache/sql-Funktionen. Aber im Allgemeinen bin ich wirklich ein fan von der Flexibilität der ein ORM-System und jedes mal, wenn Sie die Verwendung von Datenbank-spezifischen Funktionen ist es schwieriger zu handhaben.

Dies ist, wie ich es mache: ich bringe das config/models.js um die Funktionalität und es prüft, um zu sehen, ob der adapter hat den richtigen Methoden. Sie können es nennen, wie ein Versprechen oder normal.

    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;
        }
    }
}