പട്ടികയിലെ ഡാറ്റ (DML) മാറ്റങ്ങളുമായി ബന്ധപ്പെട്ടിരിക്കുമ്പോൾ സെർവർ സ്വയമേവ നടപ്പിലാക്കുന്ന ഒരു പ്രത്യേക തരം സംഭരിച്ച നടപടിക്രമങ്ങളാണ് sql ട്രിഗറുകൾ. ട്രിഗറുകൾ ഒരു നിർദ്ദിഷ്‌ട പട്ടികയിലേക്ക് ബന്ധിപ്പിക്കുന്നു. ഒരു ട്രിഗർ വരുത്തിയ എല്ലാ ഡാറ്റ മാറ്റങ്ങളും ഒരു ഇടപാടായി കണക്കാക്കുന്നു.

ഒരു സാധാരണ സംഭരിച്ച നടപടിക്രമം/പ്രവർത്തനത്തിൽ നിന്ന് വ്യത്യസ്തമായി, ഒരു നിർദ്ദിഷ്ട ട്രിഗർ ഇവൻ്റ് സംഭവിക്കുമ്പോൾ സെർവർ ഒരു ട്രിഗറിനെ പരോക്ഷമായി വിളിക്കുന്നു. കൂടാതെ, SQL ട്രിഗറിന് ആർഗ്യുമെൻ്റുകളൊന്നുമില്ല. ഇനിപ്പറയുന്ന ജോലികൾ ഒരു ട്രിഗർ ഉപയോഗിച്ച് പരിഹരിക്കുന്നു:

• മാറ്റപ്പെടുന്ന ഡാറ്റയുടെ കൃത്യത പരിശോധിക്കുകയും പരിപാലിക്കേണ്ട സങ്കീർണ്ണമായ ഡാറ്റാ സമഗ്രത നിയന്ത്രണങ്ങൾ പരിശോധിക്കുകയും ചെയ്യുക;
• ശേഖരണം സ്ഥിതിവിവരക്കണക്ക് വിവരങ്ങൾവരുത്തിയ മാറ്റങ്ങളെക്കുറിച്ചുള്ള വിവരങ്ങൾ രേഖപ്പെടുത്തുന്നതിലൂടെ;
• അനുകരണ പിന്തുണ.

സമഗ്രത നിയന്ത്രണങ്ങൾ ഉപയോഗിച്ച്, നിയമങ്ങളും മൂല്യങ്ങളും സജ്ജമാക്കുക, ഡാറ്റ സമഗ്രതയുടെ ആവശ്യമുള്ള ലെവൽ നേടാൻ എല്ലായ്പ്പോഴും സാധ്യമല്ല. ചിലപ്പോൾ നിങ്ങൾ നടപ്പിലാക്കേണ്ടതുണ്ട് സങ്കീർണ്ണമായ അൽഗോരിതങ്ങൾഡാറ്റയുടെ വിശ്വാസ്യതയും യാഥാർത്ഥ്യവും ഉറപ്പാക്കാൻ പരിശോധിക്കുന്നു. കൂടാതെ, പട്ടിക മൂല്യങ്ങളിലെ മാറ്റങ്ങൾ നിരീക്ഷിക്കേണ്ടത് പലപ്പോഴും ആവശ്യമാണ്, അതുവഴി ബന്ധപ്പെട്ട ഡാറ്റ ആവശ്യാനുസരണം പരിഷ്കരിക്കാനാകും. SQL ട്രിഗറുകൾനിയമങ്ങൾ, സ്റ്റാൻഡേർഡ് മൂല്യങ്ങൾ മുതലായവയ്ക്ക് അനുസൃതമായി എല്ലാ പ്രവർത്തനങ്ങളും പൂർത്തിയാക്കിയ ശേഷം പ്രാബല്യത്തിൽ വരുന്ന ഒരു തരം ഫിൽട്ടറുകളായി കണക്കാക്കാം.

അപേക്ഷ SQL ട്രിഗറുകൾപ്രവർത്തനങ്ങൾ ചേർക്കുന്നതിനുള്ള അധിക സെർവർ റിസോഴ്സ് ചെലവുകളുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു ( ട്രിഗർ ഉൾപ്പെടുത്തൽ), അപ്ഡേറ്റുകൾ ( ട്രിഗർ അപ്ഡേറ്റ്) അല്ലെങ്കിൽ ഇല്ലാതാക്കൽ ( ട്രിഗർ ഇല്ലാതാക്കുക) പട്ടികയിലെ ഡാറ്റ.

സംഭരിച്ച നടപടിക്രമങ്ങൾ അല്ലെങ്കിൽ ആപ്ലിക്കേഷൻ പ്രോഗ്രാമുകൾ ഉപയോഗിച്ച് സമാന ഫലങ്ങൾ നേടാനാകുമ്പോൾ, ട്രിഗറുകൾ ഉപയോഗിക്കുന്നത് പ്രായോഗികമല്ല.

ട്രിഗർ സൃഷ്‌ടിക്കുക

CREATE TRIGGER കമാൻഡിൻ്റെ അടിസ്ഥാന ഫോർമാറ്റ് ചുവടെ കാണിച്ചിരിക്കുന്നു:

ട്രിഗർ ട്രിഗർ_നാമം സൃഷ്ടിക്കുക [ മുമ്പ് | ശേഷം ] പട്ടിക_നാമം ആരംഭിക്കുന്നു അവസാനിക്കുന്നു;

ട്രിഗർ ആരംഭിക്കുന്ന നിമിഷം കീവേഡുകളാൽ നിർണ്ണയിക്കപ്പെടുന്നു മുമ്പ്(അതുമായി ബന്ധപ്പെട്ട ഇവൻ്റ് എക്സിക്യൂട്ട് ചെയ്യുന്നതിനുമുമ്പ് ട്രിഗർ ഫയർ ചെയ്യുന്നു; ഉദാഹരണത്തിന്, ഒരു റെക്കോർഡ് ചേർക്കുന്നതിന് മുമ്പ്) അല്ലെങ്കിൽ ശേഷം(സംഭവത്തിന് ശേഷം). ഒരു ഇവൻ്റിന് മുമ്പ് ഒരു ട്രിഗർ വിളിക്കുകയാണെങ്കിൽ, ഇവൻ്റ് ഒരു റെക്കോർഡ് ഇല്ലാതാക്കിയില്ലെങ്കിൽ, ഇവൻ്റ് പരിഷ്കരിച്ച റെക്കോർഡിൽ അതിന് മാറ്റങ്ങൾ വരുത്താനാകും. ചില DBMS-കൾ ഒരു ട്രിഗറിൽ ഉപയോഗിക്കാനാകുന്ന പ്രസ്താവനകളിൽ നിയന്ത്രണങ്ങൾ ഏർപ്പെടുത്തുന്നു (ഉദാഹരണത്തിന്, ട്രിഗർ "ബന്ധപ്പെട്ടിരിക്കുന്ന" പട്ടികയിൽ മാറ്റങ്ങൾ വരുത്തുന്നത് നിരോധിച്ചേക്കാം).

ട്രിഗറുകൾ ഒരു ടേബിളിലേക്കല്ല, ഒരു കാഴ്ചയിലേക്ക് ബന്ധിപ്പിക്കാൻ കഴിയും കാണുക. ഈ സാഹചര്യത്തിൽ, അവരുടെ സഹായത്തോടെ, "അപ്ഡേറ്റ് ചെയ്യാവുന്ന കാഴ്ച" സംവിധാനം നടപ്പിലാക്കുന്നു. ഒരു കാഴ്ചയിലേക്ക് ഒരു ട്രിഗർ അറ്റാച്ചുചെയ്യുമ്പോൾ കീവേഡുകൾ മുമ്പ്ഒപ്പം ശേഷംയഥാർത്ഥ ഇവൻ്റ് (ഇല്ലാതാക്കൽ, ഉൾപ്പെടുത്തൽ അല്ലെങ്കിൽ അപ്ഡേറ്റ്) സംഭവിക്കാത്തതിനാൽ, ട്രിഗർ കോളുകളുടെ ക്രമത്തെ മാത്രമേ ബാധിക്കുകയുള്ളൂ.

ഓരോ വരിയിലും ട്രിഗർ വിളിക്കാം ( ഓരോ വരിയിലും) തന്നിരിക്കുന്ന ഒരു ഇവൻ്റ് പരിരക്ഷിക്കുന്നു, അല്ലെങ്കിൽ ഓരോ ഇവൻ്റിനും ഒരിക്കൽ മാത്രം ( ഓരോ പ്രസ്താവനയ്ക്കും).

പദവി<список_псевдонимов>പഴയതോ പുതിയതോ ആയ വരി (പഴയ / പുതിയത്) അല്ലെങ്കിൽ പഴയതോ പുതിയതോ ആയ പട്ടിക (പഴയ പട്ടിക / പുതിയ പട്ടിക) പോലുള്ള ഘടകങ്ങളെ സൂചിപ്പിക്കുന്നു. ഉൾപ്പെടുത്തൽ ഇവൻ്റുകൾക്ക് പഴയ മൂല്യങ്ങൾ ബാധകമല്ല, കൂടാതെ പുതിയവ ഇല്ലാതാക്കൽ ഇവൻ്റുകൾക്ക് ബാധകമല്ല.

ട്രിഗറുകളുടെ പ്രധാന നേട്ടം അതാണ് സ്റ്റാൻഡേർഡ് സവിശേഷതകൾഡാറ്റാബേസിൽ സേവ് ചെയ്യപ്പെടുകയും അത് അപ്ഡേറ്റ് ചെയ്യുമ്പോഴെല്ലാം അത് സജീവമാക്കുകയും ചെയ്യുന്നു. ആപ്ലിക്കേഷനുകൾ കാര്യമായി ലളിതമാക്കാൻ ഇത് അനുവദിക്കുന്നു.

തെറ്റായി എഴുതിയ ട്രിഗറുകൾ നയിച്ചേക്കാം ഗുരുതരമായ പ്രശ്നങ്ങൾതടസ്സങ്ങളുടെ രൂപവുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു. ട്രിഗറുകൾക്ക് ദീർഘകാലത്തേക്ക് ഉറവിടങ്ങൾ തടയാൻ കഴിയും, അതിനാൽ ആക്സസ് വൈരുദ്ധ്യങ്ങൾ കുറയ്ക്കുന്നതിന് പ്രത്യേക ശ്രദ്ധ നൽകണം.

MS SQL ട്രിഗർ

MS SQL DBMS-ൽ ഒരു ട്രിഗർ സൃഷ്ടിക്കുന്നതിനുള്ള വാക്യഘടന ഇപ്രകാരമാണ്:

ട്രിഗർ ട്രിഗർ_നാമം ഓൺ (എൻക്രിപ്ഷൻ ഉപയോഗിച്ച്) [ [,] [,] ] [ അനുബന്ധമായി ] [ ആവർത്തനത്തിന് വേണ്ടിയല്ല ] ( sql_statement )

സ്കീമ_നാമം

DML ട്രിഗർ സർക്യൂട്ടിൻ്റെ പേര്. DML ട്രിഗറുകൾ സൃഷ്ടിക്കപ്പെട്ട പട്ടികയുടെ അല്ലെങ്കിൽ കാഴ്ചയുടെ സ്കീമ സ്കോപ്പിലേക്ക് പരിമിതപ്പെടുത്തിയിരിക്കുന്നു. DDL ട്രിഗറുകൾക്കോ ​​ലോഗിൻ ട്രിഗറുകൾക്കോ ​​വേണ്ടി schema_name വ്യക്തമാക്കാൻ കഴിയില്ല.

trigger_name

ട്രിഗർ പേര്. ട്രിഗർ_നെയിം ആർഗ്യുമെൻ്റ് ഐഡൻ്റിഫയറുകൾക്കുള്ള നിയമങ്ങൾ പാലിക്കണം - ട്രിഗർ_നാമം # അല്ലെങ്കിൽ ## പ്രതീകങ്ങളിൽ ആരംഭിക്കാൻ കഴിയില്ല എന്നതൊഴിച്ചാൽ.

പട്ടിക_പേര് | കാഴ്ച_പേര്

ട്രിഗർ ഘടിപ്പിച്ചിരിക്കുന്ന പട്ടിക അല്ലെങ്കിൽ കാഴ്ച.

ms sql ട്രിഗർ ഉദാഹരണം

ട്രിഗർ നടപ്പിലാക്കാൻ, രണ്ട് പട്ടികകൾ സൃഷ്ടിക്കും: test_table, test_log. ടെസ്റ്റ്_ടേബിൾ പട്ടികയിലേക്ക് ഒരു ട്രിഗർ ബന്ധിപ്പിക്കും. test_table പട്ടികയിൽ റെക്കോർഡുകൾ അപ്ഡേറ്റ് ചെയ്യുമ്പോൾ, test_log പട്ടികയിലെ മാറ്റങ്ങളുടെ ഫലങ്ങൾ ട്രിഗർ ലോഗ് ചെയ്യും. ആ. അപ്‌ഡേറ്റ് ഇവൻ്റിൽ ട്രിഗർ വിളിക്കും.

ടെസ്റ്റ് ടേബിൾ test_table:

പട്ടിക dbo.test_table സൃഷ്‌ടിക്കുക (id int null അല്ല, ഫീൽഡ്1 varchar(255) null, field2 varchar(255) null, constraint pkTestTableID പ്രാഥമിക കീ(ഐഡി));

ടെസ്റ്റ്_ലോഗ് ലോഗിംഗ് ടേബിൾ:

പട്ടിക dbo.test_log സൃഷ്‌ടിക്കുക (ഐഡി ബിജിൻ്റ് ഐഡൻ്റിറ്റി(1,1) അസാധുവല്ല, ടേബിൾ_നെയിം വാർചാർ(50) അസാധുവല്ല, ഓപ്പർ വാർചാർ(15) അസാധുവല്ല, റെക്കോർഡ്_ഓൾഡ് xml നൾ, റെക്കോർഡ്_ന്യൂ xml null, ഡാറ്റാ ഡേറ്റ്ടൈം null, കൺസ്ട്രൈൻ്റ് പ്രൈമറി കീടെസ്റ്റ്‌ലോഗ് (pkTestLog ഐഡി));

ഡാറ്റ അപ്ഡേറ്റ് ട്രിഗർ:

ട്രിഗ്ഗർ അപ്‌ഡേറ്റ് ട്രിഗർ dbo.trg_test_table_update സൃഷ്‌ടിക്കുക, അപ്‌ഡേറ്റിനായി dbo.test_table-ൽ അപ്‌ഡേറ്റ് ആരംഭിക്കുക -- പഴയതും പുതിയതുമായ ഡാറ്റ സംഭരിക്കുന്നതിനുള്ള വേരിയബിളുകൾ @record_new xml; @record_old xml പ്രഖ്യാപിക്കുക; -- പട്ടിക ഇല്ലാതാക്കിയ പഴയ/ഇല്ലാതാക്കിയ ഡാറ്റ സംഭരിക്കുന്നു @record_old = (XML RAW, TYPE എന്നിവയ്‌ക്കായി ഇല്ലാതാക്കിയതിൽ നിന്ന് * തിരഞ്ഞെടുക്കുക); -- ചേർത്ത പട്ടിക മാറ്റിയ (ഇപ്പോൾ സൃഷ്‌ടിച്ച) ഡാറ്റ സെറ്റ് സംഭരിക്കുന്നു @record_new = (XML RAW, TYPE-നായി ചേർത്തതിൽ നിന്ന് * തിരഞ്ഞെടുക്കുക); (@record_new അസാധുവല്ല) കൂടാതെ (@record_old അസാധുവല്ല) dbo.test_log (table_name, oper, record_old, record_new, ഡാറ്റ) മൂല്യങ്ങൾ ("test_table", "update", @record_old, @record_new എന്നിവയിൽ ചേർക്കാൻ തുടങ്ങിയാൽ , GETDATE ())അവസാനം; അവസാനിക്കുന്നു;

ടെസ്റ്റ് ടേബിളിലേക്ക് കുറച്ച് വരികൾ ചേർക്കാം, അത് ട്രിഗർ പരീക്ഷിക്കുന്നതിന് ഞങ്ങൾ അപ്ഡേറ്റ് ചെയ്യും:

dbo.test_table (ഐഡി, ഫീൽഡ്1, ഫീൽഡ്2) മൂല്യങ്ങളിലേക്ക് തിരുകുക (1, "കോഫി", "നെസ്‌കഫെ"); dbo.test_table (ഐഡി, ഫീൽഡ്1, ഫീൽഡ്2) മൂല്യങ്ങളിൽ ചേർക്കുക (2, "ടീ" , "ഗ്രീൻഫീൽഡ്");

വരികൾ അപ്ഡേറ്റ് ചെയ്തുകൊണ്ട് ഞങ്ങൾ ട്രിഗറിൻ്റെ പ്രവർത്തനം പരിശോധിക്കുന്നു:

ലോഗിംഗ് ടേബിൾ test_log പരിശോധിക്കുക. ഫലം സ്ക്രീൻഷോട്ടിൽ കാണിച്ചിരിക്കുന്നതുപോലെ ആയിരിക്കണം:

XML ഡാറ്റ പരിശോധിച്ച് ലോഗിംഗ് ടേബിളിൽ പഴയതും പുതിയതുമായ മൂല്യങ്ങൾ ഉൾപ്പെടുന്നുവെന്ന് കാണിക്കുന്നു.

PostgreSQL ട്രിഗർ

ഒരു ട്രിഗർ സൃഷ്ടിക്കുന്നതിനുള്ള വാക്യഘടന

ഓരോന്നിനും പട്ടിക_നാമത്തിൽ ട്രിഗ്ഗർ ട്രിഗ്ഗർ_നാമം [ ഇവൻ്റ് [ അല്ലെങ്കിൽ ഇവൻ്റ് ]] സൃഷ്‌ടിക്കൂ

സൃഷ്ടിക്കേണ്ട ട്രിഗറിൻ്റെ പേര് ആർഗ്യുമെൻ്റ് വ്യക്തമാക്കുന്നു. ആവശ്യമെങ്കിൽ, പദ്ധതിയുടെ പേര് സൂചിപ്പിക്കാം.

(മുമ്പ് | ശേഷം)

BEFORE കീവേഡ് അർത്ഥമാക്കുന്നത് മുമ്പ് ട്രിഗർ ചെയ്യുകബന്ധപ്പെട്ട ഇവൻ്റ് എക്സിക്യൂട്ട് ചെയ്യുന്നതിനുമുമ്പ് ഫംഗ്ഷൻ എക്സിക്യൂട്ട് ചെയ്യണം. AFTER കീവേഡ് എന്നാണ് അർത്ഥമാക്കുന്നത് ശേഷം ട്രിഗർട്രിഗർ ജ്വലിക്കുന്ന പ്രവർത്തനം പൂർത്തിയായതിന് ശേഷമാണ് ഫംഗ്‌ഷനെ വിളിക്കുന്നത്.

( ഇവൻ്റ് [ അല്ലെങ്കിൽ ഇവൻ്റ്... ] )

PostgreSQL-ൽ ഇനിപ്പറയുന്ന ഇവൻ്റുകൾ പിന്തുണയ്ക്കുന്നു. ഒന്നിലധികം ഇവൻ്റുകൾ ലിസ്റ്റ് ചെയ്യുമ്പോൾ, OR കീവേഡ് ഒരു സെപ്പറേറ്ററായി ഉപയോഗിക്കുന്നു.

മാറ്റം വരുത്തിയ പട്ടികയുടെ പേര് ട്രിഗർ തീപിടിക്കാൻ കാരണമാകുന്നു.

ഓരോന്നിനും (വരി | പ്രസ്താവന)

നിർമ്മാണത്തിന് താഴെയുള്ള കീവേഡ് ഓരോന്നിനുംകൂടാതെ നിർദ്ദിഷ്ട ഇവൻ്റ് സംഭവിക്കുമ്പോൾ ഫംഗ്ഷൻ കോളുകളുടെ എണ്ണം നിർവചിക്കുന്നു. ROW ഉപയോഗിക്കുന്നത് അർത്ഥമാക്കുന്നത് പരിഷ്കരിച്ച ഓരോ റെക്കോർഡിനും ഫംഗ്ഷൻ വിളിക്കപ്പെടുന്നു എന്നാണ്. മുഴുവൻ കമാൻഡിനും ഒരു ഫംഗ്‌ഷൻ ഒരിക്കൽ മാത്രമേ വിളിക്കാവൂ എങ്കിൽ, STATEMENT കീവേഡ് ഉപയോഗിക്കും.

നടപടിക്രമം നടപ്പിലാക്കുക function_name

ആർഗ്യുമെൻ്റുകളുള്ള വിളിക്കപ്പെടുന്ന ഫംഗ്‌ഷൻ്റെ പേര്. പ്രായോഗികമായി, ട്രിഗർ ഫംഗ്‌ഷനുകൾ വിളിക്കുമ്പോൾ ആർഗ്യുമെൻ്റുകൾ ഉപയോഗിക്കില്ല.

ട്രിഗർ ഫംഗ്ഷൻ ഡെഫനിഷൻ സിൻ്റാക്സ്

ഫങ്ഷൻ ഫംഗ്‌ഷൻ_നാമം സൃഷ്‌ടിക്കുക () പ്രഖ്യാപിക്കുന്നതുപോലെ റിട്ടേൺസ് ട്രിഗർ -- വേരിയബിൾ ഡിക്ലറേഷനുകൾ BEGIN -- ട്രിഗർ ഫംഗ്‌ഷൻ ബോഡി END; ഭാഷ plpgsql;

ട്രിഗർ ഫംഗ്‌ഷനുകൾ ഫയർ ചെയ്‌ത ട്രിഗറിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ അടങ്ങിയ പ്രത്യേക വേരിയബിളുകൾ ഉപയോഗിക്കുന്നു. ഈ വേരിയബിളുകൾ ഉപയോഗിച്ച് ട്രിഗർ പ്രവർത്തനംഡാറ്റയുമായി പ്രവർത്തിക്കുന്നു. ട്രിഗർ ഫംഗ്‌ഷനുകളിൽ ലഭ്യമായ ചില വേരിയബിളുകൾ ചുവടെ പട്ടികപ്പെടുത്തിയിരിക്കുന്നു.

പേര്	ടൈപ്പ് ചെയ്യുക	വിവരണം
പുതിയത്	രേഖപ്പെടുത്തുക	ഒരു റെക്കോർഡ് ലെവൽ (ROW) ട്രിഗർ ചെയ്യുമ്പോൾ ഒരു INSERT കമാൻഡ് അല്ലെങ്കിൽ അപ്‌ഡേറ്റ് ചെയ്‌ത UPDATE കമാൻഡ് സൃഷ്‌ടിച്ച റെക്കോർഡിൻ്റെ പുതിയ ഫീൽഡ് മൂല്യങ്ങൾ. പുതിയ റെക്കോർഡുകൾ പരിഷ്കരിക്കാൻ വേരിയബിൾ ഉപയോഗിക്കുന്നു. പുതിയ വേരിയബിൾ INSERT ചെയ്യുമ്പോഴും അപ്‌ഡേറ്റ് ചെയ്യുമ്പോഴും മാത്രമേ ലഭ്യമാകൂ. ഒരു പുതിയ റെക്കോർഡിൻ്റെ ഫീൽഡുകൾ ഒരു ട്രിഗർ ഉപയോഗിച്ച് പരിഷ്‌ക്കരിക്കാനാകും.
പഴയത്	രേഖപ്പെടുത്തുക	DELETE അല്ലെങ്കിൽ UPDATE കമാൻഡിന് മുമ്പുള്ള റെക്കോർഡിൽ അടങ്ങിയിരിക്കുന്ന പഴയ റെക്കോർഡ് ഫീൽഡ് മൂല്യങ്ങൾ റെക്കോർഡ്-ലെവൽ (ROW) ട്രിഗർ ഫയർ ചെയ്യുമ്പോൾ എക്സിക്യൂട്ട് ചെയ്തു. പഴയ വേരിയബിൾ ഇല്ലാതാക്കുന്നതിനും അപ്ഡേറ്റ് ചെയ്യുന്നതിനും മാത്രമേ ലഭ്യമാകൂ. പഴയ റെക്കോർഡ് ഫീൽഡുകൾ വായിക്കാൻ മാത്രമുള്ളതാണ്, അവ പരിഷ്‌ക്കരിക്കാനാവില്ല.
TG_NAME	പേര്	വെടിയുതിർത്ത ട്രിഗറിൻ്റെ പേര്.
TG_WHEN	വാചകം	നിർവചനത്തിൽ വ്യക്തമാക്കിയിരിക്കുന്ന ട്രിഗർ എപ്പോൾ പ്രവർത്തിക്കുന്നു എന്നതിനെ ആശ്രയിച്ച് പ്രസ്താവനകൾക്ക് മുമ്പോ ശേഷമോ.
TG_LEVEL	വാചകം	നിർവചനത്തിൽ വ്യക്തമാക്കിയ ട്രിഗർ ലെവലിനെ ആശ്രയിച്ച് ഒരു ROW അല്ലെങ്കിൽ STATEMENT സ്ട്രിംഗ്.
TG_OP	വാചകം	ട്രിഗർ തീപിടിക്കാൻ കാരണമായ പ്രവർത്തനത്തെ ആശ്രയിച്ച് ഒരു ഇൻസേർട്ട്, അപ്ഡേറ്റ് അല്ലെങ്കിൽ ഡിലീറ്റ് സ്ട്രിംഗ്.
TG_RELID	oid	ട്രിഗർ വെടിയുതിർത്ത പട്ടികയുടെ ഒബ്ജക്റ്റ് ഐഡൻ്റിഫയർ.
TG_RELNAME	പേര്	ട്രിഗർ വെടിയുതിർത്ത പട്ടികയുടെ പേര്.

ഒരു റെക്കോർഡിൻ്റെ വ്യക്തിഗത ഫീൽഡുകളിലേക്ക് പുതിയത്ഒപ്പം പഴയത്ട്രിഗർ നടപടിക്രമങ്ങളിൽ അവയെ ഇനിപ്പറയുന്ന രീതിയിൽ അഭിസംബോധന ചെയ്യുന്നു: NEW.names, OLD.rg.

Postgresql ട്രിഗർ ഉദാഹരണം

ഉദാഹരണത്തിൽ നടപ്പിലാക്കിയത് ലളിതമായ സിസ്റ്റംഉപയോക്തൃ ലോഗിംഗ്. ഇത് ഉപയോക്തൃ പട്ടിക നിരീക്ഷിക്കുകയും ലോഗിംഗ് ടേബിളിലെ എല്ലാ മാറ്റങ്ങളും രേഖപ്പെടുത്തുകയും ചെയ്യുന്നു. ഉദാഹരണത്തിന്, ഞങ്ങൾ ലളിതമായ പട്ടികകൾ സൃഷ്ടിക്കും.

ഉപയോക്തൃ പട്ടിക:

"പബ്ലിക്" എന്ന പട്ടിക സൃഷ്ടിക്കുക.ഉപയോക്താക്കൾ (id int അസാധുവല്ല, പേര് varchar (64), constraint pkUsersID പ്രാഥമിക കീ (ഐഡി));

ലോഗിംഗ് ടേബിൾ

പട്ടിക "പൊതു".ലോഗുകൾ സൃഷ്ടിക്കുക (ടെക്സ്റ്റ് varchar(256), സമയ മേഖലയില്ലാത്ത ഡാറ്റ ടൈംസ്റ്റാമ്പ്);

ട്രിഗർ പ്രവർത്തനം

"public" എന്ന പ്രവർത്തനം സൃഷ്‌ടിക്കുക അല്ലെങ്കിൽ മാറ്റിസ്ഥാപിക്കുക. v_user varchar(64); v_retstr varchar(256); BEGIN IF TG_OP = "ഇൻസേർട്ട്" തുടർന്ന് v_user = NEW.name; v_action:= "പുതിയ ഉപയോക്താവിനെ ചേർക്കുക"; v_retstr:= v_action || v_user; "പൊതുവായ".ലോഗുകളിൽ (ടെക്സ്റ്റ്, ഡാറ്റ) മൂല്യങ്ങൾ (v_retstr, NOW()) ചേർക്കുക; പുതിയതായി മടങ്ങുക; ELSIF TG_OP = "അപ്ഡേറ്റ്" തുടർന്ന് v_user = NEW.name; v_action:= "ഉപയോക്താവിനെ അപ്ഡേറ്റ് ചെയ്യുക"; v_retstr:= v_action || v_user; "പൊതുവായ".ലോഗുകളിൽ (ടെക്സ്റ്റ്, ഡാറ്റ) മൂല്യങ്ങൾ (v_retstr, NOW()) ചേർക്കുക; പുതിയതായി മടങ്ങുക; ELSIF TG_OP = "ഇല്ലാതാക്കുക" തുടർന്ന് v_user = OLD.name; v_action:= "ഉപയോക്താവിനെ നീക്കം ചെയ്യുക"; v_retstr:= v_action || v_user; "പൊതുവായ".ലോഗുകളിൽ (ടെക്സ്റ്റ്, ഡാറ്റ) മൂല്യങ്ങൾ (v_retstr, NOW()) ചേർക്കുക; പഴയതിലേക്ക് മടങ്ങുക; ENDIF; അവസാനിക്കുന്നു; $$ ഭാഷ plpgsql;

ഇൻപുട്ട് പാരാമീറ്ററുകളില്ലാത്ത ട്രിഗർ ഫംഗ്‌ഷൻ ഒരു പ്രത്യേക തരം നൽകുന്നു ട്രിഗർ. വിഭാഗത്തിലെ ചടങ്ങിൽ പ്രഖ്യാപിക്കുക 3 വേരിയബിളുകൾ നിർവചിച്ചിരിക്കുന്നു. ഫംഗ്ഷൻ ബോഡി വേരിയബിളിൻ്റെ മൂല്യം പരിശോധിക്കുന്നു TG_OP(ആന്തരിക ട്രിഗർ വേരിയബിൾ). ഇടപാടിനെ ആശ്രയിച്ച്, ഞങ്ങൾ v_user വേരിയബിൾ നിർവചിക്കുകയും ഒരു retstr സ്ട്രിംഗ് സൃഷ്ടിക്കുകയും ചെയ്യുന്നു, അത് ലോഗ്സ് ടേബിളിൽ എഴുതുന്നു.

വേരിയബിളുകൾ പുതിയത്ഒപ്പം പഴയത്- ഇവയാണ് ട്രിഗർ പ്രോസസ്സ് ചെയ്യുന്ന യഥാർത്ഥ വരികൾ. INSERT-ൻ്റെ കാര്യത്തിൽ, പുതിയ വേരിയബിളിൽ അടങ്ങിയിരിക്കും പുതിയ വര, പഴയത് ശൂന്യമായിരിക്കും. UPDATE-ൻ്റെ കാര്യത്തിൽ, രണ്ട് വേരിയബിളുകളും നിർവചിക്കപ്പെടും (അനുബന്ധ ഡാറ്റ പ്രകാരം), കൂടാതെ DELETE-ൻ്റെ കാര്യത്തിൽ, പുതിയ വേരിയബിൾ ശൂന്യമായിരിക്കും, OLD-ൽ ഇല്ലാതാക്കേണ്ട വരി അടങ്ങിയിരിക്കും.

ട്രിഗർ തന്നെ PL/pgSQL-ൽ ഇങ്ങനെ വിവരിച്ചിരിക്കുന്നു:

ട്രിഗർ ഇൻസേർട്ട് & ട്രിഗർ അപ്‌ഡേറ്റ് & ട്രിഗർ ഡിലീറ്റ് ചെയ്യുക "പൊതുവ" എന്നതിൽ ഉൾപ്പെടുത്തുകയോ അപ്‌ഡേറ്റ് ചെയ്യുകയോ ഇല്ലാതാക്കുകയോ ചെയ്തതിന് ശേഷം TRIGGER trg_user സൃഷ്‌ടിക്കുക. ഓരോ വരിയ്‌ക്കുമുള്ള ഉപയോക്താക്കൾ add_to_log ();

ഓരോ വരിയിലും INSERT, UPDATE, DELETE ട്രാൻസാക്ഷനുകൾ എന്നിവ നടത്തി add_to_log() ഫംഗ്‌ഷനിലേക്ക് വിളിച്ചതിന് ശേഷം trg_user ട്രിഗർ എക്‌സിക്യൂട്ട് ചെയ്യും. ഇപ്പോൾ ഉപയോക്തൃ പട്ടികയിലുള്ള ഏത് പ്രവർത്തനങ്ങളും ലോഗ് ചെയ്യപ്പെടും.

ട്രിഗറിൻ്റെ പ്രവർത്തനക്ഷമത പരിശോധിക്കാൻ ഇനിപ്പറയുന്ന സ്ക്രിപ്റ്റുകൾ നിങ്ങളെ അനുവദിക്കുന്നു:

ഉപയോക്തൃ പട്ടികയിലേക്ക് ഒരു എൻട്രി ചേർക്കുന്നത് ഉപയോക്താക്കൾക്ക് (ഐഡി, പേര്) മൂല്യങ്ങളിലേക്ക് ചേർക്കുക (1, "കിസ വോറോബിയാനിനോവ്"); -- ഉപയോക്തൃ പട്ടികയിൽ ഒരു റെക്കോർഡ് അപ്ഡേറ്റ് ചെയ്യുന്നു അപ്ഡേറ്റ് ഉപയോക്താക്കൾ പേര് = "Ostap Bender" എന്ന് സജ്ജീകരിക്കുന്നു, ഇവിടെ id = 1 -- റീഡിംഗ് ഉപയോക്താക്കൾ ഉപയോക്താക്കളിൽ നിന്ന് * തിരഞ്ഞെടുക്കുന്നു -- ലോഗിംഗ് ലോഗ് വായിക്കുന്നു. ലോഗുകളിൽ നിന്ന് * തിരഞ്ഞെടുത്ത് 2 എൻട്രികൾ ഉണ്ടായിരിക്കണം

ഒറാക്കിൾ ട്രിഗറുകൾ

Oracle-ൽ TRIGGER സൃഷ്ടിക്കുന്നതിനുള്ള വാക്യഘടന ഇപ്രകാരമാണ്:

TRIGGER ട്രിഗർ_നാമം സൃഷ്‌ടിക്കുന്നതിന് മുമ്പ് ട്രിഗർ ചെയ്യുക.<список_псевдонимов>ഓരോ വരിയിലും എപ്പോൾ (new.field_name > 0) പ്രഖ്യാപിക്കുക -- വേരിയബിളുകൾ, സ്ഥിരാങ്കങ്ങൾ, കഴ്‌സറുകൾ മുതലായവ. BEGIN -- PL/SQL ബ്ലോക്ക് END;

വാക്യത്തിലെ ഒരു ബൂളിയൻ SQL എക്സ്പ്രഷൻ നിർവചിച്ച് ട്രിഗർ സൃഷ്‌ടി ടെക്‌സ്‌റ്റിൽ ഒരു ഓപ്‌ഷണൽ ട്രിഗർ കൺസ്ട്രൈൻ്റ് ഉൾപ്പെടുത്താവുന്നതാണ്. എപ്പോൾ. ട്രിഗർ ബാധിച്ച ഓരോ വരിയിലും WHEN ക്ലോസിലെ എക്‌സ്‌പ്രഷൻ പരീക്ഷിക്കപ്പെടുന്നു. പദപ്രയോഗത്തിൻ്റെ ഫലം ശരിയാണെങ്കിൽ, ട്രിഗർ ബോഡി എക്സിക്യൂട്ട് ചെയ്യപ്പെടും. എക്സ്പ്രഷൻ FALSE അല്ലെങ്കിൽ NULL ആണെങ്കിൽ, ട്രിഗർ ബോഡി എക്സിക്യൂട്ട് ചെയ്യില്ല. WHEN ക്ലോസിലെ എക്‌സ്‌പ്രഷൻ ഒരു SQL എക്‌സ്‌പ്രഷൻ ആയിരിക്കണം, PL/SQL എക്‌സ്‌പ്രഷൻ അല്ല, സബ്‌ക്വറി ഉൾപ്പെടുത്താൻ കഴിയില്ല.

റഫറൻസ്

പട്ടികയ്ക്ക് "പഴയ" അല്ലെങ്കിൽ "പുതിയത്" എന്ന് പേരിട്ടിരിക്കുന്ന സാഹചര്യത്തിൽ പരസ്പരബന്ധമുള്ള പേരുകളും പട്ടികയുടെ പേരുകളും തമ്മിലുള്ള വൈരുദ്ധ്യങ്ങൾ ഒഴിവാക്കാൻ ട്രിഗർ ബോഡിയിൽ റഫറൻസിങ് ഓപ്ഷൻ ഉപയോഗിക്കാം. ഈ സാഹചര്യം അപൂർവ്വമാണ്, ഈ ഓപ്ഷൻ മിക്കവാറും ഉപയോഗിക്കില്ല.

ഉദാഹരണമായി, പുതിയതായി പേരിട്ടിരിക്കുന്ന ഒരു പട്ടിക പരിഗണിക്കുക. അടുത്ത നിർവചനം ട്രിഗർ സൃഷ്‌ടിക്കുകപട്ടികയുമായി ബന്ധപ്പെട്ട ട്രിഗർ കാണിക്കുന്നു പുതിയത്ഓപ്ഷൻ ഉപയോഗിക്കുന്ന റഫറൻസ്പരസ്പരബന്ധമുള്ള പേരുകളും പട്ടികയുടെ പേരും തമ്മിലുള്ള വൈരുദ്ധ്യങ്ങൾ ഒഴിവാക്കാൻ:

ഓരോ വരിയിലും ഏറ്റവും പുതിയതായി പുതിയ റഫറൻസിംഗിൽ അപ്‌ഡേറ്റ് ചെയ്യുന്നതിന് മുമ്പ് TRIGGER trg_dummy സൃഷ്‌ടിക്കുന്നതിന് മുമ്പ് ട്രിഗർ ചെയ്യുക BEGIN:newest.field2:= TO_CHAR (:newest.field1); അവസാനിക്കുന്നു;

ഓപ്പറേറ്റർ പുതിയത്ഓപ്ഷൻ ഉപയോഗിച്ച് ഏറ്റവും പുതിയതായി പുനർനാമകരണം ചെയ്തു റഫറൻസ്, തുടർന്ന് ട്രിഗർ ബോഡിയിൽ ഉപയോഗിച്ചു.

സോപാധിക പ്രവചനങ്ങൾ

ഒന്നിലധികം തരത്തിലുള്ള DML പ്രസ്താവനകൾ (ഉദാഹരണത്തിന്, "ഇൻസേർട്ട് അല്ലെങ്കിൽ ഡിലീറ്റ് അല്ലെങ്കിൽ അപ്ഡേറ്റ്") ഉപയോഗിച്ച് ഒരു ട്രിഗർ എക്സിക്യൂട്ട് ചെയ്യാൻ കഴിയുമെങ്കിൽ, ട്രിഗറിൻ്റെ ബോഡിയിൽ സ്റ്റേറ്റ്മെൻ്റുകൾ ഉപയോഗിക്കാം ചേർക്കുന്നു, ഇല്ലാതാക്കുന്നുഒപ്പം അപ്ഡേറ്റ് ചെയ്യുന്നു, വ്യവസ്ഥയെ ആശ്രയിച്ച് കോഡിൻ്റെ വിവിധ വിഭാഗങ്ങൾ എക്സിക്യൂട്ട് ചെയ്യാൻ. ട്രിഗർ ബോഡിക്കുള്ളിലെ കോഡിൽ, നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന വ്യവസ്ഥകൾ ഉപയോഗിക്കാം:

ഇൻസേർട്ട് ചെയ്യുകയാണെങ്കിൽ പിന്നെ. . . ENDIF; അപ്ഡേറ്റ് ചെയ്യുകയാണെങ്കിൽ പിന്നെ. . . ENDIF;

പട്ടികയിൽ ഒരു വരി തിരുകുമ്പോൾ ട്രിഗർ പ്രയോഗിച്ച സന്ദർഭങ്ങളിൽ ആദ്യ വ്യവസ്ഥ പാലിക്കും. ഒരു പട്ടിക വരി അപ്‌ഡേറ്റ് ചെയ്യുമ്പോൾ രണ്ടാമത്തെ വ്യവസ്ഥ പാലിക്കപ്പെടും.

ഓപ്പറേറ്ററിൽ അപ്ഡേറ്റ് ചെയ്യുന്നുഅപ്‌ഡേറ്റ് ചെയ്യുന്ന നിരയുടെ പേര് പരിശോധിക്കാൻ നിങ്ങൾക്ക് ഒരു വ്യവസ്ഥ ഉപയോഗിക്കാവുന്നതാണ്. ഒരു ഉദാഹരണമായി, ഇനിപ്പറയുന്ന കോഡ് പരിഗണിക്കുക, ട്രിഗർ ഉയർത്തിയ അപ്‌ഡേറ്റ് ക്ലോസ് SAL കോളം അപ്‌ഡേറ്റ് ചെയ്താൽ ബോഡി എക്‌സിക്യൂട്ട് ചെയ്യപ്പെടും:

അപ്‌ഡേറ്റ് ചെയ്യുകയാണെങ്കിൽ ("SAL") പിന്നെ . . . ENDIF;

Oracle ട്രിഗറുകൾ പ്രവർത്തനരഹിതമാക്കുക, പ്രവർത്തനക്ഷമമാക്കുക

IN ഒറാക്കിൾ ട്രിഗർഇനിപ്പറയുന്ന വ്യവസ്ഥകളിലൊന്ന് സംഭവിക്കുകയാണെങ്കിൽ താൽക്കാലികമായി ഓഫാക്കാനാകും:

• ട്രിഗർ പരാമർശിച്ച ഒബ്ജക്റ്റ് ആക്സസ് ചെയ്യാൻ കഴിയില്ല;
• ട്രിഗറുകൾ വിളിക്കാതെ തന്നെ ഒരു ബൾക്ക് ഡാറ്റ ലോഡ് ചെയ്യേണ്ടത് ആവശ്യമാണ്;
• ഒരു ട്രിഗർ വിളിക്കാതെ തന്നെ നിങ്ങൾ പട്ടികയിലേക്ക് ഡാറ്റ ലോഡ് ചെയ്യേണ്ടതുണ്ട്.

ഒരു ട്രിഗർ സൃഷ്‌ടിക്കുമ്പോൾ അത് ഡിഫോൾട്ടായി പ്രവർത്തനക്ഷമമാകും. ഒരു ട്രിഗർ പ്രവർത്തനരഹിതമാക്കാൻ, നിങ്ങൾ കമാൻഡ് ഉപയോഗിക്കണം ട്രിഗർ മാറ്റുകഓപ്ഷൻ കൂടെ പ്രവർത്തനരഹിതമാക്കുക. ഒരു ട്രിഗർ പ്രവർത്തനക്ഷമമാക്കാൻ, ഓപ്‌ഷനോടുകൂടിയ ALTER TRIGGER കമാൻഡ് ഉപയോഗിക്കുക പ്രവർത്തനക്ഷമമാക്കുക. കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു പട്ടികയുമായി ബന്ധപ്പെട്ട എല്ലാ ട്രിഗറുകളും ഒരേസമയം പ്രവർത്തനരഹിതമാക്കാം ആൾട്ടർ ടേബിൾഓപ്ഷൻ കൂടെ എല്ലാ ട്രിഗറുകളും പ്രവർത്തനരഹിതമാക്കുക.

ഒരു ട്രിഗർ പ്രവർത്തനരഹിതമാക്കുന്നു ALTER TRIGGER TRG_Orders_INS പ്രവർത്തനരഹിതമാക്കുന്നു; -- ട്രിഗർ ബന്ധിപ്പിക്കുന്നു ALTER TRIGGER TRG_Orders_INS പ്രവർത്തനക്ഷമമാക്കുന്നു; -- എല്ലാ ടേബിൾ ട്രിഗറുകളും പ്രവർത്തനരഹിതമാക്കുക ALTER TABLE ഓർഡറുകൾ എല്ലാ ട്രിഗറുകളും പ്രവർത്തനരഹിതമാക്കുക;

ALTER TABLE കമാൻഡ് ഉപയോഗിച്ച് ഒരു ട്രിഗർ പ്രവർത്തനക്ഷമമാക്കുന്നതിനോ പ്രവർത്തനരഹിതമാക്കുന്നതിനോ, നിങ്ങൾ പട്ടികയുടെ ഉടമയായിരിക്കണം അല്ലെങ്കിൽ ഉചിതമായ പ്രത്യേകാവകാശം ഉണ്ടായിരിക്കണം.

ഒറാക്കിൾ ട്രിഗർ ഉദാഹരണം

സീക്വൻസ് ജനറേറ്റർ സീക്വൻസ് സെക്ഐഡി സൃഷ്ടിക്കുക; -- ഉപയോക്തൃ പട്ടിക ടേബിൾ ഉപയോക്താക്കൾ സൃഷ്ടിക്കുക (ഐഡി ഇൻറ്റ് പ്രൈമറി കീ അസാധുവല്ല, പേര് varchar(50), ഫോൺ varchar(15), dt തീയതി); -- ട്രിഗർ ഇൻസേർട്ട് റെക്കോർഡ് ഐഡി വ്യക്തമാക്കുന്നു അല്ലെങ്കിൽ ഉപയോക്താക്കളിൽ ചേർക്കുന്നതിന് മുമ്പ് ട്രിഗർ trgAutonumber മാറ്റിസ്ഥാപിക്കുക -- ഓരോ വരിയ്‌ക്കും മുമ്പായി ട്രിഗർ ചെയ്യുക ആരംഭിക്കുക. അവസാനിക്കുന്നു; -- ട്രിഗർ ഇൻസേർട്ട് റെക്കോർഡിംഗ് തീയതി വ്യക്തമാക്കുന്നു ട്രിഗർ ട്രിഗർ ട്രിഗ്ഗർ സ്ഥാപിക്കുന്നതിന് മുമ്പ് ട്രിഗ്ഗർ മാറ്റിസ്ഥാപിക്കുക, ഓരോ വരിയിലും ആരംഭിക്കുന്നതിന് മുമ്പ്:old.dt ശൂന്യമാണെങ്കിൽ:new.dt:= current_date; എങ്കിൽ അവസാനിപ്പിക്കുക; END trgDate;

ഇനിപ്പറയുന്ന ഉദാഹരണത്തിൽ, trgDepartmentst_del_cascade ട്രിഗർ റെക്കോർഡുകളുടെ കാസ്കേഡ് ഇല്ലാതാക്കുന്നു ട്രിഗർ ഇല്ലാതാക്കുക കാസ്‌കേഡ്. ഡിപ്പാർട്ട്‌മെൻ്റ് ടേബിളുമായി ബന്ധിപ്പിച്ചിരിക്കുന്ന ട്രിഗർ deptID പട്ടികയുടെ പ്രാഥമിക കീയിൽ DELETE CASCADE എന്ന റഫറൻസ് പ്രവർത്തനം നടപ്പിലാക്കുന്നു:

ഓരോ വരിയിലും ഡിപ്പാർട്ട്‌മെൻ്റുകൾ ഇല്ലാതാക്കിയതിന് ശേഷം TRIGGER സൃഷ്‌ടിക്കുക അല്ലെങ്കിൽ മാറ്റിസ്ഥാപിക്കുക TRGDepartmentst_del_cascade ട്രിഗർ ചെയ്യുക. */ ജീവനക്കാരിൽ നിന്ന് ഇല്ലാതാക്കുക എവിടുന്ന് ജീവനക്കാര്.deptID = :old.deptID; അവസാനിക്കുന്നു;

ശ്രദ്ധിക്കുക: സാധാരണയായി ഇതിനുള്ള കോഡ് കാസ്‌കേഡ് ഇല്ലാതാക്കുകഅപ്‌ഡേറ്റ് സെറ്റ് നൾ അല്ലെങ്കിൽ അപ്‌ഡേറ്റ് സെറ്റ് ഡിഫോൾട്ടിനായുള്ള കോഡുമായി സംയോജിപ്പിച്ച് ഒരൊറ്റ ട്രിഗറിൽ അപ്‌ഡേറ്റുകൾക്കും ഇല്ലാതാക്കലുകൾക്കും അക്കൗണ്ടിലേക്ക്.

ജനറേറ്ററുകൾ സൃഷ്ടിക്കുന്നു

ഒരു ഡാറ്റാബേസിൽ സംഭരിച്ചിരിക്കുന്ന ഒരു പ്രോഗ്രാമാണ് ജനറേറ്റർ, അത് ഓരോ തവണ ആക്സസ് ചെയ്യുമ്പോഴും ഒരു അദ്വിതീയ നമ്പർ സൃഷ്ടിക്കുന്നു.

ജനറേറ്റർ സൃഷ്ടിക്കൽ:

ജനറേറ്റർ സൃഷ്ടിക്കുക<Имя генератора>

പ്രാരംഭ മൂല്യം നിർദ്ദേശങ്ങളാൽ വ്യക്തമാക്കിയിരിക്കുന്നു:

ജനറേറ്റർ സജ്ജമാക്കുക<Имя генератора>TO<Начальное значение (целое число)>

ജനറേറ്റർ ജെൻസ്റ്റോർ സൃഷ്ടിക്കുക

ജനറേറ്റർ ജെൻസ്റ്റോർ 1 ആയി സജ്ജീകരിക്കുക

ഫംഗ്ഷൻ ഉപയോഗിച്ച് സൃഷ്ടിച്ച ജനറേറ്റർ ആക്സസ് ചെയ്യുന്നു

GEN_ID(<Имя генератора>, <Шаг>)

ഒരു ട്രിഗർ എന്നത് ഡാറ്റാബേസ് സെർവറിൽ സ്ഥിതി ചെയ്യുന്ന ഒരു നടപടിക്രമമാണ്, കൂടാതെ ഡാറ്റാബേസ് റെക്കോർഡുകൾ പരിഷ്കരിക്കുമ്പോൾ സ്വയമേവ വിളിക്കപ്പെടുന്നു, അതായത്. കോളങ്ങൾ മാറ്റുമ്പോഴോ അവ നീക്കം ചെയ്യുമ്പോഴോ ചേർക്കുമ്പോഴോ. സംഭരിച്ച നടപടിക്രമങ്ങളിൽ നിന്ന് വ്യത്യസ്തമായി, ഒരു ക്ലയൻ്റ് ആപ്ലിക്കേഷനിൽ നിന്ന് ട്രിഗറുകൾ വിളിക്കാൻ കഴിയില്ല, നിങ്ങൾക്ക് അവയിലേക്ക് പാരാമീറ്ററുകൾ കൈമാറാനോ അവയിൽ നിന്ന് ഫലങ്ങൾ സ്വീകരിക്കാനോ കഴിയില്ല.

ഒരു ട്രിഗർ സൃഷ്ടിക്കുന്നു:

ട്രിഗർ സൃഷ്‌ടിക്കുക<>വേണ്ടി<>

(മുമ്പ് | ശേഷം)

(അപ്ഡേറ്റ് ചെയ്യുക | തിരുകുക | ഇല്ലാതാക്കുക)

എ.എസ്<Тело триггера>

സജീവ വിവരണങ്ങൾ | ട്രിഗർ സൃഷ്‌ടിച്ചതിന് ശേഷം അത് സജീവമാണോ എന്ന് നിഷ്‌ക്രിയമാണ് നിർണ്ണയിക്കുക. സ്ഥിരസ്ഥിതി സജീവമാണ്.

വിവരണങ്ങൾക്ക് മുമ്പ് | റെക്കോർഡുകൾ മാറ്റുന്നതുമായി ബന്ധപ്പെട്ട അനുബന്ധ ഇവൻ്റ് സംഭവിക്കുന്നതിന് മുമ്പോ ശേഷമോ ട്രിഗർ പ്രവർത്തിപ്പിക്കാൻ തുടങ്ങുന്ന നിമിഷം AFTER വ്യക്തമാക്കുന്നു.

വിവരണങ്ങൾ അപ്ഡേറ്റ് | തിരുകുക | റെക്കോർഡുകൾ എഡിറ്റുചെയ്യുമ്പോഴോ ചേർക്കുമ്പോഴോ ഇല്ലാതാക്കുമ്പോഴോ - ഏത് ഇവൻ്റാണ് ട്രിഗർ ട്രിഗർ ചെയ്യുന്നതെന്ന് നിർണ്ണയിക്കുക.

ഒരു ഇവൻ്റിന്, നിങ്ങൾക്ക് നിരവധി ട്രിഗറുകൾ സൃഷ്ടിക്കാൻ കഴിയും, അവ ഓരോന്നും സ്വയമേവ നടപ്പിലാക്കും (അത് സജീവമായ അവസ്ഥയിലാണെങ്കിൽ). ഒന്നിലധികം ട്രിഗറുകൾ ഉണ്ടെങ്കിൽ, POSITION ഓപ്പറണ്ടിൽ വ്യക്തമാക്കിയ സംഖ്യ അനുസരിച്ചാണ് അവയെ വിളിക്കുന്ന (നിർവഹണം) ക്രമം നിർണ്ണയിക്കുന്നത്. ഈ സംഖ്യകളുടെ ആരോഹണ ക്രമത്തിലാണ് ട്രിഗറുകൾ നടപ്പിലാക്കുന്നത്.

ഒരു ട്രിഗർ നീക്കംചെയ്യുന്നു:

ഡ്രോപ്പ് ട്രിഗർ<Имя триггера>

ട്രിഗർ മാറ്റം:

കോളം മൂല്യങ്ങൾ ആക്സസ് ചെയ്യുന്നതിന്, ഫോർമാറ്റ് നിർദ്ദേശങ്ങൾ ഉപയോഗിക്കുന്നു:

പഴയത്.<Имя столбца>- നിരയുടെ പഴയ (മാറ്റങ്ങൾക്ക് മുമ്പ്) മൂല്യത്തെ സൂചിപ്പിക്കുന്നു,

പുതിയത്.<Имя столбца>- കോളത്തിൻ്റെ പുതിയ (മാറ്റങ്ങൾക്ക് ശേഷം) മൂല്യത്തെ സൂചിപ്പിക്കുന്നു.

ഒരു കീ കോളത്തിലേക്ക് അദ്വിതീയ മൂല്യങ്ങൾ ചേർക്കുന്നതിന് ഒരു ട്രിഗർ സൃഷ്ടിക്കുന്നു

ടേബിൾ സ്റ്റോർ സൃഷ്ടിക്കുക

(S_Code INTEGER NULL അല്ല ,

പ്രൈമറി കീ(എസ്_കോഡ്));

ജനറേറ്റർ ജെൻസ്റ്റോർ സൃഷ്ടിക്കുക

ജനറേറ്റർ ജെൻസ്റ്റോർ 1 ആയി സജ്ജീകരിക്കുക

സ്‌റ്റോറിനായി ട്രിഗർ കോഡ്‌സ്റ്റോർ സൃഷ്‌ടിക്കുക

NEW.S_Code = GEN_ID(GenStore, 1);

ഒരു മേശയിൽ ചേർക്കുമ്പോൾ പുതിയത് സംഭരിക്കുകറെക്കോർഡ്, ആ റെക്കോർഡിൻ്റെ S_Code കീ കോളത്തിന് ഒരു അദ്വിതീയ മൂല്യം സ്വയമേവ നൽകപ്പെടും. GEN_ID-നെ GenStore ജനറേറ്ററിലേക്ക് വിളിക്കുന്നതിലൂടെ ഇത് നേടാനാകും.

ഒരു ട്രിഗർ ഉപയോഗിച്ച് റെക്കോർഡുകളുടെ കാസ്കേഡ് ഇല്ലാതാക്കൽ നടപ്പിലാക്കൽ

ടേബിൾ സ്റ്റോർ സൃഷ്ടിക്കുക

(S_Code INTEGER NULL അല്ല ,

പ്രൈമറി കീ(എസ്_കോഡ്));

ടേബിൾ കാർഡുകൾ സൃഷ്ടിക്കുക

(C_കോഡ് INTEGER NULL അല്ല,

C_Code2 INTEGER NULL അല്ല,

പ്രൈമറി കീ(C_കോഡ്));

സ്‌റ്റോറിനായി ട്രിഗർ ഡിലീറ്റ് സ്റ്റോർ സൃഷ്‌ടിക്കുക

സ്റ്റോർ എവിടെയായിരുന്നാലും കാർഡുകളിൽ നിന്ന് ഇല്ലാതാക്കുക.S_Code = Cards.C_Code2;

സ്റ്റോർ ടേബിളിലെ ഒരു എൻട്രി ഇല്ലാതാക്കിയ ശേഷം, കാർഡ് പട്ടികയിലെ എല്ലാ അനുബന്ധ എൻട്രികളും സ്വയമേവ ഇല്ലാതാക്കപ്പെടും.

അഭിപ്രായം: ഫിസിക്കൽ ലെയറിൽ സജ്ജീകരിച്ചിരിക്കുന്ന റഫറൻഷ്യൽ ഇൻ്റഗ്രിറ്റി നിയന്ത്രണങ്ങൾക്ക് ടേബിളുകൾ വിധേയമാകരുത്.

ലിങ്ക് കോളങ്ങൾ അപ്ഡേറ്റ് ചെയ്യുക ( പ്രധാന നിരകൾ) പ്രധാന പട്ടികയുടെ ലിങ്ക് കോളത്തിൻ്റെ മൂല്യം മാറുമ്പോൾ, സബോർഡിനേറ്റ് ടേബിളിൻ്റെ എല്ലാ അനുബന്ധ രേഖകളുടെയും ലിങ്ക് കോളത്തിൻ്റെ മൂല്യങ്ങൾ അതിനനുസരിച്ച് മാറുന്നു എന്ന വസ്തുത ഉൾക്കൊള്ളുന്ന ലിങ്ക് ചെയ്ത പട്ടികകൾ.

സ്റ്റോറിനായി ട്രിഗർ ചേഞ്ച്‌സ്റ്റോർ സൃഷ്‌ടിക്കുക

IF(OLD.S_Code<>NEW.S_കോഡ്)

തുടർന്ന് കാർഡുകൾ അപ്ഡേറ്റ് ചെയ്യുക

സെറ്റ് C_Code2 = NEW.S_Code

എവിടെ C_Code2 = OLD.S_Code;

സ്റ്റോർ മാസ്റ്റർ ടേബിളിനെ കാർഡ് സബ്‌ടേബിളിലേക്ക് ലിങ്ക് ചെയ്യാൻ ഉപയോഗിക്കുന്ന S_Code കോളം നിങ്ങൾ മാറ്റുമ്പോൾ, സബ്‌ടേബിളിലെ അനുബന്ധ റെക്കോർഡുകളുടെ C_Code2 ലിങ്ക് കോളത്തിലെ മൂല്യങ്ങൾ സ്വയമേവ മാറും.

ഒരു പ്രധാന പട്ടിക കോളം എഡിറ്റുചെയ്യാൻ, അതിനായി ഒരു കീ സൃഷ്ടിക്കാൻ പാടില്ല.

ട്രിഗർഒരു ടേബിളിൽ ഒരു റെക്കോർഡ് മാറ്റുമ്പോഴോ ഇല്ലാതാക്കുമ്പോഴോ ചേർക്കുമ്പോഴോ DBMS സ്വയമേവ വിളിക്കുന്ന ഒരു ഡാറ്റാബേസ് നടപടിക്രമത്തിന് സമാനമായ ഒരു സബ്റൂട്ടീനാണ്. ഒരു പ്രോഗ്രാമിൽ നിന്ന് ട്രിഗറുകൾ ആക്‌സസ് ചെയ്യാനോ അവയ്ക്ക് പാരാമീറ്ററുകൾ കൈമാറാനോ അവയിൽ നിന്ന് ഫലങ്ങൾ സ്വീകരിക്കാനോ കഴിയില്ല. മിക്കപ്പോഴും, ഡാറ്റാബേസിൽ റഫറൻഷ്യൽ ഇൻ്റഗ്രിറ്റിയും കാസ്കേഡ് പ്രവർത്തനങ്ങളും നിലനിർത്താൻ ട്രിഗറുകൾ ഉപയോഗിക്കുന്നു. കാസ്‌കേഡിംഗ് ഇല്ലാതാക്കലും അപ്‌ഡേറ്റ് പ്രവർത്തനങ്ങളും നിർവചിക്കുന്ന റഫറൻസ് സ്പെസിഫിക്കേഷനുകൾ, പട്ടികകൾ പ്രഖ്യാപിക്കുമ്പോൾ സൃഷ്ടിക്കപ്പെടുന്നു, അവ ട്രിഗറുകൾ വഴിയും നടപ്പിലാക്കുന്നു, എന്നാൽ ഈ ട്രിഗറുകളുടെ വാചകം എഡിറ്റുചെയ്യാനാകില്ല.

ട്രിഗറുകളുടെ ഉദ്ദേശ്യം

മാറ്റങ്ങൾ തടയുക (ഉദാഹരണത്തിന്, ഇൻവോയ്‌സുകൾ അയച്ചതിന് ശേഷം മാറ്റുന്നത് തടയുക).
. ലോഗ് മാറ്റങ്ങൾ (ഉദാഹരണത്തിന്, പഴയ ഡാറ്റയുടെ പകർപ്പുകൾ സൂക്ഷിക്കുക).
. ഓഡിറ്റ് മാറ്റങ്ങൾ (ഉദാഹരണത്തിന്, മാറ്റങ്ങളിൽ ഉൾപ്പെട്ടിരിക്കുന്ന ഉപയോക്താക്കളുടെയും റോളുകളുടെയും ഒരു ലോഗ് സൂക്ഷിക്കുക).
. മാറ്റങ്ങൾ ക്യാപ്‌ചർ ചെയ്യുക (ഉദാഹരണത്തിന്, എല്ലാ മാറ്റങ്ങളും സെർവറിൻ്റെ ക്ലോക്ക് അനുസരിച്ചാണെന്ന് ഉറപ്പാക്കുക, ക്ലയൻ്റിൻ്റെതല്ല).
. ബിസിനസ്സ് നിയമങ്ങൾ നടപ്പിലാക്കൽ.
. ഡാറ്റ റെപ്ലിക്കേഷൻ (ഉദാഹരണത്തിന്, പിന്നീടുള്ള പതിപ്പിൽ മറ്റൊരു ഡാറ്റാബേസിലേക്ക് അയയ്ക്കുന്ന എല്ലാ മാറ്റങ്ങളുടെയും റെക്കോർഡ് സൂക്ഷിക്കുക).
. ഉൽപ്പാദനക്ഷമത വർദ്ധിപ്പിച്ചു (ഉദാഹരണത്തിന്, ഓരോ ഇടപാട് വിശദാംശത്തിനും ശേഷമുള്ള ബാലൻസ് അപ്ഡേറ്റ് ചെയ്യുന്നത്, ചോദ്യങ്ങൾ വേഗത്തിലാക്കാൻ).

ട്രിഗറുകൾ പ്രഖ്യാപിക്കുന്നു

ട്രിഗർ സൃഷ്‌ടിക്കുക {മുമ്പ്|ശേഷം} {ഇല്ലാതാക്കുക|ഇൻസേർട്ട്|അപ്ഡേറ്റ് ചെയ്യുക [ഓഫ് ]} ഓൺ റഫറൻസ് {പഴയത് {[വരി]|മേശ [എ.എസ്] } പുതിയത് {വരി|മേശ} [എ.എസ്] }] [ഓരോന്നിനും {പ്രസ്താവന|വരി [എപ്പോൾ ]}]
[ആറ്റോമിക് ആരംഭിക്കുക]

[അവസാനിക്കുന്നു]

കീവേഡുകൾ

. മുമ്പ്|ശേഷം– ട്രിഗർ ആരംഭ സമയം – മുമ്പ് | അപ്ഡേറ്റ് പ്രവർത്തനത്തിന് ശേഷം.
. ഇല്ലാതാക്കുക|ഇൻസേർട്ട്|അപ്ഡേറ്റ് ചെയ്യുക= ട്രിഗർ ഇവൻ്റ്.
. ഓരോ വരിയിലും- ഓരോ വരിക്കും (ലൈൻ ട്രിഗർ, പിന്നെ എപ്പോൾ).
. ഓരോ പ്രസ്താവനയ്ക്കും- മുഴുവൻ ടീമിനും (സ്ഥിരസ്ഥിതിയായി സാധുതയുള്ളത്).
. റഫറൻസ്– പഴയതും | എന്നതിനും 4 അപരനാമങ്ങൾ വരെ നൽകാൻ നിങ്ങളെ അനുവദിക്കുന്നു അല്ലെങ്കിൽ പുതിയ വരികളും | അല്ലെങ്കിൽ ട്രിഗറുകൾ വഴി ആക്സസ് ചെയ്യാൻ കഴിയുന്ന പട്ടികകൾ.

നിയന്ത്രണങ്ങൾ ട്രിഗർ ചെയ്യുക

ട്രിഗർ ബോഡിയിൽ ഇനിപ്പറയുന്ന പ്രസ്താവനകൾ അടങ്ങിയിരിക്കരുത്:
. ഡാറ്റാബേസ് ഒബ്ജക്റ്റുകൾ (പട്ടികകൾ, ഡൊമെയ്‌നുകൾ മുതലായവ) നിർവചിക്കുകയും ഇല്ലാതാക്കുകയും മാറ്റുകയും ചെയ്യുന്നു.
. ഇടപാട് പ്രോസസ്സിംഗ് (കമ്മിറ്റ്, റോൾബാക്ക്)
. ഡാറ്റാബേസിലേക്കുള്ള കണക്ഷനുകളും വിച്ഛേദങ്ങളും (കണക്റ്റ്, ഡിസ്കണക്ട്)

ആപ്ലിക്കേഷൻ്റെ സവിശേഷതകൾ
. മറ്റെല്ലാ (ഡിക്ലറേറ്റീവ്) ഇൻ്റഗ്രിറ്റി ചെക്കുകളും പ്രയോഗിച്ചതിന് ശേഷമാണ് ട്രിഗർ എക്സിക്യൂട്ട് ചെയ്യുന്നത്, ടെസ്റ്റ് മാനദണ്ഡം വളരെ സങ്കീർണ്ണമായിരിക്കുമ്പോൾ ഇത് ഉപയോഗപ്രദമാണ്. ഡിക്ലറേറ്റീവ് ചെക്കുകൾ അപ്ഡേറ്റ് ഓപ്പറേഷൻ നിരസിക്കുകയാണെങ്കിൽ, ട്രിഗറുകൾ എക്സിക്യൂട്ട് ചെയ്യില്ല. ഒരു ഇടപാടിൻ്റെ പശ്ചാത്തലത്തിലാണ് ട്രിഗർ പ്രവർത്തിക്കുന്നത്, എന്നാൽ FK പരിമിതി അങ്ങനെയല്ല.
. ഒരു ട്രിഗർ അതിൻ്റെ അടിസ്ഥാന ടേബിളിൽ ഒരു അധിക പരിഷ്ക്കരണത്തിന് കാരണമാകുകയാണെങ്കിൽ, മിക്കപ്പോഴും ഇത് അതിൻ്റെ ആവർത്തന നിർവ്വഹണത്തിലേക്ക് നയിക്കില്ല, എന്നാൽ ഇത് വ്യക്തമാക്കണം. ഡിബിഎംഎസിൽ SQL സെർവർ OPTION കീവേഡ് (MAXRECURSIV 3) ഉപയോഗിച്ച് ആവർത്തനത്തിൻ്റെ 255 ലെവലുകൾ വരെ വ്യക്തമാക്കാനുള്ള കഴിവ് 2005 നൽകുന്നു.
. വലിയ ബൈനറി നിരകൾ (BLOBs) പ്രോസസ്സ് ചെയ്യുമ്പോൾ ട്രിഗറുകൾ സാധാരണയായി എക്സിക്യൂട്ട് ചെയ്യില്ല.
. ഡാറ്റ അപ്‌ഡേറ്റ് ചെയ്യുമ്പോഴെല്ലാം, ഡിബിഎംഎസ് സ്വയമേവ ട്രിഗർ വെർച്വൽ ടേബിളുകൾ എന്ന് വിളിക്കപ്പെടുന്നു, അവ വിവിധ ഡിബിഎംഎസുകളിൽ ഉണ്ട്. വ്യത്യസ്ത പേര്. ഇൻ്റർബേസിലും ഒറക്കിളിലും - ഇവ പുതിയതും പഴയതുമാണ്. SQL സെർവറിൽ - ചേർത്തു, ഇല്ലാതാക്കി. മാത്രമല്ല, ഡാറ്റ മാറുമ്പോൾ, രണ്ടും സൃഷ്ടിക്കപ്പെടുന്നു. ഈ പട്ടികകൾക്ക് ഒരേ എണ്ണം നിരകളുണ്ട്, പട്ടിക അപ്‌ഡേറ്റ് ചെയ്യുന്ന അതേ പേരുകളും ഡൊമെയ്‌നുകളും ഉണ്ട്. OUTPUT Inserted.ID,... INTO @ കീവേഡ് ഉപയോഗിച്ച് ഡാറ്റ ചേർക്കേണ്ട ഒരു താൽക്കാലിക ടേബിൾ ഉൾപ്പെടെ ഒരു പട്ടിക വ്യക്തമാക്കാനുള്ള കഴിവ് SQL സെർവർ 2005 DBMS നൽകുന്നു.
. നിരവധി ഡിബിഎംഎസുകളിൽ, ഒരേസമയം നിരവധി പ്രവർത്തനങ്ങൾക്കായി ട്രിഗറുകൾ പ്രഖ്യാപിക്കുന്നത് അനുവദനീയമാണ്. വ്യത്യസ്‌ത പ്രവർത്തനങ്ങളോടുള്ള വ്യത്യസ്ത പ്രതികരണങ്ങൾ നടപ്പിലാക്കാൻ, Oracle പ്രവചനങ്ങൾ നൽകുന്നു, ഇല്ലാതാക്കൽ, ചേർക്കൽ, അപ്‌ഡേറ്റുചെയ്യൽ, അത് അനുബന്ധ തരത്തിലുള്ള അപ്‌ഡേറ്റിന് True നൽകുന്നു.
. IN ഒറാക്കിൾ ഡിബിഎംഎസ്അപ്‌ഡേറ്റ് ട്രിഗറുകൾക്കായുള്ള നിരകളുടെ ഒരു ലിസ്റ്റ് നിങ്ങൾക്ക് വ്യക്തമാക്കാൻ കഴിയും (അപ്‌ഡേറ്റ് ഓഫ്), ഈ നിരകളുടെ മൂല്യങ്ങൾ മാത്രം മാറുമ്പോൾ മാത്രമേ ട്രിഗർ വിളിക്കപ്പെടുകയുള്ളൂവെന്ന് ഉറപ്പാക്കും.
. ഓരോ ട്രിഗർ ഇവൻ്റിനും ഒന്നിലധികം ട്രിഗറുകൾ പ്രഖ്യാപിക്കാൻ കഴിയും (ഒറക്കിളിന് ഒരു ടേബിളിന് 12 ട്രിഗറുകൾ ഉണ്ട്) സാധാരണയായി അവ സൃഷ്ടിക്കപ്പെട്ട ക്രമം അനുസരിച്ച് അവ എറിഞ്ഞുകളയുന്ന ക്രമം നിർണ്ണയിക്കപ്പെടുന്നു. ഇൻ്റർബേസ് പോലുള്ള ചില DBMS-കളിൽ, POSITION എന്ന അധിക കീവേഡ് ഉപയോഗിച്ചാണ് സ്റ്റാർട്ടപ്പ് ഓർഡർ വ്യക്തമാക്കുന്നത്. പൊതുവേ, ഓരോ കമാൻഡിനും ആദ്യം ട്രിഗറുകൾ എക്സിക്യൂട്ട് ചെയ്യണം, തുടർന്ന് ഓരോ വരിയിലും.
. ട്രിഗറുകൾ പരസ്പരം ഉൾച്ചേർക്കാവുന്നതാണ്. അങ്ങനെ, SQL സെർവർ 32 നെസ്റ്റിംഗ് ലെവലുകൾ അനുവദിക്കുന്നു (നെസ്റ്റിംഗ് ലെവൽ നിർണ്ണയിക്കാൻ നിങ്ങൾക്ക് @@NextLevel ഗ്ലോബൽ വേരിയബിൾ ഉപയോഗിക്കാം).

ട്രിഗറുകളുടെ ദോഷങ്ങൾ

സങ്കീർണ്ണത. ഡാറ്റാബേസിൽ ഡാറ്റയിൽ ചില പ്രവർത്തനങ്ങൾ സ്ഥാപിക്കുന്നത് അതിൻ്റെ രൂപകല്പന, നടപ്പാക്കൽ, ഭരണം എന്നിവ സങ്കീർണ്ണമാക്കുന്നു.
. സ്റ്റെൽത്ത് പ്രവർത്തനക്ഷമതഉപയോക്താവിൽ നിന്ന്. ചില സവിശേഷതകൾ മറച്ചിരിക്കുമ്പോൾ ഒരു ആപ്ലിക്കേഷൻ നവീകരിക്കുന്നത് ബുദ്ധിമുട്ടാണ്.
. പ്രകടനത്തിലെ സ്വാധീനം. ചെറിയ എണ്ണം ട്രിഗറുകൾ ഉപയോഗിച്ച്, ഡാറ്റ പ്രോസസ്സിംഗ് സമയം വർദ്ധിക്കുന്നു.

ട്രിഗറുകൾ എഡിറ്റുചെയ്യലും ഇല്ലാതാക്കലും

ഒരു ട്രിഗർ നീക്കംചെയ്യാൻ, DROP TRIGGER പ്രസ്താവന ഉപയോഗിക്കുക
. ഒരു ട്രിഗർ മാറ്റാൻ, ALTER TRIGGER... എന്ന പ്രസ്താവന ഉപയോഗിക്കുക.
. ട്രിഗറുകൾ പ്രവർത്തനരഹിതമാക്കുന്നു
ചില സന്ദർഭങ്ങളിൽ, ഉദാഹരണത്തിന്, ബാച്ച് ലോഡിംഗ് സമയത്ത്, ട്രിഗറുകൾ പ്രവർത്തനരഹിതമാക്കേണ്ടതുണ്ട്. നിരവധി ഡിബിഎംഎസുകൾ അതിനനുസരിച്ചുള്ള കഴിവുകൾ നൽകുന്നു. ഒറാക്കിളിലും SQL-ലും സെർവർ കീവാക്കുകൾ പ്രവർത്തനരഹിതമാക്കുക|പ്രാപ്‌തമാക്കുക, ഇൻ്റർബേസിൽ നിഷ്‌ക്രിയം|ആൾട്ടർ ട്രിഗർ പ്രസ്താവനയിൽ സജീവമാണ്.

വ്യാവസായിക സെർവറുകളുടെ സവിശേഷതകൾ

1) ഇൻ്റർബേസ്/ഫയർബേർഡ്

ട്രിഗർ സൃഷ്‌ടിക്കുക വേണ്ടി {സജീവം|നിഷ്ക്രിയം} {മുമ്പ്|ശേഷം} {തിരുകുക|ഇല്ലാതാക്കുക|അപ്ഡേറ്റ് ചെയ്യുക} [സ്ഥാനം ]
എ.എസ് [ഡിക്ലെയർ വേരിയബിൾ [()]]
ആരംഭിക്കുന്നു

അവസാനിക്കുന്നു

ഉദാഹരണം:

ഉപഭോക്താവിനായി TRIGGER BF_Del_Cust സൃഷ്‌ടിക്കുക
സ്ഥാനം 1 ആയി ഇല്ലാതാക്കുന്നതിന് മുമ്പ് സജീവം
ആരംഭിക്കുന്നു
Orders.CNum=Customer.CNum എന്ന ഓർഡറുകളിൽ നിന്ന് ഇല്ലാതാക്കുക;
അവസാനിക്കുന്നു;

2) SQL സെർവർ

ട്രിഗർ സൃഷ്‌ടിക്കുക ഓൺ [എൻക്രിപ്ഷൻ ഉപയോഗിച്ച്] {വേണ്ടി|ശേഷം|പകരം} {തിരുകുക|അപ്ഡേറ്റ് ചെയ്യുക|ഇല്ലാതാക്കുക}
എ.എസ്

B1 ഉപയോഗിക്കുക;
പോകൂ
ഉപഭോക്താവിൽ ട്രിഗർ ഇൻഅപ്പ്‌കസ്‌റ്റ് 1 സൃഷ്‌ടിക്കുക, അപ്‌ഡേറ്റ് ചെയ്‌തതിന് ശേഷം
AS RAISEERROR('ഉപഭോക്തൃ പട്ടിക മാറ്റി');

അധിക തരം ട്രിഗറുകൾ

Oracle ഉം SQL സെർവറും അപ്‌ഡേറ്റ് ചെയ്യാത്ത കാഴ്‌ചകൾക്കായി ട്രിഗറുകൾ സൃഷ്‌ടിക്കുന്നതിനുള്ള കഴിവ് നൽകുന്നു. ഈ ആവശ്യത്തിനായി, പകരം കീവേഡുകൾ നൽകിയിരിക്കുന്നു:

ഇൻസേർട്ട് ചെയ്യുന്നതിന് പകരം ട്രിഗർ സൃഷ്‌ടിക്കുക ...

കാഴ്‌ചകൾ ഉപയോഗിച്ച് ഡാറ്റ അപ്‌ഡേറ്റ് ചെയ്യാനുള്ള ക്ലയൻ്റ് ശ്രമങ്ങൾ നിങ്ങൾക്ക് നിരീക്ഷിക്കാനും എന്തെങ്കിലും പ്രവർത്തനങ്ങൾ നടത്താനും അപ്‌ഡേറ്റ് ചെയ്യാത്ത കാഴ്ചകൾ കൈകാര്യം ചെയ്യാനും കഴിയും.
. SQL സെർവർ DBMS ഒരു റോൾബാക്ക് ട്രിഗർ നൽകുന്നു, അത് യഥാർത്ഥത്തിൽ എല്ലാ പ്രവർത്തനങ്ങളും നിർത്തുകയും ഒരു സന്ദേശം നൽകുകയും ചെയ്യുന്നു:

റോൾബാക്ക് ട്രിഗർ

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

ഓരോ ടേബിളിനും വെവ്വേറെ ട്രിഗറുകൾ സൃഷ്ടിക്കുകയും "ട്രിഗറുകൾ" ഫോൾഡറിലെ ഒബ്ജക്റ്റ് എക്സ്പ്ലോററിൽ സ്ഥിതി ചെയ്യുകയും ചെയ്യുന്നു. "അധ്യാപകർ" പട്ടികയ്ക്കായി ട്രിഗറുകൾ സൃഷ്ടിക്കാം. "ട്രിഗറുകൾ" ഫോൾഡർ "അധ്യാപകർ" പട്ടികയുടെ ഭാഗമായിരിക്കും:

പട്ടികയിൽ ഒരു റെക്കോർഡ് ചേർക്കുമ്പോൾ "റെക്കോർഡ് ചേർത്തു" എന്ന സന്ദേശം പ്രദർശിപ്പിക്കുന്ന ഒരു ട്രിഗർ നമുക്ക് സൃഷ്ടിക്കാം. "അധ്യാപകർ" പട്ടികയിലെ "ട്രിഗറുകൾ" ഫോൾഡറിൽ വലത്-ക്ലിക്കുചെയ്ത് ദൃശ്യമാകുന്ന മെനുവിൽ നിന്ന് "പുതിയ ട്രിഗർ" തിരഞ്ഞെടുത്ത് നമുക്ക് ഒരു പുതിയ ട്രിഗർ സൃഷ്ടിക്കാം. പുതിയ ട്രിഗറുള്ള ഇനിപ്പറയുന്ന വിൻഡോ ദൃശ്യമാകും:

ട്രിഗറുകളുടെ ഘടന നോക്കാം:

1) ഫംഗ്‌ഷൻ നാമത്തിൻ്റെ വ്യാപ്തി (Trigger_Name);

2) ഏത് പട്ടികയ്‌ക്കായാണ് ട്രിഗർ സൃഷ്‌ടിക്കുന്നതെന്ന് കാണിക്കുന്ന ഏരിയ (Table_Name);

3) ട്രിഗർ എപ്പോൾ എക്സിക്യൂട്ട് ചെയ്യണമെന്ന് കാണിക്കുന്ന ഒരു ഏരിയ (ഇൻസേർട്ട് - ടേബിളിൽ ഒരു റെക്കോർഡ് സൃഷ്ടിക്കുമ്പോൾ, ഇല്ലാതാക്കുക - ഇല്ലാതാക്കുമ്പോൾ അപ്ഡേറ്റ് ചെയ്യുക - മാറ്റുമ്പോൾ) അത് എങ്ങനെ എക്സിക്യൂട്ട് ചെയ്യാം (ALTER - ഓപ്പറേഷൻ എക്സിക്യൂട്ട് ചെയ്തതിന് ശേഷം, പകരം - എക്സിക്യൂട്ട് ചെയ്യുന്നതിന് പകരം പ്രവര്ത്തനം);

4) ട്രിഗറിൻ്റെ ബോഡിയിൽ TSQL അന്വേഷണ പ്രോഗ്രാമിംഗ് ഭാഷയുടെ കമാൻഡുകൾ അടങ്ങിയിരിക്കുന്നു.

പുതിയ ട്രിഗർ വിൻഡോയിൽ, കോഡ് നൽകുക:

TRIGGER TR_add സൃഷ്‌ടിക്കുക

dbo.teachers-ൽ

"പുതിയ എൻട്രി ചേർത്തു" എന്ന് അച്ചടിക്കുക

"dbo.teachers" ടേബിളിൽ (ON dbo.teachers) ഒരു റെക്കോർഡ് (ഇൻസേർട്ടിന് ശേഷം) ചേർത്തതിന് ശേഷം സൃഷ്ടിച്ച "സൂചകം ചേർക്കുക" ട്രിഗർ എക്സിക്യൂട്ട് ചെയ്തതായി ചിത്രത്തിൽ നിന്ന് നിങ്ങൾക്ക് കാണാൻ കഴിയും. ഒരു എൻട്രി ചേർത്തതിന് ശേഷം, ട്രിഗർ "പുതിയ എൻട്രി ചേർത്തു" (PRINT "New Entry Added") എന്ന സന്ദേശം പ്രദർശിപ്പിക്കും. ടൂൾബാറിലെ ബട്ടണിൽ ക്ലിക്ക് ചെയ്ത് ടൈപ്പ് ചെയ്ത കോഡ് എക്സിക്യൂട്ട് ചെയ്യാം. "കമാൻഡ്(കൾ) വിജയകരമായി പൂർത്തിയാക്കി" എന്ന സന്ദേശം കോഡ് വിൻഡോയുടെ ചുവടെ ദൃശ്യമാകും.

പുതിയ ട്രിഗർ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് പരിശോധിക്കാം. നമുക്ക് ഒരു പുതിയ ശൂന്യമായ അഭ്യർത്ഥന സൃഷ്ടിച്ച് അതിൽ ചേർക്കുന്നതിന് ഇനിപ്പറയുന്ന കമാൻഡ് നൽകുക പുതിയ പ്രവേശനം"dbo.teachers" പട്ടികയിലേക്ക്:

dbo.teachers-ലേക്ക് തിരുകുക

"സിഡോറോവ്"

ടൂൾബാറിലെ ബട്ടണിൽ ക്ലിക്ക് ചെയ്ത് ടൈപ്പ് ചെയ്ത കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യാം. പട്ടികയിലേക്ക് ഒരു പുതിയ റെക്കോർഡ് ചേർക്കും, കൂടാതെ ട്രിഗർ "പുതിയ റെക്കോർഡ് ചേർത്തു" എന്ന സന്ദേശം പ്രദർശിപ്പിക്കും.

UPDATE, DELETE എന്നിവയുള്ള ട്രിഗറുകൾ സമാനമായ രീതിയിൽ സൃഷ്‌ടിക്കപ്പെട്ടിരിക്കുന്നു.

അസൈൻമെൻ്റ്: അനുസൃതമായിനിങ്ങളുടെ സ്വന്തം തീം ഉപയോഗിച്ച് സൃഷ്ടിക്കുകSQLസെർവർമാനേജ്മെൻ്റ്സ്റ്റുഡിയോപ്രകടനങ്ങൾ (3-4),അന്വേഷണങ്ങൾ (3-4), സംഭരിച്ച നടപടിക്രമങ്ങൾ (3-4), ഉപയോക്തൃ-നിർവചിച്ച പ്രവർത്തനങ്ങൾ (3-4), ട്രിഗറുകൾ (INSERT,അപ്ഡേറ്റ് ചെയ്യുകഒപ്പംഇല്ലാതാക്കുക). ഓപ്പറേറ്റർമാരെ സൃഷ്ടിക്കുമ്പോൾ സോപാധികമായ പ്രസ്താവനകളും ലൂപ്പുകളും ഉപയോഗിക്കുക.

ഒരു ട്രിഗർ എന്നത് കംപൈൽ ചെയ്ത രൂപത്തിൽ സെർവറിൽ സംഭരിച്ചിരിക്കുന്ന ഒരു നടപടിക്രമമാണ്, കൂടാതെ ഒരു റെക്കോർഡ് കൂട്ടിച്ചേർക്കുകയോ എഡിറ്റ് ചെയ്യുകയോ ഇല്ലാതാക്കുകയോ ചെയ്യുകയാണെങ്കിൽ, ക്ലയൻ്റിൻ്റെ ആഗ്രഹം പരിഗണിക്കാതെ തന്നെ സ്വയമേവ നിർവ്വഹിക്കുന്നു. ഒരു ക്ലയൻ്റ് ആപ്ലിക്കേഷനിൽ നിന്ന് ഒരു ട്രിഗർ പ്രവർത്തിപ്പിക്കാൻ നിങ്ങൾക്ക് നിർബന്ധിക്കാനാവില്ല. ട്രിഗർ കടന്നുപോകാൻ കഴിയില്ല ഇൻപുട്ട് പാരാമീറ്ററുകൾഅതിൽ നിന്ന് ഔട്ട്പുട്ട് പാരാമീറ്ററുകൾ നേടുക.

ട്രിഗർ എപ്പോഴും പ്രവർത്തിക്കുന്നു നിലവിലെഒരു നിർദ്ദിഷ്ട പ്രവർത്തനം രേഖപ്പെടുത്തുകയും നടപ്പിലാക്കുകയും ചെയ്യുന്നു.

ഇവൻ്റ് സംഭവിക്കുന്നതിന് മുമ്പ് ട്രിഗറുകൾ എക്സിക്യൂട്ട് ചെയ്യാൻ കഴിയും (പാരാമീറ്റർ മുമ്പ്)അല്ലെങ്കിൽ ഒരു സംഭവം നടന്നതിന് ശേഷം (പാരാമീറ്റർ ശേഷം).

പ്രവർത്തനത്തിൻ്റെ ദിശ അനുസരിച്ച് ട്രിഗറുകൾ വേർതിരിച്ചിരിക്കുന്നു:

• തിരുകുക -ഒരു എൻട്രി ചേർക്കാൻ;
• അപ്ഡേറ്റ് ചെയ്യുക- ഒരു റെക്കോർഡ് എഡിറ്റുചെയ്യാൻ;
• ഇല്ലാതാക്കുക- ഒരു റെക്കോർഡ് ഇല്ലാതാക്കാൻ.

ഒരു നിർദ്ദിഷ്‌ട പട്ടികയ്‌ക്കായി ഒരു ട്രിഗർ സൃഷ്‌ടിച്ചിരിക്കുന്നു, അത് അതിലുള്ളതാണ്. ഒരു പട്ടികയ്ക്ക് ഒരേ ദിശയിലുള്ള പ്രവർത്തനത്തിൻ്റെ നിരവധി ട്രിഗറുകൾ ഉണ്ടെങ്കിൽ, അവയുടെ പ്രതികരണ സമയം പ്രാഥമികമായി പാരാമീറ്ററുകളാൽ നിർണ്ണയിക്കപ്പെടുന്നു. മുമ്പ്ഒപ്പം ശേഷം, എപ്പോൾ ഒരേ മൂല്യംഇവൻ്റ് സംഭവ പരാമീറ്റർ - പരാമീറ്റർ സ്ഥാനംട്രിഗറിൻ്റെ നമ്പർ (ഓർഡർ) സൂചിപ്പിക്കുന്നു.

ട്രിഗറുകളുമായി പ്രവർത്തിക്കുമ്പോൾ, ഇത് ഓർമ്മിക്കുക:

• ഇടപാടുകൾ പിൻവലിക്കുമ്പോൾ, ട്രിഗറുകൾ വരുത്തിയ എല്ലാ മാറ്റങ്ങളും പിൻവലിക്കപ്പെടും;
• ചൈൽഡ് ടേബിളുകളിലെ കാസ്കേഡിംഗ് മാറ്റങ്ങളും കാസ്കേഡിംഗ് ഡിലീറ്റുകളും എളുപ്പത്തിൽ നടപ്പിലാക്കുന്നു;
• ട്രിഗർ ബോഡിയിൽ വരുത്തിയ മാറ്റങ്ങൾ ഓരോ ക്ലയൻ്റ് ആപ്ലിക്കേഷനും സ്വയമേവ പ്രവർത്തിക്കുന്നു, അതായത് ഓരോ ഉപയോക്താവിനും വരുത്തിയ മാറ്റങ്ങൾ ആശയവിനിമയം നടത്തേണ്ട ആവശ്യമില്ല.

ചില പ്രത്യേക സവിശേഷതകൾ ഉണ്ടെങ്കിലും, സംഭരിച്ച നടപടിക്രമങ്ങൾ സൃഷ്ടിക്കുന്നതിനുള്ള നിയമങ്ങൾക്കനുസൃതമായി ഒരു ട്രിഗർ സൃഷ്ടിക്കപ്പെടുന്നു.

ഒരു ട്രിഗർ സൃഷ്ടിക്കുന്നു

ഒരു ട്രിഗർ സൃഷ്ടിക്കാൻ, ഓപ്പറേറ്റർ ഉപയോഗിക്കുക ട്രിഗർ സൃഷ്‌ടിക്കുക.

ഓപ്പറേറ്റർ ഫോർമാറ്റ്

ട്രിഗർ സൃഷ്‌ടിക്കുക വേണ്ടി

[ സജീവം | നിഷ്ക്രിയം ]

[ മുമ്പ്|ശേഷം]

[തിരുകുക | അപ്ഡേറ്റ് ഇല്ലാതാക്കുക ]

[ സ്ഥാനം ]

ഓപ്ഷനുകളുടെ ഉദ്ദേശ്യം:

സജീവം- ട്രിഗർ സജീവമാണ്, അതായത് നിർദ്ദിഷ്ട പട്ടിക ആക്സസ് ചെയ്യുമ്പോൾ, ട്രിഗർ സ്റ്റെലിൽ എഴുതിയ നടപടിക്രമം നടപ്പിലാക്കുന്നു

നിഷ്ക്രിയം- ട്രിഗർ നിഷ്ക്രിയമാണ്, അതായത് ട്രിഗർ സൃഷ്‌ടിക്കുകയും സെർവറിൽ സംഭരിക്കുകയും ചെയ്യുന്നു, എന്നാൽ നിർദ്ദിഷ്ട പട്ടിക ആക്‌സസ് ചെയ്യുമ്പോൾ, ട്രിഗർ ഘടകം> എക്‌സിക്യൂട്ട് ചെയ്യപ്പെടുന്നില്ല;

മുമ്പ്- മുമ്പ്ഒരു സംഭവത്തിൻ്റെ സംഭവം;

ശേഷം -പ്രതികരണ സമയം നിർണ്ണയിക്കുന്നു ശേഷംഒരു സംഭവത്തിൻ്റെ സംഭവം;

തിരുകുക -പട്ടികയിൽ ഒരു റെക്കോർഡ് ചേർക്കുന്ന സംഭവം ട്രിഗറിനായി നിർവ്വചിക്കുന്നു;

അപ്ഡേറ്റ് ചെയ്യുക -ട്രിഗറിനായി പട്ടികയിൽ ഒരു റെക്കോർഡ് എഡിറ്റ് ചെയ്യുന്ന സംഭവം നിർവ്വചിക്കുന്നു;

ഇല്ലാതാക്കുക -പട്ടികയിൽ നിന്ന് ഒരു റെക്കോർഡ് ഇല്ലാതാക്കുന്ന സംഭവം ട്രിഗറിന് വേണ്ടി നിർവചിക്കുന്നു;

സ്ഥാനം -ഒരു നിർദ്ദിഷ്ട ട്രിഗർ ഇവൻ്റിനുള്ളിലെ ട്രിഗർ നമ്പർ (സ്ഥാനം) നിർവചിക്കുന്നു (മുമ്പ്അഥവാ ശേഷം).

ട്രിഗർ നടപടിക്രമം വിവരിക്കാൻ, സംഭരിച്ച നടപടിക്രമം സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്ന അതേ ഓപ്പറേറ്റർമാരും കൺസ്ട്രക്‌റ്റുകളും ഉപയോഗിക്കുന്നു. ഒരു ട്രിഗറിൻ്റെ തലക്കെട്ട് അതിൻ്റെ പ്രവർത്തനം, ഫയറിംഗ് ഇവൻ്റ്, അത് പ്രതികരിക്കുന്ന പ്രവർത്തനം, കൂടാതെ, ഓപ്ഷണലായി, ട്രിഗറിൻ്റെ ഫയറിംഗ് സ്ഥാനം എന്നിവ നിർവചിക്കുന്നു.

ഒരു ട്രിഗർ സ്റ്റെൽ എഴുതുമ്പോൾ> നിങ്ങൾക്ക് അധികമായി കീവേഡുകൾ ഉപയോഗിക്കാം പഴയത്(ഇവൻ്റിനു മുമ്പ്) കൂടാതെ പുതിയത്(ഇവൻ്റിനുശേഷം) തുടർന്ന് ഫീൽഡ് നാമം.

ഒരു റിമോട്ട് ഡാറ്റാബേസിൽ പട്ടികകളിലെ എല്ലാ മാറ്റങ്ങളും (രേഖകൾ ചേർക്കുന്നതും എഡിറ്റ് ചെയ്യുന്നതും ഇല്ലാതാക്കുന്നതും) സാമ്പിളുകളിൽ വരുത്തിയിരിക്കുന്നതിനാൽ റാൻഡം ആക്സസ് മെമ്മറി), തുടർന്ന്, ഉദാഹരണത്തിന്, ഒരു ഫീൽഡിൻ്റെ മൂല്യം മാറ്റുമ്പോൾ, നിങ്ങൾക്ക് പഴയ (മാറ്റത്തിന് മുമ്പുള്ള) ഫീൽഡ് മൂല്യം - ObO.fieldname>, കൂടാതെ പുതിയ (മാറ്റത്തിന് ശേഷം) ഫീൽഡ് മൂല്യം - NEW-fieldname ഇല്ലെങ്കിൽ നിർദ്ദിഷ്ട ഫീൽഡിൽ മാറ്റം വരുത്തി, തുടർന്ന് ObO.chmb ഫീൽഡ്> NEW.chmb ഫീൽഡുകൾക്ക് തുല്യമായിരിക്കും

ഉദാഹരണം 6.10.ഒരു ട്രിഗർ സൃഷ്ടിക്കുന്നു.

കമ്പോസർമാർക്കായി TRIGGER T_COMPCODE സൃഷ്‌ടിക്കുക

സ്ഥാനം 0 ചേർക്കുന്നതിന് മുമ്പ് സജീവം

new.code_composer=gen_id(g_composers, 1); എങ്കിൽ (COMPOSERS. ഡാറ്റ ജനിച്ചത് അസാധുവല്ല) തുടർന്ന് ആരംഭിക്കുക

new.actuallyage = (CAST("ഇപ്പോൾ" തീയതി പ്രകാരം)-COMPOSERS.data_born)/365; എങ്കിൽ(COMPOSERS.data ദിവസം അസാധുവല്ല) അപ്പോൾ COM POSERS.age =(COMPOSERS.data_day-COMPOSERS. ഡാറ്റ ജനിച്ചത്) /365; മറ്റുള്ളവ പുതിയ.പ്രായം=ശൂന്യമായ; അവസാനിക്കുന്നു

ഒരു പുതിയ റെക്കോർഡ് ചേർക്കുന്നതിന് മുമ്പായി ട്രിഗർ ഫയർ ചെയ്യുകയും കമ്പോസറുടെ പ്രായം കണക്കാക്കുകയും ചെയ്യുന്നു. കണക്കാക്കിയ പ്രായം ഫീൽഡിൽ എഴുതിയിരിക്കുന്നു "യഥാർത്ഥ_പ്രായം».

ട്രിഗർ മാറ്റം

ട്രിഗർ മാറ്റാൻ, കമാൻഡ് ഉപയോഗിക്കുക ട്രിഗർ മാറ്റുക, ഇതിന് സമാനമായ ഫോർമാറ്റും കമാൻഡിന് സമാനമായ പ്രവർത്തന തത്വവുമുണ്ട് നടപടിക്രമം മാറ്റുകസംഭരിച്ച നടപടിക്രമത്തിൻ്റെ ശരീരം മാറ്റാൻ.

കമാൻഡ് ഫോർമാറ്റ്

ട്രിഗർ മാറ്റുക വേണ്ടി [ സജീവംഐ നിഷ്ക്രിയം

മുമ്പ്ഐ ശേഷം

തിരുകുകഐ അപ്ഡേറ്റ് ഇല്ലാതാക്കുക

[ സ്ഥാനം 1

പ്രസ്താവന നടപ്പിലാക്കിയ ശേഷം ട്രിഗർ മാറ്റുകപഴയ ട്രിഗർ നിർവചനം പുതിയ നിർവചനം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു. പഴയ ട്രിഗർ നിർവചനം പുനഃസ്ഥാപിക്കാൻ കഴിയില്ല.

ഉദാഹരണം 6.11.ഒരു ട്രിഗർ എഡിറ്റുചെയ്യുന്നു.

സ്ഥാനം 5 ആയി ചേർക്കുന്നതിന് മുമ്പ് സജീവമായ കമ്പോസർമാർക്ക് T_COMPCODE മാറ്റുക

new.code_composer=gen_id(g_composers, 1); എങ്കിൽ (COMPOSERS.data_born ശൂന്യമല്ല) തുടർന്ന് ആരംഭിക്കുക

new.actually_age = (CAST("ഇപ്പോൾ" തീയതി പ്രകാരം)-COMPOSERS.data_born)/365; if(COM POSERS.dataday അസാധുവല്ല) പിന്നെ COM POSERS.age =

(COMPOSERS.data_day-COMPOSERS.data ജനിച്ചത്) /365; മറ്റുള്ളവ പുതിയ.പ്രായം=ശൂന്യമായ; അവസാനിക്കുന്നു

അല്ലാത്തപക്ഷം new.age=null; new.actually_age=null; അവസാനം അവസാനം

ഉദാഹരണം 6.10-ൽ സൃഷ്‌ടിച്ച ട്രിഗർ ഒരു പുതിയ സ്ഥാനം ഉൾപ്പെടുത്തുന്നതിനായി പരിഷ്‌ക്കരിച്ചിരിക്കുന്നു ( സ്ഥാനം) ട്രിഗർ ആക്റ്റിവേഷൻ - 5.

ഒരു ട്രിഗർ നീക്കംചെയ്യുന്നു

ഒരു ട്രിഗർ നീക്കം ചെയ്യാൻ കമാൻഡ് ഉപയോഗിക്കുക

ഉദാഹരണം 6.12.ഒരു ട്രിഗർ നീക്കംചെയ്യുന്നു.

ഡ്രോപ്പ് ട്രിഗർ T_COMPCODE

ഇല്ലാതാക്കിയ ട്രിഗർ പുനഃസ്ഥാപിക്കാൻ കഴിയില്ല.

കാസ്കേഡ് പ്രവർത്തനങ്ങളിൽ ഒരു ട്രിഗർ ഉപയോഗിക്കുന്നു

മുകളിൽ സൂചിപ്പിച്ചതുപോലെ, രണ്ട് തരം കാസ്കേഡിംഗ് ഇഫക്റ്റുകൾ ഉണ്ട്: കാസ്കേഡിംഗ് മാറ്റവും കാസ്കേഡിംഗ് ഇല്ലാതാക്കലും. അതിനാൽ, ഓരോ പേരൻ്റ് ടേബിളിനും, നിങ്ങൾ രണ്ട് ട്രിഗറുകൾ നൽകേണ്ടതുണ്ട്: ഒന്ന് കാസ്കേഡ് മാറ്റത്തിന്, രണ്ടാമത്തേത് കാസ്കേഡ് ഡിലീറ്റിന്. ഈ സാഹചര്യത്തിൽ, റഫറൻഷ്യൽ സമഗ്രത വ്യവസ്ഥകൾ നീക്കം ചെയ്യണം.

ഉദാഹരണം 6.13.റെക്കോർഡുകളുടെ കാസ്കേഡ് ഇല്ലാതാക്കൽ.

ഒരു പേരൻ്റ് ടേബിളിൽ നിന്ന് അവസാന നാമം ഇല്ലാതാക്കുമ്പോൾ GAMഅനുബന്ധ പേരുകൾ ഇല്ലാതാക്കേണ്ടത് ആവശ്യമാണ് (കുടുംബനാമ കീകൾ പ്രകാരം)

li) എല്ലാ ചൈൽഡ് ടേബിളുകളിലും (ഉദാഹരണ പട്ടികയിൽ രചയിതാവ്ഒപ്പം പുസ്തകം).

ഫാം ആക്റ്റീവിനായി ട്രിഗർ ഡെൽ ഫാം സൃഷ്‌ടിക്കുക

രചയിതാവിൽ നിന്ന് ഇല്ലാതാക്കുക

എവിടെ FAM.KEYFAM = AUTHOR. കീഫാം; പുസ്തകത്തിൽ നിന്ന് ഇല്ലാതാക്കുക

FAM.KEY FAM = BOOK.KEY FAM;

ഉദാഹരണം 6.14.റെക്കോർഡുകളുടെ കാസ്കേഡ് എഡിറ്റിംഗ്.

ഒരു കീ ഫീൽഡിൻ്റെ മൂല്യം മാറുമ്പോൾ (കീ ഫാം)പാരൻ്റ് ടേബിളിൽ FAMനിങ്ങൾ അനുബന്ധ മൂല്യങ്ങൾ മാറ്റേണ്ടതുണ്ട് വിദേശ കീകൾഎല്ലാ ചൈൽഡ് ടേബിളുകളിലും (ഉദാഹരണ പട്ടികകളിൽ AUTHOR, BOOK എന്നിവയിൽ).

ഫാം ആക്റ്റീവിനായി ട്രിഗർ അപ്‌ഡി ഫാം സൃഷ്‌ടിക്കുക

AS അപ്ഡേറ്റ് ചെയ്യുന്നതിന് മുമ്പ്

എങ്കിൽ (OLD.KEYFAM NEW.KEY FAM) തുടർന്ന് ആരംഭിക്കുക

Author Set KEY FAM = NEW.KEY FAM അപ്ഡേറ്റ് ചെയ്യുക

എവിടെ കീ ഫാം - പഴയ കീ ഫാം; അപ്ഡേറ്റ് ബുക്ക് സെറ്റ് കീഫാം - N EW. കീഫാം

എവിടെ കീ ഫാം = പഴയ കീ ഫാം;

കാസ്കേഡ് ഇഫക്റ്റുകൾ ഉപയോഗിക്കുന്നതിൻ്റെ സവിശേഷതകൾ:

• ഇടപാടുകൾ പിൻവലിക്കുമ്പോൾ, ട്രിഗറുകൾ വരുത്തിയ എല്ലാ മാറ്റങ്ങളും തിരികെ നൽകും യഥാർത്ഥ മൂല്യങ്ങൾ;
• ഒരു ട്രിഗറിന് ഒന്നിലധികം പട്ടികകൾ ആക്സസ് ചെയ്യാൻ കഴിയും;
• ട്രിഗറിന് മാത്രമേ ആക്‌സസ് ചെയ്യാനാകൂ നിലവിലെപട്ടിക എൻട്രികൾ, അതായത്, മറ്റ് പട്ടിക എൻട്രികളിലേക്ക് നീങ്ങുന്നത് നിരോധിച്ചിരിക്കുന്നു.

ഒരു ട്രിഗർ ഉപയോഗിച്ച് ഡാറ്റ സാധുത ഉറപ്പാക്കുന്നു

ഒരു ടേബിളിന് ഒരു ഇവൻ്റിനായി നിരവധി ട്രിഗറുകൾ ഉണ്ടായിരിക്കുമെന്നതിനാൽ (ഒരു റെക്കോർഡ് ചേർക്കൽ, എഡിറ്റുചെയ്യൽ അല്ലെങ്കിൽ ഇല്ലാതാക്കൽ), പട്ടികയിൽ നൽകിയ ഡാറ്റയുടെ വിശ്വാസ്യത ഉറപ്പാക്കാൻ കഴിയും. ഡാറ്റ വിശ്വാസ്യത ഉറപ്പാക്കാൻ ഒരു ട്രിഗർ സൃഷ്ടിക്കാൻ, ഓപ്പറേറ്റർമാരും കീവേഡുകളും അധികമായി ഉപയോഗിക്കുന്നു.

എ. ഒരു ഫീൽഡിൻ്റെ മൂല്യം അദ്വിതീയമാണെന്ന് ഉറപ്പാക്കുന്നു

ചട്ടം പോലെ, ഈ ആവശ്യങ്ങൾക്കായി ഒരു ജനറേറ്റർ ഉപയോഗിക്കുന്നു. ജനറേറ്ററുകളുമായി പ്രവർത്തിക്കുന്നതിന്, ഖണ്ഡിക 6.3 കാണുക. ഒരു ജനറേറ്റർ ആദ്യം സൃഷ്ടിക്കപ്പെടുന്നു, തുടർന്ന് ജനറേറ്ററിൻ്റെ പേര് ട്രിഗറിൻ്റെ ബോഡിയിൽ വ്യക്തമാക്കിയിരിക്കുന്നു.

ഉദാഹരണം 6.15.പ്രാഥമിക കീ ഫീൽഡിൽ പൂരിപ്പിക്കൽ.

ഒരു അദ്വിതീയ പ്രാഥമിക കീ മൂല്യം ചേർക്കാൻ ഒരു ട്രിഗർ എഴുതുക കീഫാം.ജനറേറ്റർ GFAMഇതിനകം സൃഷ്ടിച്ചു.

ഫാമിനായി ഫ്രെയിമിലേക്ക് ട്രിഗർ സൃഷ്‌ടിക്കുക

N EW. KEYFAM = GEN_ID(G_FAM, 1);

ഉദാഹരണം 6.16.വിവര ഫീൽഡ് പൂരിപ്പിക്കുന്നു.

കമ്പോസർമാർക്കായി ട്രിഗർ ടികോംപ്ഡേറ്റ് സൃഷ്‌ടിക്കുക

സ്ഥാനം 0 അപ്ഡേറ്റ് ചെയ്യുന്നതിന് മുമ്പ് സജീവമാണ്

എങ്കിൽ (COMPOSERS. ഡാറ്റ ജനിച്ചത് അസാധുവല്ല) തുടർന്ന് ആരംഭിക്കുക

new.actually_age = (CAST("NOW" AS

തീയതി)-COMPOSERS.data_born)/365; എങ്കിൽ(COMPOSERS.data ദിവസം അസാധുവല്ല) അപ്പോൾ COM POSERS.age =

(COM POSERS.data_day-COMPOSERS.data_born)/365; മറ്റുള്ളവ പുതിയ.പ്രായം=ശൂന്യമായ; അവസാനിക്കുന്നു

അല്ലാത്തപക്ഷം new.age=null; new.actually_age=null; അവസാനിക്കുന്നു

IN ഈ ഉദാഹരണത്തിൽവ്യക്തിയുടെ പ്രായം കണക്കാക്കുകയും ഫീൽഡ് പൂരിപ്പിക്കുകയും ചെയ്യുന്നു യഥാർത്ഥത്തിൽ പ്രായം

ഒരു ട്രിഗർ ഉപയോഗിച്ച് ലോഗിംഗ് ഓഡിറ്റ് ചെയ്യുക

റിമോട്ട് ഡാറ്റാബേസുകളിൽ, മോശം ഡാറ്റയുടെ ഉറവിടം നിർണ്ണയിക്കുന്നതിന് ഡാറ്റാബേസ് പട്ടികകളിലെ മാറ്റങ്ങളുടെ ഒരു ലോഗ് നിലനിർത്തുന്നത് പ്രത്യേക താൽപ്പര്യമുള്ളതാണ്. ഒരു മാറ്റ ലോഗ് പരിപാലിക്കുമ്പോൾ, ഇനിപ്പറയുന്നവ ഒരു പ്രത്യേക പട്ടികയിൽ രേഖപ്പെടുത്തുന്നു:

• മേശപ്പുറത്ത് പ്രവർത്തനം നടത്തി;
• പുതിയ ഫീൽഡ് മൂല്യം;
• പഴയ ഫീൽഡ് മൂല്യം;
• മാറ്റം തീയതി;
• അവസാന നാമം, ആദ്യനാമം, ഉപയോക്താവിൻ്റെ രക്ഷാധികാരി (ഉപയോക്തൃ നാമം);
• വർക്ക്സ്റ്റേഷൻ നമ്പർ (പേര്).

ഉദാഹരണം 6.17.ഓഡിറ്റ് ലോഗിൻ്റെ യാന്ത്രിക പൂർത്തീകരണം.

നായ്ക്കൾക്കായി TRIGGER AFTJNS_DOGS സൃഷ്‌ടിക്കുക, ആരംഭിക്കുമ്പോൾ സ്ഥാനം 0 ചേർത്തതിന് ശേഷം സജീവമാണ്

ലോഗ് (ആക്ട്, ടേബിൾ_നെയിം, റെക്കോഡ്_ഐഡി) മൂല്യങ്ങളിൽ ("ഇൻസേർട്ട്", "ഡോഗ്സ്", ഡോഗ്സ്. ഐഡി) ചേർക്കുക; അവസാനിക്കുന്നു

POSITION 0 അപ്‌ഡേറ്റ് ചെയ്‌തതിന് ശേഷം നായ്ക്കൾക്കായി സജീവമായ AFT_UPD_DOGS സൃഷ്‌ടിക്കുക

ലോഗ് (ആക്ട്, ടേബിൾ_നെയിം, റെക്കോർഡ്_ഐഡി) മൂല്യങ്ങൾ ('UPDATE',"DOGS',DOGS.ID) ചേർക്കുക; അവസാനം

സ്ഥാനം 0 ആയി ഇല്ലാതാക്കിയ ശേഷം സജീവമായ നായ്ക്കൾക്കായി ട്രിഗർ സൃഷ്ടിക്കുക

ലോഗ് (ആക്ട്, ടേബിൾ_നെയിം, റെക്കോഡ്_ഐഡി) മൂല്യങ്ങൾ ('ഇല്ലാതാക്കുക","ഡോഗ്സ്', ഡോഗ്സ്.ഐഡി) എന്നിവയിലേക്ക് തിരുകുക; അവസാനിക്കുന്നു

പട്ടികയുടെ ഈ ഉദാഹരണത്തിൽ നായ്ക്കൾമൂന്ന് ട്രിഗറുകൾ സൃഷ്ടിച്ചു (ഓരോ ഇവൻ്റിനും ഒന്ന് ചേർക്കുക, അപ്ഡേറ്റ് ചെയ്യുകഒപ്പം ഇല്ലാതാക്കുക).ഓരോ ട്രിഗറുകളും ഓഡിറ്റ് ടേബിളിലേക്ക് ചേർക്കുന്നു ലോഗ്"നടത്തിയ പ്രവർത്തനം", "ടേബിളിൻ്റെ പേര്", "റെക്കോർഡ് നമ്പർ" എന്നീ ഫീൽഡുകൾ ഉൾക്കൊള്ളുന്ന ഒരു വരി. വേണമെങ്കിൽ, ഓഡിറ്റ് ടേബിളിലെ ഫീൽഡുകളുടെ എണ്ണം വർദ്ധിപ്പിക്കാം.