PostgreSQL ആന്റിപാറ്റേണുകൾ: "ഒരെണ്ണം മാത്രമേ അവശേഷിക്കുന്നുള്ളൂ!"

SQL-ൽ, നിങ്ങൾ "എന്താണ്" നേടാൻ ആഗ്രഹിക്കുന്നതെന്ന് വിവരിക്കുന്നു, അത് നടപ്പിലാക്കേണ്ടത് "എങ്ങനെ" എന്നല്ല. അതിനാൽ, "കേൾക്കുന്നതുപോലെ എഴുതിയിരിക്കുന്നതുപോലെ" എന്ന ശൈലിയിൽ SQL അന്വേഷണങ്ങൾ വികസിപ്പിക്കുന്നതിലെ പ്രശ്നം അതിന്റെ ബഹുമതിയുടെ സ്ഥാനത്ത് എടുക്കുന്നു. SQL-ൽ വ്യവസ്ഥകൾ കണക്കാക്കുന്നതിനുള്ള സവിശേഷതകൾ.

ഇന്ന്, വളരെ ലളിതമായ ഉദാഹരണങ്ങൾ ഉപയോഗിച്ച്, ഉപയോഗത്തിന്റെ പശ്ചാത്തലത്തിൽ ഇത് എന്തിലേക്ക് നയിക്കുമെന്ന് നോക്കാം GROUP/DISTINCT и LIMIT അവരോടൊപ്പം.

ഇപ്പോൾ, നിങ്ങൾ അഭ്യർത്ഥനയിൽ എഴുതിയെങ്കിൽ "ആദ്യം ഈ അടയാളങ്ങൾ ബന്ധിപ്പിക്കുക, തുടർന്ന് എല്ലാ തനിപ്പകർപ്പുകളും എറിയുക, ഒരെണ്ണം മാത്രമേ ശേഷിക്കാവൂ ഓരോ കീയ്ക്കും പകർത്തുക" - കണക്ഷൻ ആവശ്യമില്ലെങ്കിലും ഇത് കൃത്യമായി പ്രവർത്തിക്കും.

ചിലപ്പോൾ നിങ്ങൾ ഭാഗ്യവാനാണ്, അത് "വെറും പ്രവർത്തിക്കുന്നു", ചിലപ്പോൾ ഇത് പ്രകടനത്തിൽ അസുഖകരമായ സ്വാധീനം ചെലുത്തുന്നു, ചിലപ്പോൾ ഇത് ഡവലപ്പറുടെ കാഴ്ചപ്പാടിൽ നിന്ന് തികച്ചും അപ്രതീക്ഷിതമായ ഇഫക്റ്റുകൾ നൽകുന്നു.

ശരി, ഒരുപക്ഷേ അത്ര ഗംഭീരമല്ല, പക്ഷേ ...

"മധുര ദമ്പതികൾ": ചേരുക + ഡിസ്റ്റിങ്ക്റ്റ്

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

അവർക്ക് എന്താണ് വേണ്ടതെന്ന് വ്യക്തമാകും പൂർത്തിയാക്കിയ അവസ്ഥയുമായി ബന്ധപ്പെട്ട Y-ൽ റെക്കോർഡുകൾ ഉള്ള X റെക്കോർഡുകൾ തിരഞ്ഞെടുക്കുക. വഴി ഒരു അപേക്ഷ എഴുതി JOIN - കുറച്ച് pk മൂല്യങ്ങൾ പലതവണ ലഭിച്ചു (കൃത്യമായി എത്ര അനുയോജ്യമായ എൻട്രികൾ Y-ൽ പ്രത്യക്ഷപ്പെട്ടു). എങ്ങനെ നീക്കം ചെയ്യാം? തീർച്ചയായും DISTINCT!

ഓരോ എക്‌സ്-റെക്കോർഡിനും നൂറുകണക്കിന് വൈ-റെക്കോർഡുകൾ ഉള്ളപ്പോൾ ഇത് പ്രത്യേകിച്ചും "സന്തോഷകരമാണ്", തുടർന്ന് ഡ്യൂപ്ലിക്കേറ്റുകൾ വീരോചിതമായി നീക്കം ചെയ്യപ്പെടുന്നു ...

എങ്ങനെ ശരിയാക്കാം? ആരംഭിക്കുന്നതിന്, പ്രശ്നം മാറ്റാൻ കഴിയുമെന്ന് മനസ്സിലാക്കുക "നിവർത്തിച്ച അവസ്ഥയുമായി Y-ൽ കുറഞ്ഞത് ഒരെണ്ണമെങ്കിലും ബന്ധപ്പെട്ടിരിക്കുന്ന X രേഖകൾ തിരഞ്ഞെടുക്കുക" - എല്ലാത്തിനുമുപരി, Y- റെക്കോർഡിൽ നിന്ന് തന്നെ ഞങ്ങൾക്ക് ഒന്നും ആവശ്യമില്ല.

നെസ്റ്റഡ് EXISTS

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

PostgreSQL-ന്റെ ചില പതിപ്പുകൾ, EXISTS-ൽ വരുന്ന ആദ്യ എൻട്രി കണ്ടെത്തിയാൽ മതിയെന്നും പഴയവ കണ്ടെത്തുന്നില്ലെന്നും മനസ്സിലാക്കുന്നു. അതുകൊണ്ട് എപ്പോഴും സൂചിപ്പിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു 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

സമാനമായ കാര്യങ്ങൾ വ്യത്യസ്ത സ്ഥലങ്ങളിൽ സംഭവിക്കുന്നു ശൂന്യതയില്ലാത്ത പരിശോധനകൾ അഭ്യർത്ഥന പുരോഗമിക്കുമ്പോൾ അടയാളങ്ങൾ അല്ലെങ്കിൽ CTEകൾ:

...
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 വിക്കിയിൽ നിന്നുള്ള "DISTINCT ദരിദ്രർക്കുള്ളതാണ്":

അവലംബം: www.habr.com