Utiliser find, count ou first in parse pour tester l'existence

Question

J'ai besoin de savoir si un objet existe dans la base de données que j'utilise. Je sais que je peux utiliser query.count pour tester si le résultat est zéro alors il n'existe pas ailleurs. Mais quelqu'un m'a dit que le compte est cher donc je pense que query.first peut être plus efficace. Est-ce vrai et quelle est la meilleure façon de tester l'existence d'un objet dans la base de données?

Answer 1

la première requête ne compteront pas vos résultats, vous pouvez utiliser la requête trouver et test pour la longueur du tableau en utilisant array.length si plus de 0 ou non

Answer 2

Il serait utile si vous montriez un peu de code, mais cela est trop amusant une question à passer.

Le code de test ci-dessous, mais ma réponse non-scientifique est la suivante: tant que la requête est bien indexée, peu importe la méthode que vous utilisez. Les décomptes sont chers quand vous comptez un grand nombre d'objets, mais si vous essayez juste d'en trouver un et que la requête est indexée, je ne pense pas que ça va coûter cher.

Ok, donc maintenant pour du code. J'ai préparé quelques tests unitaires dans mon repo serveur d'analyse juste pour tester les trois différentes façons dont je pourrais penser à tester l'existence. Dans les trois cas, j'utilise objectId qui peut être spécial, donc vous pouvez facilement ajuster cela. Je fais aussi chaque test une seule fois, alors que pour être scientifique à ce sujet, nous voudrions le faire une centaine de fois chacun et en moyenne. Mais alors nous devrions penser à la mise en cache des requêtes, donc je ne fais que rester simple et vous pouvez le tester pour de vrai sur vos propres données en utilisant le même modèle.

ok, maintenant que j'ai donné toutes mes mises en garde:

describe('way to find if an object exists....', function() { 

    beforeEach(function (done) { 
    new Parse.Object('Test') 
     .save() 
     .then((testObj) => { 
     this.testObj = testObj; 
     done(); 
     }) 
     .catch(done.fail); 
    }); 

    it('should use get if we know object id', function(done) { 
    this.start = new Date(); 
    new Parse.Query('Test').get(this.testObj.id) 
     .then(result => { 
     console.log('get time exists', new Date() - this.start); 
     return expect(result.id).toBe(this.testObj.id); 
     }) 
     .then(() => { 
     this.start = new Date(); 
     return new Parse.Query('Test').get('not the id'); 
     }) 
     .then(
     () => done.fail('we shouldn\'t get here, cause the obj doesn\'t exist'), 
     // so if the get is rejected you know it doesn't exist. 
     e => { 
      console.log('get time does not exist', new Date() - this.start); 
      expect(e).toEqual(new Parse.Error(101, 'Object not found.')); 
     }) 
     .then(done) 
     .catch(done.fail); 
    }); 

    it('should also work with find', function (done) { 
    this.start = new Date(); 
    new Parse.Query('Test') 
     .equalTo('objectId', this.testObj.id) 
     .find() 
     .then(result => { 
     console.log('find time exists', new Date() - this.start); 
     return expect(result.length).toBe(1); 
     }) 
     .then(() => { 
     this.start = new Date(); 
     return new Parse.Query('Test') 
      .equalTo('objectId', 'not the id') 
      .find(); 
     }) 
     .then((result) => { 
     console.log('find time does not exist', new Date() - this.start); 
     expect(result.length).toEqual(0); 
     }) 
     .then(done) 
     .catch(done.fail); 
    }); 

    it('should also work with count', function (done) { 
    this.start = new Date(); 
    new Parse.Query('Test') 
     .equalTo('objectId', this.testObj.id) 
     .count() 
     .then(result => { 
     console.log('count time exists', new Date() - this.start); 
     return expect(result).toBe(1); 
     }) 
     .then(() => { 
     this.start = new Date(); 
     return new Parse.Query('Test') 
      .equalTo('objectId', 'not the id') 
      .count(); 
     }) 
     .then((result) => { 
     console.log('count time does not exist', new Date() - this.start); 
     expect(result).toEqual(0); 
     }) 
     .then(done) 
     .catch(done.fail); 
    }); 
}); 

qui donne ce résultat:

Jasmine started 

    way to find if an object exists.... 

    ✓ should use get if we know object id 
    get time exists 19 
    get time does not exist 8 

    ✓ should also work with find 
    find time exists 12 
    find time does not exist 9 

    ✓ should also work with count  
    count time exists 7 
    count time does not exist 6 

Donc, dans mon beau vide, dans mongo mémoire, tout est super ultra-rapide (ce sont des millisecondes), donc, en supposant que votre requête soit bien indexée, choisissez celle qui donne le code le plus lisible;)