PostgreSQL એન્ટિપેટર્ન: "ફક્ત એક જ હોવો જોઈએ!"

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 મૂલ્યો મળ્યા (વાય માં કેટલી યોગ્ય એન્ટ્રીઓ દેખાઈ). કેવી રીતે દૂર કરવું? ચોક્કસ DISTINCT!

તે ખાસ કરીને "પ્રસન્નતા" છે જ્યારે દરેક એક્સ-રેકોર્ડ માટે ઘણા સો સંબંધિત Y-રેકોર્ડ્સ હોય છે, અને પછી ડુપ્લિકેટ્સ વીરતાપૂર્વક દૂર કરવામાં આવે છે...

કેવી રીતે ઠીક કરવું? શરૂ કરવા માટે, સમજો કે સમસ્યામાં ફેરફાર કરી શકાય છે "એક્સ રેકોર્ડ પસંદ કરો કે જેના માટે 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 [ચાલુ] + મર્યાદા 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 તેઓ બહુ મૈત્રીપૂર્ણ નથી.

વિકાસકર્તા વિચારી શકે છે "જો ત્યાં રેકોર્ડ છે, તો મારે 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 Wiki પરથી "DISTINCT ગરીબો માટે છે".:

સોર્સ: www.habr.com