PostgreSQL ਐਂਟੀਪੈਟਰਨ: "ਸਿਰਫ਼ ਇੱਕ ਹੀ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ!"

SQL ਵਿੱਚ, ਤੁਸੀਂ ਵਰਣਨ ਕਰਦੇ ਹੋ ਕਿ ਤੁਸੀਂ "ਕੀ" ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਨਾ ਕਿ "ਕਿਵੇਂ" ਇਹ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਸ ਲਈ, "ਜਿਵੇਂ ਕਿ ਇਹ ਸੁਣਿਆ ਜਾਂਦਾ ਹੈ ਕਿ ਇਹ ਕਿਵੇਂ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ" ਦੀ ਸ਼ੈਲੀ ਵਿੱਚ SQL ਸਵਾਲਾਂ ਨੂੰ ਵਿਕਸਤ ਕਰਨ ਦੀ ਸਮੱਸਿਆ, ਇਸਦੇ ਨਾਲ, ਸਨਮਾਨ ਦੀ ਜਗ੍ਹਾ ਲੈਂਦੀ ਹੈ. SQL ਵਿੱਚ ਸਥਿਤੀ ਦੇ ਮੁਲਾਂਕਣ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ.

ਅੱਜ, ਬਹੁਤ ਹੀ ਸਧਾਰਨ ਉਦਾਹਰਣਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਆਓ ਦੇਖੀਏ ਕਿ ਇਸ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਸੰਦਰਭ ਵਿੱਚ ਕੀ ਹੋ ਸਕਦਾ ਹੈ GROUP/DISTINCT и LIMIT ਉਹਨਾਂ ਨਾਲ.

ਜੇਕਰ ਤੁਸੀਂ ਬੇਨਤੀ ਵਿੱਚ ਲਿਖਿਆ ਹੈ ਤਾਂ ਇਹ ਹੈ "ਪਹਿਲਾਂ ਇਹਨਾਂ ਗੋਲੀਆਂ ਨੂੰ ਜੋੜੋ, ਅਤੇ ਫਿਰ ਸਾਰੇ ਡੁਪਲੀਕੇਟਸ ਨੂੰ ਬਾਹਰ ਸੁੱਟ ਦਿਓ, ਸਿਰਫ਼ ਇੱਕ ਹੀ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਹਰੇਕ ਕੁੰਜੀ ਲਈ ਉਦਾਹਰਨ" - ਇਹ ਬਿਲਕੁਲ ਇਸ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰੇਗਾ, ਭਾਵੇਂ ਕੁਨੈਕਸ਼ਨ ਦੀ ਬਿਲਕੁਲ ਲੋੜ ਨਹੀਂ ਸੀ।

ਅਤੇ ਕਈ ਵਾਰ ਤੁਸੀਂ ਖੁਸ਼ਕਿਸਮਤ ਹੁੰਦੇ ਹੋ ਅਤੇ ਇਹ "ਸਿਰਫ਼ ਕੰਮ ਕਰਦਾ ਹੈ", ਕਈ ਵਾਰ ਇਸਦਾ ਪ੍ਰਦਰਸ਼ਨ 'ਤੇ ਇੱਕ ਕੋਝਾ ਪ੍ਰਭਾਵ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਕਈ ਵਾਰ ਇਹ ਪ੍ਰਭਾਵ ਦਿੰਦਾ ਹੈ ਜੋ ਵਿਕਾਸਕਰਤਾ ਦੇ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ ਬਿਲਕੁਲ ਅਣਕਿਆਸੇ ਹੁੰਦੇ ਹਨ।

ਖੈਰ, ਸ਼ਾਇਦ ਇੰਨਾ ਸ਼ਾਨਦਾਰ ਨਹੀਂ, ਪਰ…

"ਮਿੱਠਾ ਜੋੜਾ": JOIN + DISTINCT

SELECT DISTINCT
  X.*
FROM
  X
JOIN
  Y
    ON Y.fk = X.pk
WHERE
  Y.bool_condition;

ਇਹ ਕਿਵੇਂ ਸਪੱਸ਼ਟ ਹੋਵੇਗਾ ਕਿ ਉਹ ਕੀ ਚਾਹੁੰਦੇ ਹਨ ਅਜਿਹੇ ਰਿਕਾਰਡ X ਦੀ ਚੋਣ ਕਰੋ, ਜਿਸ ਲਈ Y ਵਿੱਚ ਪੂਰੀ ਹੋਈ ਸ਼ਰਤ ਨਾਲ ਸਬੰਧਿਤ ਹਨ. ਰਾਹੀਂ ਬੇਨਤੀ ਕੀਤੀ JOIN - pk ਦੇ ਕੁਝ ਮੁੱਲ ਕਈ ਵਾਰ ਪ੍ਰਾਪਤ ਕੀਤੇ (ਬਿਲਕੁਲ ਕਿੰਨੇ ਢੁਕਵੇਂ ਰਿਕਾਰਡ Y ਵਿੱਚ ਨਿਕਲੇ)। ਕਿਵੇਂ ਹਟਾਉਣਾ ਹੈ? ਯਕੀਨਨ DISTINCT!

ਇਹ ਖਾਸ ਤੌਰ 'ਤੇ "ਸੁਹਾਵਣਾ" ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਹਰੇਕ ਐਕਸ-ਰਿਕਾਰਡ ਲਈ ਕਈ ਸੌ ਸੰਬੰਧਿਤ Y-ਰਿਕਾਰਡ ਹੁੰਦੇ ਹਨ, ਅਤੇ ਫਿਰ ਡੁਪਲੀਕੇਟ ਬਹਾਦਰੀ ਨਾਲ ਹਟਾ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ ...

ਕਿਵੇਂ ਠੀਕ ਕਰਨਾ ਹੈ? ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਇਹ ਮਹਿਸੂਸ ਕਰੋ ਕਿ ਕੰਮ ਨੂੰ ਇਸ ਵਿੱਚ ਸੋਧਿਆ ਜਾ ਸਕਦਾ ਹੈ "ਉਨ੍ਹਾਂ ਰਿਕਾਰਡਾਂ ਦੀ ਚੋਣ ਕਰੋ X ਜਿਨ੍ਹਾਂ ਲਈ Y ਵਿੱਚ ਘੱਟੋ-ਘੱਟ ਇੱਕ ਦੀ ਪੂਰਤੀ ਹੋਣ ਵਾਲੀ ਸ਼ਰਤ ਨਾਲ ਸਬੰਧਿਤ ਹੈ" - ਆਖ਼ਰਕਾਰ, ਸਾਨੂੰ Y-ਰਿਕਾਰਡ ਤੋਂ ਕਿਸੇ ਚੀਜ਼ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।

ਨੇਸਟਡ ਮੌਜੂਦ ਹੈ

SELECT
  *
FROM
  X
WHERE
  EXISTS(
    SELECT
      NULL
    FROM
      Y
    WHERE
      fk = X.pk AND
      bool_condition
    LIMIT 1
  );

PostgreSQL ਦੇ ਕੁਝ ਸੰਸਕਰਣ ਸਮਝਦੇ ਹਨ ਕਿ ਮੌਜੂਦ ਵਿੱਚ ਇਹ ਪਹਿਲਾ ਰਿਕਾਰਡ ਲੱਭਣ ਲਈ ਕਾਫੀ ਹੈ ਜੋ ਸਾਹਮਣੇ ਆਉਂਦਾ ਹੈ, ਪੁਰਾਣੇ ਲੋਕ ਨਹੀਂ ਕਰਦੇ। ਇਸ ਲਈ, ਮੈਂ ਹਮੇਸ਼ਾਂ ਸੰਕੇਤ ਦੇਣਾ ਪਸੰਦ ਕਰਦਾ ਹਾਂ LIMIT 1 ਅੰਦਰ EXISTS.

ਲੇਟਰਲ ਜੁਆਇਨ

SELECT
  X.*
FROM
  X
, LATERAL (
    SELECT
      Y.*
    FROM
      Y
    WHERE
      fk = X.pk AND
      bool_condition
    LIMIT 1
  ) Y
WHERE
  Y IS DISTINCT FROM NULL;

ਇਹੀ ਵਿਕਲਪ, ਜੇਕਰ ਲੋੜ ਹੋਵੇ, ਉਸੇ ਸਮੇਂ ਮਿਲੇ ਸਬੰਧਿਤ Y-ਰਿਕਾਰਡ ਤੋਂ ਕੁਝ ਡਾਟਾ ਤੁਰੰਤ ਵਾਪਸ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਇੱਕ ਸਮਾਨ ਵਿਕਲਪ ਲੇਖ ਵਿੱਚ ਚਰਚਾ ਕੀਤੀ ਗਈ ਹੈ "PostgreSQL ਐਂਟੀਪੈਟਰਨ: ਦੁਰਲੱਭ ਰਿਕਾਰਡ ਸ਼ਾਮਲ ਹੋਣ ਦੇ ਮੱਧ ਤੱਕ ਪਹੁੰਚ ਜਾਵੇਗਾ".

"ਹੋਰ ਭੁਗਤਾਨ ਕਿਉਂ ਕਰੋ": DISTINCT [ON] + LIMIT 1

ਅਜਿਹੇ ਪੁੱਛਗਿੱਛ ਪਰਿਵਰਤਨ ਦਾ ਇੱਕ ਵਾਧੂ ਫਾਇਦਾ ਰਿਕਾਰਡਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਸੀਮਤ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਹੈ ਜੇਕਰ ਉਹਨਾਂ ਵਿੱਚੋਂ ਸਿਰਫ ਇੱਕ / ਕੁਝ ਦੀ ਲੋੜ ਹੈ, ਜਿਵੇਂ ਕਿ ਹੇਠਾਂ ਦਿੱਤੇ ਕੇਸ ਵਿੱਚ:

SELECT DISTINCT ON(X.pk)
  *
FROM
  X
JOIN
  Y
    ON Y.fk = X.pk
LIMIT 1;

ਹੁਣ ਅਸੀਂ ਬੇਨਤੀ ਨੂੰ ਪੜ੍ਹਦੇ ਹਾਂ ਅਤੇ ਇਹ ਸਮਝਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹਾਂ ਕਿ DBMS ਨੂੰ ਕੀ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ:

• ਅਸੀਂ ਪਲੇਟਾਂ ਨੂੰ ਜੋੜਦੇ ਹਾਂ
• X.pk ਦੁਆਰਾ ਵਿਲੱਖਣ
• ਬਾਕੀ ਬਚੇ ਰਿਕਾਰਡਾਂ ਵਿੱਚੋਂ ਇੱਕ ਚੁਣੋ

ਤਾਂ ਤੁਹਾਨੂੰ ਕੀ ਮਿਲਿਆ? "ਕੁਝ ਇੱਕ ਰਿਕਾਰਡ" ਵਿਲੱਖਣ ਤੋਂ - ਅਤੇ ਜੇ ਤੁਸੀਂ ਇਸ ਨੂੰ ਗੈਰ-ਵਿਲੱਖਣ ਵਿੱਚੋਂ ਇੱਕ ਲੈਂਦੇ ਹੋ, ਤਾਂ ਕੀ ਨਤੀਜਾ ਕਿਸੇ ਤਰ੍ਹਾਂ ਬਦਲ ਜਾਵੇਗਾ? .. "ਅਤੇ ਜੇ ਕੋਈ ਅੰਤਰ ਨਹੀਂ ਹੈ, ਤਾਂ ਹੋਰ ਭੁਗਤਾਨ ਕਿਉਂ ਕਰੋ?"

SELECT
  *
FROM
  (
    SELECT
      *
    FROM
      X
    -- сюда можно подсунуть подходящих условий
    LIMIT 1 -- +1 Limit
  ) X
JOIN
  Y
    ON Y.fk = X.pk
LIMIT 1;

ਅਤੇ ਨਾਲ ਬਿਲਕੁਲ ਉਹੀ ਥੀਮ GROUP BY + LIMIT 1.

"ਮੈਨੂੰ ਹੁਣੇ ਪੁੱਛਣਾ ਹੈ": ਅਪ੍ਰਤੱਖ GROUP + LIMIT

ਇਹੋ ਜਿਹੀਆਂ ਚੀਜ਼ਾਂ ਵੱਖੋ-ਵੱਖਰੀਆਂ ਵਿੱਚ ਵਾਪਰਦੀਆਂ ਹਨ ਅਧੂਰੇਪਣ ਦੀ ਜਾਂਚ ਲੇਬਲ ਜਾਂ CTEs ਜਿਵੇਂ ਕਿ ਬੇਨਤੀ ਅੱਗੇ ਵਧਦੀ ਹੈ:

...
CASE
  WHEN (
    SELECT
      count(*)
    FROM
      X
    LIMIT 1
  ) = 0 THEN ...

ਕੁੱਲ ਫੰਕਸ਼ਨ (count/min/max/sum/...) ਨੂੰ ਪੂਰੇ ਸੈੱਟ 'ਤੇ ਸਫਲਤਾਪੂਰਵਕ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਭਾਵੇਂ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਨਿਰਧਾਰਿਤ ਕੀਤੇ ਬਿਨਾਂ GROUP BY. ਸਿਰਫ ਇੱਥੇ ਨਾਲ LIMIT ਉਹ ਬਹੁਤ ਦੋਸਤਾਨਾ ਨਹੀਂ ਹਨ।

ਡਿਵੈਲਪਰ ਸੋਚ ਸਕਦਾ ਹੈ "ਹੁਣ, ਜੇ ਉੱਥੇ ਰਿਕਾਰਡ ਹਨ, ਤਾਂ ਮੈਨੂੰ ਸੀਮਾ ਤੋਂ ਵੱਧ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ". ਪਰ ਤੁਹਾਨੂੰ ਇਹ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ! ਕਿਉਂਕਿ ਅਧਾਰ ਲਈ ਇਹ ਹੈ:

• ਉਹ ਕੀ ਚਾਹੁੰਦੇ ਹਨ ਗਿਣੋ ਸਾਰੇ ਰਿਕਾਰਡਾਂ 'ਤੇ
• ਜਿੰਨੀਆਂ ਲਾਈਨਾਂ ਉਹ ਪੁੱਛਦੇ ਹਨ ਦਿਓ

ਟੀਚੇ ਦੀਆਂ ਸਥਿਤੀਆਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦਿਆਂ, ਹੇਠਾਂ ਦਿੱਤੇ ਬਦਲਾਂ ਵਿੱਚੋਂ ਇੱਕ ਬਣਾਉਣਾ ਉਚਿਤ ਹੈ:

• (count + LIMIT 1) = 0 'ਤੇ NOT EXISTS(LIMIT 1)
• (count + LIMIT 1) > 0 'ਤੇ EXISTS(LIMIT 1)
• count >= N 'ਤੇ (SELECT count(*) FROM (... LIMIT N))

"ਗ੍ਰਾਮ ਵਿੱਚ ਕਿੰਨਾ ਲਟਕਣਾ ਹੈ": DISTINCT + LIMIT

SELECT DISTINCT
  pk
FROM
  X
LIMIT $1

ਇੱਕ ਭੋਲਾ ਵਿਕਾਸਕਾਰ ਈਮਾਨਦਾਰੀ ਨਾਲ ਵਿਸ਼ਵਾਸ ਕਰ ਸਕਦਾ ਹੈ ਕਿ ਇੱਕ ਬੇਨਤੀ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਬੰਦ ਹੋ ਜਾਵੇਗਾ, ਜਿਵੇਂ ਹੀ ਸਾਨੂੰ ਪਹਿਲੇ $1 ਵੱਖ-ਵੱਖ ਮੁੱਲ ਮਿਲਦੇ ਹਨ ਜੋ ਸਾਹਮਣੇ ਆਉਂਦੇ ਹਨ.

ਭਵਿੱਖ ਵਿੱਚ ਕਿਸੇ ਸਮੇਂ, ਇਹ ਇੱਕ ਨਵੇਂ ਨੋਡ ਦਾ ਧੰਨਵਾਦ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਕੰਮ ਕਰੇਗਾ ਸੂਚਕਾਂਕ ਛੱਡੋ ਸਕੈਨ, ਜਿਸ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਫਿਲਹਾਲ ਕੰਮ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ, ਪਰ ਅਜੇ ਤੱਕ ਨਹੀਂ।

ਹੁਣ ਤੱਕ ਪਹਿਲੀ ਸਾਰੇ ਰਿਕਾਰਡ ਮੁੜ ਪ੍ਰਾਪਤ ਕੀਤੇ ਜਾਣਗੇ, ਵਿਲੱਖਣ ਹਨ, ਅਤੇ ਉਹਨਾਂ ਵਿੱਚੋਂ ਜਿੰਨੇ ਹੀ ਬੇਨਤੀ ਕੀਤੇ ਗਏ ਹਨ ਵਾਪਸ ਕੀਤੇ ਜਾਣਗੇ। ਇਹ ਖਾਸ ਤੌਰ 'ਤੇ ਉਦਾਸ ਹੈ ਜੇਕਰ ਅਸੀਂ ਕੁਝ ਅਜਿਹਾ ਚਾਹੁੰਦੇ ਹਾਂ $1 = 4, ਅਤੇ ਸਾਰਣੀ ਵਿੱਚ ਸੈਂਕੜੇ ਹਜ਼ਾਰਾਂ ਰਿਕਾਰਡ ਹਨ ...

ਵਿਅਰਥ ਵਿੱਚ ਉਦਾਸ ਨਾ ਹੋਣ ਲਈ, ਅਸੀਂ ਇੱਕ ਦੁਹਰਾਉਣ ਵਾਲੀ ਪੁੱਛਗਿੱਛ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ PostgreSQL ਵਿਕੀ ਤੋਂ "ਗਰੀਬਾਂ ਲਈ ਵੱਖਰਾ":

ਸਰੋਤ: www.habr.com