Самая быстрая проверка, если строка существует в PostgreSQL

У меня есть несколько строк, которые мне нужно вставить в таблицу, но эти вставки всегда выполняются партиями. Поэтому я хочу проверить, существует ли в таблице одна строка из пакета, потому что тогда я знаю, что все они были вставлены.

Так что это не проверка первичного ключа, но это не должно иметь большого значения. Я хотел бы проверить только одну строку, так что, count(*)вероятно, это не хорошо, так что это что-то вроде, existsя думаю.

Но так как я довольно новичок в PostgreSQL, я бы лучше спросил людей, которые знают.

Моя партия содержит строки со следующей структурой:

userid | rightid | remaining_count

Таким образом, если таблица содержит какие-либо строки при условии, useridэто означает, что они все присутствуют там.

Используйте ключевое слово EXISTS для возврата ИСТИНА / ЛОЖЬ:

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

Как насчет просто:

select 1 from tbl where userid = 123 limit 1;

где 123идентификатор пользователя пакета, который вы собираетесь вставить.

Приведенный выше запрос вернет либо пустой набор, либо одну строку, в зависимости от того, существуют ли записи с данным идентификатором пользователя.

Если это окажется слишком медленным, вы можете посмотреть на создание индекса tbl.userid.

если в таблице существует хотя бы одна строка из пакета, в этом случае мне не нужно вставлять свои строки, потому что я точно знаю, что все они были вставлены.

Чтобы это оставалось верным, даже если ваша программа прерывается в середине пакета, я бы порекомендовал вам убедиться, что вы правильно управляете транзакциями базы данных (то есть, что весь пакет вставляется в одну транзакцию).

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

Кстати: если вы хотите, чтобы весь пакет потерпел неудачу в случае дублирования, тогда (с учетом ограничения первичного ключа)

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

будет делать именно то, что вы хотите: либо удастся, либо не получится.

select true from tablename where condition limit 1;

Я считаю, что это запрос, который Postgres использует для проверки внешних ключей.

В вашем случае вы могли бы сделать это также за один раз:

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

как указал @MikeM.

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

с индексом на контакте, это обычно может сократить затраты времени до 1 мс.

CREATE INDEX index_contact on contact(id);

SELECT 1 FROM user_right where userid = ? LIMIT 1

Если ваш набор результатов содержит строку, то вам не нужно вставлять. В противном случае вставьте свои записи.

Если вы думаете о производительности, возможно, вы можете использовать «PERFORM» в такой функции:

 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;

Я хотел бы предложить еще одну мысль, чтобы конкретно рассмотреть ваше предложение: «Итак, я хочу проверить, существует ли в таблице одна строка из пакета, потому что тогда я знаю, что все они были вставлены ».

Вы делаете вещи эффективными, вставляя «партии», но затем проводите проверки существования по одной записи за раз? Это кажется мне нелогичным. Поэтому, когда вы говорите « вставки всегда выполняются партиями », я понимаю, что вы имеете в виду, что вы вставляете несколько записей одним оператором вставки . Вы должны понимать, что Postgres совместим с ACID. Если вы вставляете несколько записей (пакет данных) с одним оператором вставки , нет необходимости проверять, были ли некоторые вставлены или нет. Утверждение либо проходит, либо провалится. Все записи будут вставлены или нет.

С другой стороны, если ваш код на C # просто «устанавливает» отдельные операторы вставки, например, в цикле, и, по вашему мнению, это «пакет» ... тогда вам не следует описывать это как " вкладыши всегда делаются партиями ». Тот факт, что вы ожидаете, что часть того, что вы называете «партией», может быть фактически не вставлен, и, следовательно, чувствуете необходимость проверки, настоятельно подтверждает, что это именно тот случай, и в этом случае у вас есть более фундаментальная проблема. Вам нужно изменить свою парадигму, чтобы фактически вставить несколько записей одной вставкой, и отказаться от проверки, сделали ли отдельные записи это.

Рассмотрим этот пример:

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

На самом деле это парадигма для любой ACID-совместимой БД ... не только для Postgresql. Другими словами, вам лучше, если вы исправите свою «пакетную» концепцию и избежите необходимости выполнять какие-либо построчные проверки в первую очередь.