PostgreSQL'de satır olup olmadığını en hızlı kontrol etme

Tabloya eklemek için gereken satırlar bir grup var, ama bu ekler her zaman toplu olarak yapılır. Bu yüzden toplu işten tek bir satır olup olmadığını kontrol etmek istiyorum çünkü o zaman hepsinin eklendiğini biliyorum.

Yani birincil anahtar kontrolü değil, ama çok da önemli değil. Ben sadece tek satır kontrol etmek istiyorum, bu yüzden count(*)muhtemelen iyi değil, bu yüzden existssanırım onun gibi bir şey .

Ama PostgreSQL için oldukça yeni olduğum için bilen insanlara sormayı tercih ederim.

Toplu işim aşağıdaki yapıya sahip satırlar içeriyor:

userid | rightid | remaining_count

Tablonun sağlandığı herhangi bir satır içermesi, useridhepsinin orada bulunduğu anlamına gelir.

DOĞRU / YANLIŞ dönüş için EXISTS anahtar sözcüğünü kullanın:

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

Basitçe:

select 1 from tbl where userid = 123 limit 1;

nerede 123 olduğunuz grubun kullanıcı kimliği .

Yukarıdaki sorgu, belirtilen kullanıcı kimliğine sahip kayıtların olup olmamasına bağlı olarak boş bir küme veya tek bir satır döndürür.

Bu çok yavaş çıkıyorsa, üzerinde bir dizin oluşturmaya bakabilirsiniz tbl.userid.

tablodaki toplu işten tek bir satır bile varsa, bu durumda satırları eklemek zorunda değilim çünkü hepsinin eklendiğinden eminim.

Programınız toplu iş ortasında kesintiye uğramış olsa bile doğru kalması için veritabanı işlemlerini uygun şekilde yönettiğinizden emin olmanızı öneririm (tüm toplu iş tek bir işlemde eklenir).

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: yinelenen bir durumda tüm toplu işin başarısız olmasını istiyorsanız, (birincil anahtar kısıtlaması verildiğinde)

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

tam olarak istediğinizi yapar: ya başarılı olur ya da başarısız olur.

select true from tablename where condition limit 1;

Bu postgres yabancı anahtarları kontrol etmek için kullandığı sorgu olduğuna inanıyorum.

Sizin durumunuzda, bunu tek seferde de yapabilirsiniz:

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

@MikeM'in işaret ettiği gibi.

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

ile endeks temas, genellikle 1 ms zaman maliyetini düşürebilir.

CREATE INDEX index_contact on contact(id);

SELECT 1 FROM user_right where userid = ? LIMIT 1

Sonuç kümeniz bir satır içeriyorsa, eklemeniz gerekmez. Aksi takdirde kayıtlarınızı ekleyin.

Performansı düşünüyorsanız, "PERFORM" u aşağıdaki gibi bir işlevde kullanabilirsiniz:

 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;

Özellikle Cezanı ele almak başka bir düşünce önermek istiyorum: "Ben çünkü partiden tek bir satır tabloda varsa kontrol etmek istiyorum Yani hepsi biliyor ardından edildi takılı ."

"Gruplar" içine yerleştirerek işleri verimli hale getiriyorsunuz, ancak varlığını kontrol etmek her seferinde bir kayıt mı? Bu bana karşı sezgisel görünüyor. Yani " ekler her zaman toplu olarak yapılır " derken, bir insert deyimiyle birden çok kayıt eklediğiniz anlamına gelir . Postgres'in ASİT ile uyumlu olduğunu bilmeniz gerekir. Bir insert deyimiyle birden çok kayıt (bir grup veri) ekliyorsanız , bazılarının eklenip eklenmediğini kontrol etmeye gerek yoktur. İfade ya geçer ya da başarısız olur. Tüm kayıtlar eklenecek veya eklenmeyecek.

Öte yandan, C # kodunuz basitçe bir "set" ayrı ekleme deyimi yapıyorsa, örneğin, bir döngü içinde ve aklınızda, bu bir "toplu iş" .. o zaman aslında " ". "Parti" olarak adlandırdığınız şeyin bir kısmının eklenmeyeceğini beklediğiniz ve aslında bir kontrole ihtiyaç duyduğunuzu düşünmeniz, bu durumda daha temel bir sorununuz olduğunu güçlü bir şekilde göstermektedir. Tek bir eklemeyle birden çok kayıt eklemek için paradigmanızı değiştirmeniz ve tek tek kayıtların yapılıp yapılmadığını kontrol etmeye devam etmeniz gerekir.

Bu örneği düşünün:

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

Bu aslında herhangi bir ACID uyumlu DB için paradigma .. sadece Postgresql değil. Başka bir deyişle, "toplu" kavramınızı düzeltir ve ilk etapta herhangi bir satır kontrol yapmak zorunda kalmazsanız daha iyi olursunuz.