SQLite et Javascript : Vérifier l'existence des données avant de les insérer OU laisser SQLite lancer une exception

Question

Ma principale question est de savoir quelle est l'approche la plus rapide.

Quelques informations

Je développe une application en utilisant Mozilla.

J'ai un module dans lequel je capture des données et les stocke dans une base de données. Les données arrivent par intermittence. Aucun doublon ne doit être stocké. Pour les besoins de la discussion, nous pouvons supposer qu'une table ne comporte qu'une seule colonne, nommée "mot-clé". Ainsi, si nous obtenons un mot-clé qui se trouve déjà dans la base de données, nous ne le stockons pas à nouveau. Et oui, nous avons défini cette colonne en tant que CLÉ PRIMAIRE et l'avons rendue UNIQUE :)

La question que je me pose est la suivante :

1) Avant d'insérer ces nouvelles données dans la base de données, dois-je faire un appel à la base de données et vérifier si le mot-clé existe ou non ; s'il n'existe pas, l'insérer dans la base de données ? Quelque chose comme :

function insert_keyword(keyword)
{
   if(!SQL.exists(keyword))
   {
       SQL.insert(keyword);
   } 
}

O

2) Je me contente d'insérer et de laisser la base de données gérer la condition, en la laissant effectivement lancer une exception, que je rattrape.

function insert_keyword(keyword)
{
    try {
       SQL.insert(keyword);
    }
    catch (e)
    {
       // keyword exists!
    }
}

Je sais qu'il n'est pas bon d'attraper une exception et de ne rien faire ! Je ne cherche donc pas à savoir ce qui est bon ou mauvais :) . Ce que je veux comprendre, c'est quelle approche serait la plus rapide. (Spécifiquement en relation avec Mozilla, JavaScript et SQLite, mais les commentaires généraux sont les bienvenus !)

Notes de bas de page : En SQL. La syntaxe que j'ai utilisée ne l'est qu'à titre d'illustration. Vous pouvez supposer que je crée des instructions SQL, que je les exécute et que je récupère le résultat, ou que c'est un appel à la bibliothèque JavaScript qui fait tout le sale boulot.

Cette question ressemble un peu à celle-ci :

Dois-je vérifier les contraintes de la base de données dans le code ou dois-je attraper les exceptions lancées par la base de données ?

Mais je souhaite comprendre les différences liées aux performances, car l'application sur laquelle je travaille doit être aussi rapide que possible (quelle application ne l'est pas ? ;) ).

Answer 1

Indiquez simplement à votre base de données d'ignorer les doublons (cela ne fonctionne que pour les colonnes qui imposent des valeurs uniques) :

INSERT OR IGNORE INTO table(keyword) VALUES("someWord");

ou créer une colonne qui ignore les doublons.

CREATE TABLE someTable(keyword PRIMARY KEY ON CONFLICT IGNORE);

Au lieu d'ignorer, il y a aussi ces clauses de conflit :

ROLLBACK
ABORT
FAIL
IGNORE
REPLACE

Pour plus d'informations, lisez le page sur les clauses de conflit de SQLite y el documentation de l'instruction INSERT .

---

Quant à savoir s'il est plus rapide d'utiliser des exceptions ou de vérifier l'existence de valeurs : Les exceptions sont coûteuses lorsqu'elles sont soulevées et leur coût est nul lorsqu'elles ne sont pas soulevées. Cela signifie que si vous vous attendez à avoir de nombreux doublons, utilisez la vérification et si seul un petit nombre de mots-clés sont des doublons, utilisez les exceptions. Après tout, les exceptions doivent être exceptionnelles.

Answer 2

Je ne suis pas sûr des spécificités de la partie mozilla/javascript de cette question, mais il existe une troisième option "insérer ou remplacer". Elle permet d'obtenir ce que vous souhaitez sans doublons et évite d'avoir à vérifier dans le code si la ligne existe déjà.