Vérification la plus rapide si la ligne existe dans PostgreSQL

J'ai un tas de lignes que je dois insérer dans le tableau, mais ces insertions sont toujours faites par lots. Je veux donc vérifier si une seule ligne du lot existe dans le tableau car je sais alors qu'ils ont tous été insérés.

Ce n'est donc pas une vérification de clé primaire, mais cela ne devrait pas trop avoir d'importance. Je voudrais ne vérifier qu'une seule ligne, donc ce count(*)n'est probablement pas bon, donc c'est quelque chose comme existsje suppose.

Mais comme je suis assez nouveau dans PostgreSQL, je préfère demander aux gens qui savent.

Mon lot contient des lignes avec la structure suivante:

userid | rightid | remaining_count

Donc, si la table contient des lignes fournies, useridcela signifie qu'elles y sont toutes présentes.

Utilisez le mot clé EXISTS pour un retour TRUE / FALSE:

select exists(select 1 from contact where id=12)

Que diriez-vous simplement:

select 1 from tbl where userid = 123 limit 1;

où 123est l'ID utilisateur du lot que vous êtes sur le point d'insérer.

La requête ci-dessus renverra un ensemble vide ou une seule ligne, selon qu'il existe des enregistrements avec l'ID utilisateur donné.

Si cela s'avère trop lent, vous pouvez envisager de créer un index sur tbl.userid.

si même une seule ligne du lot existe dans la table, dans ce cas, je n'ai pas à insérer mes lignes car je sais avec certitude qu'elles ont toutes été insérées.

Pour que cela reste vrai même si votre programme est interrompu au milieu du lot, je vous recommande de vous assurer de gérer correctement les transactions de la base de données (c'est-à-dire que le lot entier est inséré dans une seule transaction).

INSERT INTO target( userid, rightid, count )
  SELECT userid, rightid, count 
  FROM batch
  WHERE NOT EXISTS (
    SELECT * FROM target t2, batch b2
    WHERE t2.userid = b2.userid
    -- ... other keyfields ...
    )       
    ;

BTW: si vous voulez que tout le lot échoue en cas de duplication, alors (étant donné une contrainte de clé primaire)

INSERT INTO target( userid, rightid, count )
SELECT userid, rightid, count 
FROM batch
    ;

fera exactement ce que vous voulez: soit il réussit, soit il échoue.

select true from tablename where condition limit 1;

Je crois que c'est la requête que postgres utilise pour vérifier les clés étrangères.

Dans votre cas, vous pouvez également le faire en une seule fois:

insert into yourtable select $userid, $rightid, $count where not (select true from yourtable where userid = $userid limit 1);

comme l'a souligné @MikeM.

select exists(select 1 from contact where id=12)

avec un index sur contact, il peut généralement réduire le coût en temps à 1 ms.

CREATE INDEX index_contact on contact(id);

SELECT 1 FROM user_right where userid = ? LIMIT 1

Si votre jeu de résultats contient une ligne, vous n'avez pas besoin d'insérer. Sinon, insérez vos enregistrements.

Si vous pensez à la performance, vous pouvez peut-être utiliser "PERFORM" dans une fonction comme celle-ci:

 PERFORM 1 FROM skytf.test_2 WHERE id=i LIMIT 1;
  IF FOUND THEN
      RAISE NOTICE ' found record id=%', i;  
  ELSE
      RAISE NOTICE ' not found record id=%', i;  
 END IF;

Je voudrais proposer une autre réflexion pour répondre spécifiquement à votre phrase: "Je veux donc vérifier si une seule ligne du lot existe dans le tableau parce qu'alors je sais qu'elles ont toutes été insérées ."

Vous rendez les choses efficaces en insérant des "lots" mais en effectuant ensuite des vérifications d'existence un enregistrement à la fois? Cela me semble contre-intuitif. Donc, quand vous dites "les insertions sont toujours effectuées par lots ", je suppose que vous voulez dire que vous insérez plusieurs enregistrements avec une instruction d'insertion . Vous devez vous rendre compte que Postgres est conforme à ACID. Si vous insérez plusieurs enregistrements (un lot de données) avec une instruction d'insertion , il n'est pas nécessaire de vérifier si certains ont été insérés ou non. L'instruction réussit ou échouera. Tous les enregistrements seront insérés ou aucun.

D'un autre côté, si votre code C # fait simplement un "set" d'instructions d'insertion séparées, par exemple, dans une boucle, et dans votre esprit, c'est un "batch" .. alors vous ne devriez pas en fait le décrire comme " les insertions se font toujours par lots ". Le fait que vous vous attendiez à ce qu'une partie de ce que vous appelez un "lot" ne soit en fait pas insérée, et par conséquent ressentiez le besoin d'une vérification, suggère fortement que c'est le cas, auquel cas vous avez un problème plus fondamental. Vous devez modifier votre paradigme pour insérer réellement plusieurs enregistrements avec une seule insertion et renoncer à vérifier si les enregistrements individuels l'ont fait.

Prenons cet exemple:

CREATE TABLE temp_test (
    id SERIAL PRIMARY KEY,
    sometext TEXT,
    userid INT,
    somethingtomakeitfail INT unique
)
-- insert a batch of 3 rows
;;
INSERT INTO temp_test (sometext, userid, somethingtomakeitfail) VALUES
('foo', 1, 1),
('bar', 2, 2),
('baz', 3, 3)
;;
-- inspect the data of what we inserted
SELECT * FROM temp_test
;;
-- this entire statement will fail .. no need to check which one made it
INSERT INTO temp_test (sometext, userid, somethingtomakeitfail) VALUES
('foo', 2, 4),
('bar', 2, 5),
('baz', 3, 3)  -- <<--(deliberately simulate a failure)
;;
-- check it ... everything is the same from the last successful insert ..
-- no need to check which records from the 2nd insert may have made it in
SELECT * FROM temp_test

C'est en fait le paradigme de toute base de données compatible ACID ... pas seulement de Postgresql. En d'autres termes, vous êtes mieux si vous corrigez votre concept de «lot» et évitez d'avoir à faire des vérifications ligne par ligne en premier lieu.