PostgreSQL ਐਂਟੀਪੈਟਰਨ: SQL ਵਿੱਚ ਸਥਿਤੀ ਦਾ ਮੁਲਾਂਕਣ

SQL C++ ਨਹੀਂ ਹੈ, ਨਾ ਹੀ ਇਹ JavaScript ਹੈ। ਇਸ ਲਈ, ਲਾਜ਼ੀਕਲ ਸਮੀਕਰਨਾਂ ਦਾ ਮੁਲਾਂਕਣ ਵੱਖਰਾ ਹੈ, ਅਤੇ ਇਹ ਬਿਲਕੁਲ ਇੱਕੋ ਚੀਜ਼ ਨਹੀਂ ਹੈ:

WHERE fncondX() AND fncondY()

= fncondX() && fncondY()

ਇੱਕ PostgreSQL ਪੁੱਛਗਿੱਛ ਦੀ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਪਲਾਨ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਵੇਲੇ ਬਰਾਬਰ ਦੀਆਂ ਸਥਿਤੀਆਂ ਨੂੰ ਮਨਮਾਨੇ ਤੌਰ 'ਤੇ "ਮੁੜ ਵਿਵਸਥਿਤ" ਕਰ ਸਕਦਾ ਹੈ, ਵਿਅਕਤੀਗਤ ਰਿਕਾਰਡਾਂ ਲਈ ਉਹਨਾਂ ਵਿੱਚੋਂ ਕਿਸੇ ਦੀ ਵੀ ਗਣਨਾ ਨਾ ਕਰੋ, ਲਾਗੂ ਕੀਤੇ ਸੂਚਕਾਂਕ ਦੀ ਸਥਿਤੀ ਦਾ ਹਵਾਲਾ ਦਿਓ ... ਸੰਖੇਪ ਵਿੱਚ, ਸਭ ਤੋਂ ਆਸਾਨ ਤਰੀਕਾ ਇਹ ਮੰਨਣਾ ਹੈ ਕਿ ਤੁਸੀਂ ਦਾ ਪ੍ਰਬੰਧ ਨਹੀਂ ਕਰ ਸਕਦਾ ਉਹ ਕ੍ਰਮ ਜਿਸ ਵਿੱਚ ਉਹ ਹੋਣਗੇ (ਅਤੇ ਕੀ ਉਹਨਾਂ ਦੀ ਗਣਨਾ ਕੀਤੀ ਜਾਵੇਗੀ) ਬਰਾਬਰ ਹਾਲਾਤ.

ਇਸ ਲਈ, ਜੇ ਤੁਸੀਂ ਅਜੇ ਵੀ ਤਰਜੀਹ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਢਾਂਚਾਗਤ ਤੌਰ 'ਤੇ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਇਹਨਾਂ ਸ਼ਰਤਾਂ ਨੂੰ ਅਸਮਾਨ ਬਣਾਓ ਸ਼ਰਤ ਦੇ ਨਾਲ ਸਮੀਕਰਨ и ਆਪਰੇਟਰ.

ਡਾਟਾ ਅਤੇ ਉਨ੍ਹਾਂ ਨਾਲ ਕੰਮ ਕਰਨਾ ਆਧਾਰ ਹੈ ਸਾਡੇ VLSI ਕੰਪਲੈਕਸ ਦਾ, ਇਸ ਲਈ ਇਹ ਸਾਡੇ ਲਈ ਬਹੁਤ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਉਹਨਾਂ 'ਤੇ ਓਪਰੇਸ਼ਨ ਨਾ ਸਿਰਫ਼ ਸਹੀ ਢੰਗ ਨਾਲ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਸਗੋਂ ਕੁਸ਼ਲਤਾ ਨਾਲ ਵੀ. ਆਉ ਅਸੀਂ ਠੋਸ ਉਦਾਹਰਨਾਂ ਨੂੰ ਵੇਖੀਏ ਜਿੱਥੇ ਸਮੀਕਰਨ ਮੁਲਾਂਕਣ ਵਿੱਚ ਗਲਤੀਆਂ ਕੀਤੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ, ਅਤੇ ਜਿੱਥੇ ਇਹ ਉਹਨਾਂ ਦੀ ਕੁਸ਼ਲਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰਨ ਦੇ ਯੋਗ ਹੈ।

#0: RTFM

ਸ਼ੁਰੂ ਕਰਨ ਦਸਤਾਵੇਜ਼ ਤੋਂ ਉਦਾਹਰਨ:

ਜਦੋਂ ਮੁਲਾਂਕਣ ਦਾ ਕ੍ਰਮ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਨਿਰਮਾਣ ਨਾਲ ਨਿਸ਼ਚਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ CASE. ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਵਾਕ ਵਿੱਚ ਜ਼ੀਰੋ ਦੁਆਰਾ ਵੰਡ ਤੋਂ ਬਚਣ ਦਾ ਇਹ ਤਰੀਕਾ WHERE ਭਰੋਸੇਯੋਗ:

SELECT ... WHERE x > 0 AND y/x > 1.5;

ਸੁਰੱਖਿਅਤ ਵਿਕਲਪ:

SELECT ... WHERE CASE WHEN x > 0 THEN y/x > 1.5 ELSE false END;

ਉਸਾਰੀ ਵਰਤੀ ਗਈ CASE ਸਮੀਕਰਨ ਨੂੰ ਅਨੁਕੂਲਨ ਤੋਂ ਬਚਾਉਂਦਾ ਹੈ, ਇਸਲਈ ਇਸਨੂੰ ਸਿਰਫ਼ ਲੋੜ ਪੈਣ 'ਤੇ ਹੀ ਵਰਤਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

#1: ਟਰਿੱਗਰ ਸਥਿਤੀ

BEGIN
  IF cond(NEW.fld) AND EXISTS(SELECT ...) THEN
    ...
  END IF;
  RETURN NEW;
END;

ਹਰ ਚੀਜ਼ ਚੰਗੀ ਲੱਗਦੀ ਹੈ, ਪਰ... ਕੋਈ ਵੀ ਵਾਅਦਾ ਨਹੀਂ ਕਰਦਾ ਕਿ ਨਿਵੇਸ਼ ਕੀਤਾ ਗਿਆ ਹੈ SELECT ਜੇਕਰ ਪਹਿਲੀ ਸ਼ਰਤ ਗਲਤ ਹੈ ਤਾਂ ਲਾਗੂ ਨਹੀਂ ਕੀਤਾ ਜਾਵੇਗਾ। ਨਾਲ ਇਸ ਨੂੰ ਠੀਕ ਕਰੋ ਨੇਸਟਡ IF:

BEGIN
  IF cond(NEW.fld) THEN
    IF EXISTS(SELECT ...) THEN
      ...
    END IF;
  END IF;
  RETURN NEW;
END;

ਹੁਣ ਆਉ ਧਿਆਨ ਨਾਲ ਵੇਖੀਏ - ਟਰਿੱਗਰ ਫੰਕਸ਼ਨ ਦਾ ਪੂਰਾ ਸਰੀਰ "ਲਪੇਟਿਆ ਹੋਇਆ" ਨਿਕਲਿਆ IF. ਅਤੇ ਇਸਦਾ ਮਤਲਬ ਇਹ ਹੈ ਕਿ ਕੁਝ ਵੀ ਸਾਨੂੰ ਇਸ ਸਥਿਤੀ ਨੂੰ ਵਰਤ ਕੇ ਪ੍ਰਕਿਰਿਆ ਤੋਂ ਹਟਾਉਣ ਤੋਂ ਨਹੀਂ ਰੋਕਦਾ WHEN- ਹਾਲਾਤ:

BEGIN
  IF EXISTS(SELECT ...) THEN
    ...
  END IF;
  RETURN NEW;
END;
...
CREATE TRIGGER ...
  WHEN cond(NEW.fld);

ਇਹ ਪਹੁੰਚ ਤੁਹਾਨੂੰ ਗਾਰੰਟੀ ਦੇ ਨਾਲ ਸਰਵਰ ਸਰੋਤਾਂ ਨੂੰ ਬਚਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ ਜੇਕਰ ਸਥਿਤੀ ਗਲਤ ਹੈ।

#2: ਜਾਂ/ਅਤੇ ਚੇਨ

SELECT ... WHERE EXISTS(... A) OR EXISTS(... B)

ਨਹੀਂ ਤਾਂ, ਇਹ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਕਿ ਦੋਵੇਂ EXISTS ਸੱਚ ਹੋਵੇਗਾ, ਪਰ ਦੋਵਾਂ ਨੂੰ ਚਲਾਇਆ ਜਾਵੇਗਾ.

ਪਰ ਜੇ ਅਸੀਂ ਨਿਸ਼ਚਤ ਤੌਰ ਤੇ ਜਾਣਦੇ ਹਾਂ ਕਿ ਉਹਨਾਂ ਵਿੱਚੋਂ ਇੱਕ "ਸੱਚ" ਹੈ (ਜਾਂ "ਗਲਤ" - ਲਈ AND-ਜੰਜੀਰਾਂ) - ਕੀ ਕਿਸੇ ਤਰ੍ਹਾਂ "ਇਸਦੀ ਤਰਜੀਹ ਨੂੰ ਵਧਾਉਣਾ" ਸੰਭਵ ਹੈ ਤਾਂ ਜੋ ਦੂਜੀ ਨੂੰ ਇੱਕ ਵਾਰ ਫਿਰ ਲਾਗੂ ਨਾ ਕੀਤਾ ਜਾਵੇ?

ਇਹ ਪਤਾ ਚਲਦਾ ਹੈ ਕਿ ਇਹ ਸੰਭਵ ਹੈ - ਅਲਗੋਰਿਦਮਿਕ ਪਹੁੰਚ ਲੇਖ ਦੇ ਵਿਸ਼ੇ ਦੇ ਨੇੜੇ ਹੈ PostgreSQL ਐਂਟੀਪੈਟਰਨ: ਦੁਰਲੱਭ ਐਂਟਰੀ ਇੱਕ JOIN ਦੇ ਮੱਧ ਤੱਕ ਪਹੁੰਚਦੀ ਹੈ.

ਆਉ ਇਹਨਾਂ ਦੋਹਾਂ ਸ਼ਰਤਾਂ ਨੂੰ "ਕੇਸ ਦੇ ਹੇਠਾਂ ਧੱਕੋ" ਕਰੀਏ:

SELECT ...
WHERE
  CASE
    WHEN EXISTS(... A) THEN TRUE
    WHEN EXISTS(... B) THEN TRUE
  END

ਇਸ ਕੇਸ ਵਿੱਚ, ਅਸੀਂ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਕੀਤਾ ELSE-ਮੁੱਲ, ਭਾਵ, ਜੇਕਰ ਦੋਵੇਂ ਸ਼ਰਤਾਂ ਗਲਤ ਹਨ CASE ਵਾਪਸ ਆਵੇਗਾ NULL, ਜਿਸਦਾ ਅਰਥ ਹੈ FALSE в WHERE- ਹਾਲਾਤ.

ਇਸ ਉਦਾਹਰਣ ਨੂੰ ਇਕ ਹੋਰ ਤਰੀਕੇ ਨਾਲ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ - ਸੁਆਦ ਅਤੇ ਰੰਗ ਲਈ:

SELECT ...
WHERE
  CASE
    WHEN NOT EXISTS(... A) THEN EXISTS(... B)
    ELSE TRUE
  END

#3: ਸ਼ਰਤਾਂ ਨੂੰ ਕਿਵੇਂ [ਨਹੀਂ] ਲਿਖਣਾ ਹੈ

ਅਸੀਂ ਇਸ ਟਰਿੱਗਰ ਦੇ "ਅਜੀਬ" ਟਰਿੱਗਰਿੰਗ ਦੇ ਕਾਰਨਾਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ 'ਤੇ ਦੋ ਦਿਨ ਬਿਤਾਏ - ਆਓ ਦੇਖੀਏ ਕਿਉਂ।

ਸਰੋਤ:

IF( NEW."Документ_" is null or NEW."Документ_" = (select '"Комплект"'::regclass::oid) or NEW."Документ_" = (select to_regclass('"ДокументПоЗарплате"')::oid)
     AND (   OLD."ДокументНашаОрганизация" <> NEW."ДокументНашаОрганизация"
          OR OLD."Удален" <> NEW."Удален"
          OR OLD."Дата" <> NEW."Дата"
          OR OLD."Время" <> NEW."Время"
          OR OLD."ЛицоСоздал" <> NEW."ЛицоСоздал" ) ) THEN ...

ਸਮੱਸਿਆ #1: ਅਸਮਾਨਤਾ NULL ਲਈ ਖਾਤਾ ਨਹੀਂ ਹੈ

ਚਲੋ ਸਭ ਕੁਝ ਮੰਨ ਲਈਏ OLD-ਖੇਤਰ ਮਾਇਨੇ ਰੱਖਦੇ ਹਨ NULL. ਕੀ ਹੋਵੇਗਾ?

SELECT NULL <> 1 OR NULL <> 2;
-- NULL

ਅਤੇ ਹਾਲਾਤ ਨੂੰ ਬਾਹਰ ਕੰਮ ਕਰਨ ਦੇ ਨਜ਼ਰੀਏ ਤੱਕ NULL ਬਰਾਬਰ FALSE, ਜਿਵੇਂ ਉੱਪਰ ਦੱਸਿਆ ਗਿਆ ਹੈ।

ਫੈਸਲੇ ਦਾ: ਆਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰੋ IS DISTINCT FROM ਤੱਕ ROW-ਓਪਰੇਟਰ, ਇੱਕ ਵਾਰ ਵਿੱਚ ਪੂਰੇ ਰਿਕਾਰਡ ਦੀ ਤੁਲਨਾ ਕਰਨਾ:

SELECT (NULL, NULL) IS DISTINCT FROM (1, 2);
-- TRUE

ਸਮੱਸਿਆ ਨੰਬਰ 2: ਇੱਕੋ ਕਾਰਜਸ਼ੀਲਤਾ ਦਾ ਵੱਖ-ਵੱਖ ਲਾਗੂਕਰਨ

ਤੁਲਨਾ ਕਰੋ:

NEW."Документ_" = (select '"Комплект"'::regclass::oid)
NEW."Документ_" = (select to_regclass('"ДокументПоЗарплате"')::oid)

ਇੱਥੇ ਵਾਧੂ ਨਿਵੇਸ਼ ਕਿਉਂ ਹਨ SELECT? ਇੱਕ ਫੰਕਸ਼ਨ to_regclass? ਇਹ ਵੱਖਰਾ ਕਿਉਂ ਹੈ ...

ਚਲੋ ਠੀਕ ਕਰੀਏ:

NEW."Документ_" = '"Комплект"'::regclass::oid
NEW."Документ_" = '"ДокументПоЗарплате"'::regclass::oid

ਸਮੱਸਿਆ #3: ਬੂਲ ਤਰਜੀਹ

ਆਓ ਸਰੋਤ ਨੂੰ ਫਾਰਮੈਟ ਕਰੀਏ:

{... IS NULL} OR
{... Комплект} OR
{... ДокументПоЗарплате} AND
( {... неравенства} )

ਓਹੋ... ਦਰਅਸਲ, ਇਹ ਸਾਹਮਣੇ ਆਇਆ ਕਿ ਪਹਿਲੀਆਂ ਦੋ ਸ਼ਰਤਾਂ ਵਿੱਚੋਂ ਕਿਸੇ ਇੱਕ ਦੀ ਸੱਚਾਈ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਪੂਰੀ ਸਥਿਤੀ ਵਿੱਚ ਬਦਲ ਜਾਂਦੀ ਹੈ TRUE, ਅਸਮਾਨਤਾਵਾਂ ਦੀ ਅਣਦੇਖੀ ਕਰਦੇ ਹੋਏ। ਅਤੇ ਇਹ ਉਹ ਬਿਲਕੁਲ ਨਹੀਂ ਹੈ ਜੋ ਅਸੀਂ ਚਾਹੁੰਦੇ ਸੀ.

ਚਲੋ ਠੀਕ ਕਰੀਏ:

(
  {... IS NULL} OR
  {... Комплект} OR
  {... ДокументПоЗарплате}
) AND
( {... неравенства} )

ਸਮੱਸਿਆ #4 (ਛੋਟੀ): ਇੱਕ ਖੇਤਰ ਲਈ ਗੁੰਝਲਦਾਰ ਜਾਂ ਸਥਿਤੀ

ਅਸਲ ਵਿੱਚ, ਸਾਨੂੰ ਨੰਬਰ 3 ਵਿੱਚ ਸਮੱਸਿਆਵਾਂ ਸਨ ਕਿਉਂਕਿ ਇੱਥੇ ਤਿੰਨ ਸ਼ਰਤਾਂ ਸਨ। ਪਰ ਉਹਨਾਂ ਦੀ ਬਜਾਏ, ਤੁਸੀਂ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਇੱਕ ਦੇ ਨਾਲ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ coalesce ... IN:

coalesce(NEW."Документ_"::text, '') IN ('', '"Комплект"', '"ДокументПоЗарплате"')

ਅਸੀਂ ਵੀ ਹਾਂ NULL "ਕੈਚ", ਅਤੇ ਗੁੰਝਲਦਾਰ OR ਤੁਹਾਨੂੰ ਬਰੈਕਟਾਂ ਨਾਲ ਉਲਝਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।

ਕੁੱਲ

ਆਓ ਠੀਕ ਕਰੀਏ ਕਿ ਸਾਨੂੰ ਕੀ ਮਿਲਿਆ:

IF (
  coalesce(NEW."Документ_"::text, '') IN ('', '"Комплект"', '"ДокументПоЗарплате"') AND
  (
    OLD."ДокументНашаОрганизация"
  , OLD."Удален"
  , OLD."Дата"
  , OLD."Время"
  , OLD."ЛицоСоздал"
  ) IS DISTINCT FROM (
    NEW."ДокументНашаОрганизация"
  , NEW."Удален"
  , NEW."Дата"
  , NEW."Время"
  , NEW."ЛицоСоздал"
  )
) THEN ...

ਅਤੇ ਇਹ ਦਿੱਤਾ ਗਿਆ ਹੈ ਕਿ ਇਹ ਟਰਿੱਗਰ ਫੰਕਸ਼ਨ ਸਿਰਫ ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ UPDATEਮੌਜੂਦਗੀ ਦੇ ਕਾਰਨ ਟਰਿੱਗਰ OLD/NEW ਉੱਪਰੀ-ਪੱਧਰੀ ਸਥਿਤੀ ਵਿੱਚ, ਫਿਰ ਇਸ ਸਥਿਤੀ ਨੂੰ ਆਮ ਤੌਰ 'ਤੇ ਅੰਦਰ ਲਿਆ ਜਾ ਸਕਦਾ ਹੈ WHEN- ਹਾਲਤ ਜਿਵੇਂ ਕਿ # 1 ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ ...

ਸਰੋਤ: www.habr.com