PostgreSQL ആന്റിപാറ്റേണുകൾ: ഒരു ട്രിഗർ മറികടന്ന് ഡാറ്റ മാറ്റുക

താമസിയാതെ അല്ലെങ്കിൽ പിന്നീട്, പട്ടിക രേഖകളിൽ എന്തെങ്കിലും വൻതോതിൽ ശരിയാക്കേണ്ടതിന്റെ ആവശ്യകത പലരും അഭിമുഖീകരിക്കുന്നു. എനിക്ക് ഇതിനകം ഉണ്ട് ഇത് എങ്ങനെ നന്നായി ചെയ്യാമെന്ന് എന്നോട് പറയുക, എങ്ങനെ - അത് ചെയ്യാതിരിക്കുന്നതാണ് നല്ലത്. ഇന്ന് ഞാൻ മാസ് അപ്‌ഡേറ്റിന്റെ രണ്ടാം വശത്തെക്കുറിച്ച് സംസാരിക്കും - ട്രിഗറുകളെ കുറിച്ച്.

ഉദാഹരണത്തിന്, നിങ്ങൾ എന്തെങ്കിലും ശരിയാക്കേണ്ട ഒരു മേശയിൽ, ഒരു ദുഷിച്ച ട്രിഗർ തൂങ്ങിക്കിടക്കുന്നു ON UPDATE, എല്ലാ മാറ്റങ്ങളും ചില അഗ്രഗേറ്റുകളിലേക്ക് മാറ്റുന്നു. നിങ്ങൾ എല്ലാം അപ്‌ഡേറ്റ് ചെയ്യേണ്ടതുണ്ട് (ഉദാഹരണത്തിന്, ഒരു പുതിയ ഫീൽഡ് ആരംഭിക്കുക) ഈ അഗ്രഗേറ്റുകളെ ബാധിക്കാതിരിക്കാൻ വളരെ ശ്രദ്ധാപൂർവ്വം.

നമുക്ക് ട്രിഗറുകൾ പ്രവർത്തനരഹിതമാക്കാം!

BEGIN;
  ALTER TABLE ... DISABLE TRIGGER ...;
  UPDATE ...; -- тут долго-долго
  ALTER TABLE ... ENABLE TRIGGER ...;
COMMIT;

യഥാർത്ഥത്തിൽ, അത്രമാത്രം - എല്ലാം തൂങ്ങിക്കിടക്കുന്നു.

കാരണം ALTER TABLE ചുമത്തുന്നു എക്സ്ക്ലൂസീവ് ആക്സസ്- ആരും സമാന്തരമായി പ്രവർത്തിക്കാത്ത ഒരു ലോക്ക്, ലളിതമായ ഒന്ന് പോലും SELECT, മേശയിൽ നിന്ന് ഒന്നും വായിക്കാൻ കഴിയില്ല. അതായത്, ഈ ഇടപാട് അവസാനിക്കുന്നതുവരെ, "വെറുതെ വായിക്കാൻ" പോലും ആഗ്രഹിക്കുന്ന എല്ലാവരും കാത്തിരിക്കും. ഞങ്ങൾ അത് ഓർക്കുകയും ചെയ്യുന്നു UPDATE ഞങ്ങൾക്ക് ഒരു നീണ്ട...

നമുക്ക് അത് പെട്ടെന്ന് ഓഫാക്കാം, എന്നിട്ട് പെട്ടെന്ന് ഓണാക്കുക!

BEGIN;
  ALTER TABLE ... DISABLE TRIGGER ...;
COMMIT;

UPDATE ...;

BEGIN;
  ALTER TABLE ... ENABLE TRIGGER ...;
COMMIT;

ഇവിടെ സ്ഥിതി ഇതിനകം മികച്ചതാണ്, കാത്തിരിപ്പ് സമയം വളരെ കുറവാണ്. എന്നാൽ രണ്ട് പ്രശ്നങ്ങൾ മാത്രമാണ് എല്ലാ സൗന്ദര്യത്തെയും നശിപ്പിക്കുന്നത്:

• ALTER TABLE ദൈർഘ്യമേറിയവ ഉൾപ്പെടെ മേശയിലെ മറ്റെല്ലാ പ്രവർത്തനങ്ങൾക്കുമായി സ്വയം കാത്തിരിക്കുന്നു SELECT
• ട്രിഗർ ഓഫായിരിക്കുമ്പോൾ ഏത് മാറ്റവും "ഫ്ലൈ ബൈ" മേശയിൽ, നമ്മുടേത് പോലുമില്ല. അത് അഗ്രഗേറ്റുകളിലേക്ക് കടക്കില്ല, അത് വേണമെങ്കിലും. കുഴപ്പം!

സെഷൻ വേരിയബിളുകൾ കൈകാര്യം ചെയ്യുന്നു

അതിനാൽ, മുമ്പത്തെ പതിപ്പിൽ, ഞങ്ങൾ ഒരു അടിസ്ഥാന പോയിന്റിൽ ഇടറി - പട്ടികയിലെ “നമ്മുടെ” മാറ്റങ്ങളെ “നമ്മുടേതല്ല” എന്നതിൽ നിന്ന് വേർതിരിച്ചറിയാൻ ഞങ്ങൾ എങ്ങനെയെങ്കിലും ട്രിഗറിനെ പഠിപ്പിക്കേണ്ടതുണ്ട്. “നമ്മുടേത്” അതേപടി ഒഴിവാക്കിയിരിക്കുന്നു, എന്നാൽ “നമ്മുടേതല്ല” എന്നതിൽ അവ ട്രിഗർ ചെയ്യപ്പെടുന്നു. ഇതിനായി നിങ്ങൾക്ക് ഉപയോഗിക്കാം സെഷൻ വേരിയബിളുകൾ.

സെഷൻ_റെപ്ലിക്കേഷൻ_റോൾ

വായിക്കുക മാനുവൽ:

കോൺഫിഗറേഷൻ വേരിയബിളും ട്രിഗർ മെക്കാനിസത്തെ ബാധിക്കുന്നു സെഷൻ_റെപ്ലിക്കേഷൻ_റോൾ. അധിക നിർദ്ദേശങ്ങളില്ലാതെ (സ്ഥിരസ്ഥിതി) പ്രവർത്തനക്ഷമമാക്കിയാൽ, റെപ്ലിക്കേഷൻ റോൾ "ഒറിജിൻ" (ഡിഫോൾട്ട്) അല്ലെങ്കിൽ "ലോക്കൽ" ആയിരിക്കുമ്പോൾ ട്രിഗറുകൾ പ്രവർത്തിക്കും. വ്യക്തമാക്കിയുകൊണ്ട് ട്രിഗറുകൾ പ്രവർത്തനക്ഷമമാക്കി ENABLE REPLICA, എങ്കിൽ മാത്രമേ പ്രവർത്തിക്കൂ നിലവിലെ സെഷൻ മോഡ് - "replica", കൂടാതെ ട്രിഗറുകൾ വ്യക്തമാക്കുന്നതിലൂടെ പ്രവർത്തനക്ഷമമാക്കി ENABLE ALWAYS, നിലവിലെ റെപ്ലിക്കേഷൻ മോഡ് പരിഗണിക്കാതെ തന്നെ പ്രവർത്തിക്കും.

എല്ലാത്തിനും ഒരേസമയം ക്രമീകരണം ബാധകമല്ലെന്ന് ഞാൻ പ്രത്യേകം ഊന്നിപ്പറയുന്നു ALTER TABLE, എന്നാൽ ഞങ്ങളുടെ പ്രത്യേക പ്രത്യേക കണക്ഷനിലേക്ക് മാത്രം. മൊത്തത്തിൽ, ഒരു ആപ്ലിക്കേഷനും ട്രിഗറുകൾ പ്രവർത്തിക്കാതിരിക്കാൻ:

SET session_replication_role = replica; -- выключили триггеры
UPDATE ...;
SET session_replication_role = DEFAULT; -- вернули в исходное состояние

ട്രിഗറിനുള്ളിലെ അവസ്ഥ

എന്നാൽ മുകളിലുള്ള ഓപ്ഷൻ എല്ലാ ട്രിഗറുകൾക്കും ഒരേസമയം പ്രവർത്തിക്കുന്നു (അല്ലെങ്കിൽ നിങ്ങൾ അപ്രാപ്തമാക്കാൻ ആഗ്രഹിക്കാത്ത ട്രിഗറുകൾ മുൻകൂട്ടി "ഇതര" ട്രിഗറുകൾ ഉപയോഗിക്കേണ്ടതുണ്ട്). പിന്നെ നമുക്ക് വേണമെങ്കിൽ ഒരു നിർദ്ദിഷ്ട ട്രിഗർ "ഓഫാക്കുക"?

ഇത് നമ്മെ സഹായിക്കും "ഉപയോക്തൃ" സെഷൻ വേരിയബിൾ:

വിപുലീകരണ പാരാമീറ്റർ പേരുകൾ ഇനിപ്പറയുന്ന രീതിയിൽ എഴുതിയിരിക്കുന്നു: വിപുലീകരണ നാമത്തിന് ശേഷം ഒരു ഡോട്ടും തുടർന്ന് പാരാമീറ്റർ നാമവും, SQL-ലെ പൂർണ്ണ ഒബ്ജക്റ്റ് നാമങ്ങൾക്ക് സമാനമാണ്. ഉദാഹരണത്തിന്: plpgsql.variable_conflict.
ഉചിതമായ എക്സ്റ്റൻഷൻ മൊഡ്യൂൾ ലോഡുചെയ്യാത്ത പ്രക്രിയകളിൽ സിസ്റ്റത്തിന് പുറത്തുള്ള ഓപ്ഷനുകൾ സജ്ജമാക്കാൻ കഴിയുമെന്നതിനാൽ, PostgreSQL സ്വീകരിക്കുന്നു രണ്ട് ഘടകങ്ങളുള്ള ഏതെങ്കിലും പേരുകൾക്കുള്ള മൂല്യങ്ങൾ.

ആദ്യം, ഞങ്ങൾ ട്രിഗർ അന്തിമമാക്കുന്നു, ഇതുപോലുള്ള ഒന്ന്:

BEGIN
    -- процессу конвертации можно делать все
    IF current_setting('mycfg.my_table_convert_process') = 'TRUE' THEN
        IF TG_OP IN ('INSERT', 'UPDATE') THEN
            RETURN NEW;
        ELSE
            RETURN OLD;
        END IF;
    END IF;
...

വഴിയിൽ, ഇത് തടയാതെ, "ലാഭത്തിനായി" ചെയ്യാൻ കഴിയും CREATE OR REPLACE ട്രിഗർ പ്രവർത്തനത്തിനായി. തുടർന്ന് പ്രത്യേക കണക്ഷനിൽ ഞങ്ങൾ "നമ്മുടെ" വേരിയബിൾ കോക്ക് ചെയ്യുന്നു:

SET mycfg.my_table_convert_process = 'TRUE';
UPDATE ...;
SET mycfg.my_table_convert_process = ''; -- вернули в исходное состояние

നിങ്ങൾക്ക് മറ്റ് വഴികൾ അറിയാമോ? അഭിപ്രായങ്ങളിൽ പങ്കിടുക.

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