സംഭരിച്ച നടപടിക്രമംസംഭരിച്ച നടപടിക്രമം) എന്ന് പേരിട്ടിരിക്കുന്ന ഒരു ഡാറ്റാബേസ് പ്രോഗ്രാം ഒബ്ജക്റ്റ്. SQL സെർവറിന് നിരവധി തരം സംഭരിച്ച നടപടിക്രമങ്ങളുണ്ട്.

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

EXEC sp_helplogins;

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

പട്ടിക 10.6

SQL സെർവർ സിസ്റ്റം സംഭരിച്ച നടപടിക്രമത്തിന്റെ ഉദാഹരണങ്ങൾ

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

ട്രാൻസാക്റ്റ്-എസ്‌ക്യുഎൽ ടൂളുകളോ അസംബ്ലികളോ ഉപയോഗിച്ച് എസ്‌ക്യുഎൽ സെർവർ പ്രോഗ്രാമബിൾ ഒബ്‌ജക്റ്റുകൾ സൃഷ്‌ടിക്കാൻ കഴിയും (ഇംഗ്ലീഷ്)അസംബ്ലി) Microsoft.Net Framework-ന്റെ CRL (കോമൺ ലാംഗ്വേജ് റൺടൈം) പരിതസ്ഥിതിയിൽ. ഈ ട്യൂട്ടോറിയൽ ആദ്യ രീതി മാത്രം ഉൾക്കൊള്ളുന്നു.

സംഭരിച്ച നടപടിക്രമങ്ങൾ സൃഷ്‌ടിക്കാൻ, ക്രിയേറ്റ് പ്രൊസീഡർ (PROC ആയി ചുരുക്കാം) സ്റ്റേറ്റ്‌മെന്റ് ഉപയോഗിക്കുക, അതിന്റെ ഫോർമാറ്റ് ചുവടെ നൽകിയിരിക്കുന്നു:

സൃഷ്ടിക്കുക (PROC I PROCEDURE) proc_name [ ; നമ്പർ ]

[(gparameter data_type)

[“സ്ഥിരസ്ഥിതി] |

[കൂടെ [,...n]]

[പകർപ്പിനായി]

AS ([ BEGIN ] sql_statement [;] [ ...n ] [ END ] )

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

ഓരോ തവണയും നടപടിക്രമം വിളിക്കുമ്പോൾ സിസ്റ്റം ടെക്സ്റ്റ് വീണ്ടും കംപൈൽ ചെയ്യുമെന്ന് RECOMPILE ഓപ്ഷൻ വ്യക്തമാക്കുന്നു. സാധാരണ സാഹചര്യത്തിൽ, ആദ്യ റണ്ണിൽ സമാഹരിച്ച നടപടിക്രമം കാഷെയിൽ സംഭരിച്ചിരിക്കുന്നു, ഇത് പ്രകടനം വർദ്ധിപ്പിക്കാൻ അനുവദിക്കുന്നു.

EXECUTE AS എന്നത് നടപടിക്രമം നടപ്പിലാക്കേണ്ട സുരക്ഷാ സന്ദർഭം വ്യക്തമാക്കുന്നു. അടുത്തതായി, കോളർ മൂല്യങ്ങളിൽ ഒന്ന് | സ്വയം | ഉടമ | "ഉപയോക്തൃ_നാമം"). കോളർ എന്നത് സ്ഥിരസ്ഥിതിയാണ്, ഈ മൊഡ്യൂളിനെ വിളിക്കുന്ന ഉപയോക്താവിന്റെ സുരക്ഷാ പശ്ചാത്തലത്തിൽ കോഡ് എക്സിക്യൂട്ട് ചെയ്യപ്പെടും എന്നാണ് ഇതിനർത്ഥം. അതനുസരിച്ച്, പ്രോഗ്രാമബിൾ ഒബ്‌ജക്റ്റിന് മാത്രമല്ല, അത് ബാധിക്കുന്ന മറ്റ് ഡാറ്റാബേസ് ഒബ്‌ജക്റ്റുകൾക്കും ഉപയോക്താവിന് അനുമതികൾ ഉണ്ടായിരിക്കണം. സ്വയം എക്സിക്യൂട്ട് ചെയ്യുക എന്നാൽ പ്രോഗ്രാമബിൾ ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുന്നതോ പരിഷ്ക്കരിക്കുന്നതോ ആയ ഉപയോക്താവിന്റെ സന്ദർഭം ഉപയോഗിക്കുക എന്നാണ് അർത്ഥമാക്കുന്നത്. നടപടിക്രമത്തിന്റെ നിലവിലെ ഉടമയുടെ പശ്ചാത്തലത്തിൽ കോഡ് എക്സിക്യൂട്ട് ചെയ്യുമെന്ന് ഉടമ വ്യക്തമാക്കുന്നു. അതിന് ഉടമയെ വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, അത് ഉൾപ്പെടുന്ന സ്കീമയുടെ ഉടമയെ അനുമാനിക്കപ്പെടുന്നു. ഉപയോക്തൃനാമം (ഒറ്റ ഉദ്ധരണികളിൽ) വ്യക്തമായി വ്യക്തമാക്കാൻ "user_name" ആയി നടപ്പിലാക്കുക.

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

പാരാമീറ്ററുകൾക്ക് സ്ഥിരസ്ഥിതി മൂല്യങ്ങൾ നൽകാം, നടപടിക്രമം വിളിക്കുമ്പോൾ പാരാമീറ്റർ മൂല്യം വ്യക്തമായി വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ അത് ഉപയോഗിക്കും. നമുക്ക് ഒരു ഉദാഹരണം നോക്കാം:

പ്രോക് സുർമ സൃഷ്ടിക്കുക (@a int, @b int=0,

©ഫലം ഔട്ട്പുട്ട്) AS

@ഫലം=0a+0b സജ്ജമാക്കുക

ഞങ്ങൾ മൂന്ന് പാരാമീറ്ററുകളുള്ള ഒരു നടപടിക്രമം സൃഷ്ടിച്ചു, @b പാരാമീറ്ററിന് =0 ന്റെ സ്ഥിര മൂല്യമുണ്ട്, @ റിസൾട്ട് പാരാമീറ്റർ ഒരു ഔട്ട്‌പുട്ട് പാരാമീറ്ററാണ്: ഇത് കോളിംഗ് പ്രോഗ്രാമിലേക്ക് മൂല്യം നൽകുന്നു. നിർവഹിച്ച പ്രവർത്തനങ്ങൾ വളരെ ലളിതമാണ് - ഔട്ട്പുട്ട് പാരാമീറ്റർ രണ്ട് ഇൻപുട്ടുകളുടെ ആകെത്തുകയുടെ മൂല്യം സ്വീകരിക്കുന്നു.

SQL സെർവർ മാനേജ്മെന്റ് സ്റ്റുഡിയോയിൽ പ്രവർത്തിക്കുമ്പോൾ, സൃഷ്ടിച്ച സംഭരിച്ച നടപടിക്രമം പ്രോഗ്രാം ചെയ്യാവുന്ന ഡാറ്റാബേസ് ഒബ്ജക്റ്റ് വിഭാഗത്തിൽ കാണാം. (ഇംഗ്ലീഷ്)സംഭരിച്ച നടപടിക്രമങ്ങൾക്കുള്ള ഉപവിഭാഗത്തിൽ പ്രോഗ്രാമബിലിറ്റി (ചിത്രം 10.2).

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

അരി. 10.2

@s int പ്രഖ്യാപിക്കുക;

EXEC സമ്മ 10.5,@c ഔട്ട്പുട്ട്;

പ്രിന്റ് 0c; – 15 പ്രദർശിപ്പിക്കും

പ്രഖ്യാപിക്കുക Gi int = 5;

- വിളിക്കുമ്പോൾ, സ്ഥിരസ്ഥിതി മൂല്യം ഉപയോഗിക്കുക

EXEC summa Gi, DEFAULT , 0c ഔട്ട്‌പുട്ട്;

പ്രിന്റ് 0c; – 5 പ്രദർശിപ്പിക്കും

നടപടിക്രമം അവസാനിക്കുന്ന റിട്ടേൺ കോഡിന്റെ വിശകലനത്തോടുകൂടിയ ഒരു ഉദാഹരണം നമുക്ക് ഇപ്പോൾ പരിഗണിക്കാം. ഒരു നിശ്ചിത വർഷങ്ങളിൽ എത്ര പുസ്തകങ്ങൾ ബുക്ക്‌ൽ ടേബിളിൽ പ്രസിദ്ധീകരിച്ചു എന്ന് കണക്കാക്കണം എന്ന് കരുതുക. മാത്രമല്ല, പ്രാരംഭ വർഷം അവസാന വർഷത്തേക്കാൾ വലുതാണെങ്കിൽ, നടപടിക്രമം “1” നൽകുന്നു, അത് കണക്കാക്കില്ല, അല്ലാത്തപക്ഷം, ഞങ്ങൾ പുസ്തകങ്ങളുടെ എണ്ണം കണക്കാക്കി 0 നൽകുന്നു:

PROC dbo.rownum (0FirsYear int, GLastYear int, 0result int OUTPUT) എന്ന നിലയിൽ സൃഷ്ടിക്കുക

0FirsYear>0കഴിഞ്ഞ വർഷം റിട്ടേൺ 1

@ഫലം= സെറ്റ് ചെയ്യുക (dbo.Bookl-ൽ നിന്ന് COUNT(*) തിരഞ്ഞെടുക്കുക

0 ഒന്നാം വർഷത്തിനും 0 കഴിഞ്ഞ വർഷത്തിനും ഇടയിൽ എവിടെ);

ഈ നടപടിക്രമത്തെ വിളിക്കുന്നതിനുള്ള ഒരു വകഭേദം നമുക്ക് പരിഗണിക്കാം, അതിൽ റിട്ടേൺ കോഡ് പൂർണ്ണസംഖ്യ വേരിയബിൾ 0ret-ൽ സംഭരിച്ചിരിക്കുന്നു, അതിനുശേഷം അതിന്റെ മൂല്യം വിശകലനം ചെയ്യുന്നു (ഈ സാഹചര്യത്തിൽ അത് 1 ആയിരിക്കും). പ്രിന്റ് സ്റ്റേറ്റ്‌മെന്റിൽ ഉപയോഗിച്ചിരിക്കുന്ന CAST ഫംഗ്‌ഷൻ ഗ്രെസിന്റെ പൂർണ്ണസംഖ്യ വേരിയബിളിന്റെ മൂല്യം ഒരു സ്ട്രിംഗ് തരത്തിലേക്ക് പരിവർത്തനം ചെയ്യാൻ ഉപയോഗിക്കുന്നു:

പ്രഖ്യാപിക്കുക 0ret int, Gres int

EXEC Gret = rownum 2004, 2002, Gres OUT;

IF 0ret=l PRINT "ആരംഭ വർഷം അവസാന വർഷത്തേക്കാൾ വലുതാണ്"

"പുസ്തകങ്ങളുടെ എണ്ണം" + CAST(Gres as varchar(20)) പ്രിന്റ് ചെയ്യുക

സംഭരിച്ച നടപടിക്രമങ്ങൾക്ക് ഒരു പട്ടികയിൽ നിന്നുള്ള ഡാറ്റ വായിക്കാൻ മാത്രമല്ല, ഡാറ്റ പരിഷ്കരിക്കാനും പട്ടികകളും മറ്റ് നിരവധി ഡാറ്റാബേസ് ഒബ്ജക്റ്റുകളും സൃഷ്ടിക്കാനും കഴിയും.

എന്നിരുന്നാലും, സംഭരിച്ച ഒരു നടപടിക്രമത്തിൽ നിന്ന് നിങ്ങൾക്ക് സ്കീമകൾ, ഫംഗ്‌ഷനുകൾ, ട്രിഗറുകൾ, നടപടിക്രമങ്ങൾ, കാഴ്ചകൾ എന്നിവ സൃഷ്‌ടിക്കാനാവില്ല.

ഇനിപ്പറയുന്ന ഉദാഹരണം ഈ കഴിവുകളും താൽക്കാലിക വസ്തുക്കളുടെ വ്യാപ്തിയുമായി ബന്ധപ്പെട്ട പ്രശ്നങ്ങളും വ്യക്തമാക്കുന്നു. താൽകാലിക പട്ടിക #TaL2 നിലവിലുണ്ടോയെന്ന് ഇനിപ്പറയുന്ന സംഭരിച്ച നടപടിക്രമം പരിശോധിക്കുന്നു; ഈ പട്ടിക നിലവിലില്ലെങ്കിൽ, അത് അത് സൃഷ്ടിക്കുന്നു. ഇതിനുശേഷം, രണ്ട് നിരകളുടെ മൂല്യങ്ങൾ പട്ടിക #TaL2-ലേക്ക് നൽകി, കൂടാതെ പട്ടികയിലെ ഉള്ളടക്കങ്ങൾ SELECT സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിച്ച് പ്രദർശിപ്പിക്കും:

PROC സൃഷ്‌ടിക്കുക My_Procl (@id int, @name varchar(30))

OBJECT_ID("tempdb.dbo.#Tab21) അസാധുവാണെങ്കിൽ

dbo ലേക്ക് ചേർക്കുക.#Tab2 (id, name)VALUES (0id,0name)

dbo-യിൽ നിന്ന് * തിരഞ്ഞെടുക്കുക. #Tab2 –№1

സംഭരിച്ച നടപടിക്രമം ആദ്യമായി വിളിക്കുന്നതിന് മുമ്പ്, ഞങ്ങൾ അതിൽ ഉപയോഗിച്ചിരിക്കുന്ന #TaL2 താൽക്കാലിക പട്ടിക സൃഷ്ടിക്കും. EXEC ഓപ്പറേറ്റർ ശ്രദ്ധിക്കുക. മുമ്പത്തെ ഉദാഹരണങ്ങളിൽ, പാരാമീറ്ററുകൾ "സ്ഥാനം അനുസരിച്ച്" നടപടിക്രമത്തിലേക്ക് കൈമാറി, എന്നാൽ ഈ സാഹചര്യത്തിൽ പാരാമീറ്ററുകൾ കൈമാറുന്നതിനുള്ള മറ്റൊരു ഫോർമാറ്റ് ഉപയോഗിക്കുന്നു - "പേര് പ്രകാരം", പാരാമീറ്ററിന്റെ പേരും അതിന്റെ മൂല്യവും വ്യക്തമായി സൂചിപ്പിച്ചിരിക്കുന്നു:

ടേബിൾ dbo സൃഷ്ടിക്കുക.#Tab2 (id int, name varchar(30));

EXEC My_Procl 0name="lvan", 0id=2;

dbo.#Tab2-ൽ നിന്ന് * തിരഞ്ഞെടുക്കുക; –№2

മുകളിലെ ഉദാഹരണത്തിൽ, SELECT പ്രസ്താവന രണ്ടുതവണ പ്രോസസ്സ് ചെയ്യും: ആദ്യ തവണ - നടപടിക്രമത്തിനുള്ളിൽ, രണ്ടാം തവണ - കോളിംഗ് കോഡ് ശകലത്തിൽ നിന്ന് ("നമ്പർ 2" എന്ന കമന്റിൽ അടയാളപ്പെടുത്തിയത്).

നടപടിക്രമത്തിലേക്കുള്ള രണ്ടാമത്തെ കോളിന് മുമ്പ്, ഞങ്ങൾ താൽക്കാലിക പട്ടിക #TaL2 ഇല്ലാതാക്കും. സംഭരിച്ച നടപടിക്രമത്തിൽ നിന്ന് അതേ പേരിൽ ഒരു താൽക്കാലിക പട്ടിക സൃഷ്ടിക്കും:

ഡ്രോപ്പ് ടേബിൾ dbo.#Tab2;

EXEC My_Procl 0name="Ivan", 0id=2;

dbo.#Tab2-ൽ നിന്ന് * തിരഞ്ഞെടുക്കുക; –№2

ഈ സാഹചര്യത്തിൽ, നടപടിക്രമത്തിനുള്ളിൽ സ്ഥിതി ചെയ്യുന്ന SELECT പ്രസ്താവന (“Xa 1” എന്ന കമന്റിനൊപ്പം) മാത്രമേ ഡാറ്റ പ്രദർശിപ്പിക്കൂ. SELECT "നമ്പർ 2" നടപ്പിലാക്കുന്നത് ഒരു പിശകിന് കാരണമാകും, കാരണം സംഭരിച്ച നടപടിക്രമത്തിൽ സൃഷ്‌ടിച്ച താൽകാലിക പട്ടിക, നടപടിക്രമം മടങ്ങിവരുന്ന സമയത്ത് tempdb ഡാറ്റാബേസിൽ നിന്ന് ഇതിനകം തന്നെ ഇല്ലാതാക്കപ്പെടും.

DROP PROCEDURE പ്രസ്താവന ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു സംഭരിച്ച നടപടിക്രമം ഡ്രോപ്പ് ചെയ്യാം. അതിന്റെ ഫോർമാറ്റ് ചുവടെ അവതരിപ്പിച്ചിരിക്കുന്നു. സംഭരിച്ചിരിക്കുന്ന നിരവധി നടപടിക്രമങ്ങൾ നിങ്ങൾക്ക് ഒരു പ്രസ്താവന ഉപയോഗിച്ച് ഇല്ലാതാക്കാൻ കഴിയും, അവ കോമകളാൽ വേർതിരിച്ചിരിക്കുന്നു:

ഡ്രോപ്പ് (പ്രോസി I നടപടിക്രമം) ( നടപടിക്രമം ) [

ഉദാഹരണത്തിന്, മുമ്പ് സൃഷ്‌ടിച്ച സമ്മ നടപടിക്രമം ഇല്ലാതാക്കാം:

DROP PROC സംഗ്രഹം;

ALTER PROCEDURE സ്റ്റേറ്റ്‌മെന്റ് (അനുവദനീയമാണ്

ചുരുക്കെഴുത്ത് PROC). ALTER കീവേഡ് ഒഴികെ, സ്റ്റേറ്റ്‌മെന്റിന്റെ ഫോർമാറ്റ് അടിസ്ഥാനപരമായി ക്രിയേറ്റ് പ്രൊസീഡറിന്റേതിന് സമാനമാണ്. ഉദാഹരണത്തിന്, നമുക്ക് dbo നടപടിക്രമം മാറ്റാം. rownum, ഉടമയുടെ സുരക്ഷാ പശ്ചാത്തലത്തിൽ ഇത് നടപ്പിലാക്കാൻ സജ്ജമാക്കുന്നു:

ALTER PROC dbo.rownum (SFirsYear int,

SLastYear int, Sresult int OUTPUT)

ഉടമ എന്ന നിലയിൽ എക്സിക്യൂട്ട് ചെയ്യുക - ഇൻസ്റ്റാൾ ചെയ്യാവുന്ന ഓപ്ഷൻ

0FirsYear>0Lastyear റിട്ടേൺ 1 മറ്റൊരാരംഭം ആണെങ്കിൽ

സെറ്റ് 0ഫലം= (dbo.Bookl-ൽ നിന്ന് COUNT(*) തിരഞ്ഞെടുക്കുക

സ്ഫിർസ് വർഷത്തിനും സ്ലാസ്റ്റ് ഇയറിനുമിടയിൽ എവിടെ);

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

പ്രഖ്യാപിക്കുക 0у int = 2000;

EXEC ("തിരഞ്ഞെടുക്കുക * dbo.Bookl WHERE = "+@y) ;

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

മുമ്പത്തെ ഉദാഹരണം ചെറുതായി മാറ്റാം:

പ്രഖ്യാപിക്കുക 0у varchar(100);

സെറ്റ് 0у="2ООО"; - ഞങ്ങൾക്ക് ഇത് ഉപയോക്താവിൽ നിന്ന് ലഭിച്ചു

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

പ്രഖ്യാപിക്കുക 0у varchar(100);

സെറ്റ് 0у="2000; dbo.Book2 ൽ നിന്ന് ഇല്ലാതാക്കുക"; - കുത്തിവയ്പ്പ്

EXEC("dbo.Book2-ൽ നിന്ന് * തിരഞ്ഞെടുക്കുക "+0y);

അത്തരം സന്ദർഭങ്ങളിൽ, സാധ്യമെങ്കിൽ, SQL കുത്തിവയ്പ്പുകൾക്കുള്ള തടസ്സങ്ങളിലൊന്നായ പരാമീറ്ററുകളുടെ തരം നിയന്ത്രിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന sp_executcsql എന്ന സിസ്റ്റം സംഭരിച്ച നടപടിക്രമം ഉപയോഗിക്കാൻ ശുപാർശ ചെയ്യുന്നു. അതിന്റെ ഫോർമാറ്റ് വിശദമായി പരിഗണിക്കാതെ, മുമ്പ് അവതരിപ്പിച്ചതിന് സമാനമായ ഒരു ഉദാഹരണം നോക്കാം:

EXECUTE sp_executesql

N"തിരഞ്ഞെടുക്കുക * dbo. പുസ്തകം എവിടെ =0y",

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

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

എതിരായ വാദങ്ങളിൽ നിന്ന് നമുക്ക് ആരംഭിക്കാം:

ബിസിനസ്സ് ലോജിക് സ്മിയർ ചെയ്യുന്നു

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

DBMS ഭാഷയുടെ ദൗർലഭ്യം

അങ്ങനെ ഒരു കാര്യമുണ്ട്. HF pl/sql, t-sql, pl/pgsql എന്നിവ എഴുതുന്നതിനുള്ള പരമ്പരാഗത ഭാഷകൾ ആധുനിക പൊതു-ഉദ്ദേശ്യ ഭാഷകളുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ തികച്ചും പ്രാകൃതമാണ്. കൂടുതൽ നൂതനമായ ഭാഷകളിൽ എച്ച്എഫ് എഴുതാൻ കഴിയുമെന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്, ഉദാഹരണത്തിന് ജാവ ഒറാക്കിളിൽ അല്ലെങ്കിൽ പൈത്തൺ പോസ്റ്റ്‌ഗ്രെസ്‌ക്ലിൽ.

സംഭരിച്ച പ്രവർത്തനങ്ങളുടെ അസഹിഷ്ണുത

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

ടീമിൽ ആവശ്യമായ കഴിവുകളുടെ അഭാവം, പ്രസക്തമായ സ്പെഷ്യലിസ്റ്റുകളുടെ ഉയർന്ന "ചെലവ്"

ഇത്, എന്റെ അഭിപ്രായത്തിൽ, HF ഉപയോഗത്തിനെതിരായ ഏറ്റവും ഗുരുതരമായ വാദമാണ്. ഇതെല്ലാം പദ്ധതിയുടെ അളവിനെ ആശ്രയിച്ചിരിക്കുന്നു. ഏകദേശം പറഞ്ഞാൽ, ഇടത്തരം വലിയ എന്റർപ്രൈസ് പ്രോജക്റ്റുകളിൽ DBMS ഭാഗത്ത് സംഭരിച്ചിരിക്കുന്ന കോഡിന്റെ ഉപയോഗം ന്യായീകരിക്കപ്പെടുന്നു. പ്രോജക്റ്റ് ചെറുതാണെങ്കിൽ, ഗെയിം മെഴുകുതിരിക്ക് വിലയുള്ളതല്ല. പ്രോജക്റ്റ് വളരെ വലുതും അമിതഭാരമുള്ളതുമാണെങ്കിൽ, എച്ച്എഫ്, ആർഡിബിഎംഎസ് എന്നിവയുള്ള ആർക്കിടെക്ചർ സ്കെയിലിംഗ് പ്രശ്നങ്ങളിലേക്ക് നയിക്കും - ഇവിടെ ഒരു പ്രത്യേക സംഭരണവും ഡാറ്റാ പ്രോസസ്സിംഗിനുള്ള സമീപനവും ഉപയോഗിക്കേണ്ടത് ആവശ്യമാണ്.

ഇപ്പോൾ നേട്ടങ്ങൾ:

വേഗത

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

ഡാറ്റ ഘടന മറയ്ക്കുന്നു

ഒരു സോഫ്‌റ്റ്‌വെയർ സിസ്റ്റം വളരുകയും വികസിക്കുകയും ചെയ്യുന്നതിനനുസരിച്ച്, ഡാറ്റാ സ്കീമയ്ക്ക് മാറ്റമുണ്ടാകാം, മാറണം. നന്നായി രൂപകൽപന ചെയ്ത HF സോഫ്റ്റ്‌വെയർ ഇന്റർഫേസ് ബാഹ്യ ആപ്ലിക്കേഷനുകളുടെ കോഡ് മാറ്റാതെ തന്നെ ഡാറ്റ സ്കീമ മാറ്റാൻ നിങ്ങളെ അനുവദിക്കും (അവയിൽ പലതും ഉണ്ടാകാം). ഡാറ്റാബേസിനൊപ്പം പ്രവർത്തിക്കുന്ന ഡവലപ്പർമാരുടെയും അതിന്റെ ഘടന അറിയുന്നവരുടെയും, നൽകിയിരിക്കുന്ന API മാത്രം അറിയേണ്ട ബാഹ്യ ആപ്ലിക്കേഷനുകളുടെ ഡവലപ്പർമാരുടെയും റോളുകൾ ഇത് ജൈവികമായി വേർതിരിക്കുന്നതിന് കാരണമാകുന്നു. ആപ്ലിക്കേഷൻ സൈഡിൽ ഡൈനാമിക് SQL ഉപയോഗിക്കുമ്പോൾ, അത്തരമൊരു വേർതിരിവിനായി, ഡാറ്റാബേസ് സോഫ്‌റ്റ്‌വെയർ സംഗ്രഹങ്ങളുടെയും വിവിധ ORM-കളുടെയും അധിക പാളികൾ അവതരിപ്പിക്കുന്നു.

ഫ്ലെക്സിബിൾ ആക്സസ് റൈറ്റ് മാനേജ്മെന്റ്

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

SQL കുത്തിവയ്പ്പിനുള്ള സാധ്യത കുറവാണ്

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

SQL വീണ്ടും ഉപയോഗിക്കുന്നു

സംഭരിച്ച ലെയറിൽ ഡാറ്റയുമായി പ്രവർത്തിക്കുന്നതിന്റെ യുക്തി നടപ്പിലാക്കുന്നതിലൂടെ, SQL കോഡ് വീണ്ടും ഉപയോഗിക്കുന്നതിനുള്ള പരിചിതമായ ശ്രേണിപരമായ മോഡൽ നമുക്ക് ലഭിക്കും.
ഡൈനാമിക് SQL ഉപയോഗിക്കുമ്പോൾ, ചോദ്യം പുനരുപയോഗം ബുദ്ധിമുട്ടാണ്.
ഉദാഹരണത്തിന്, HF അടിസ്ഥാനമാക്കിയുള്ള സിസ്റ്റം എയും ഡൈനാമിക് SQL അടിസ്ഥാനമാക്കിയുള്ള സിസ്റ്റം ബിയും ഉണ്ടാകട്ടെ. രണ്ട് സിസ്റ്റങ്ങൾക്കും ഒരു ഇനത്തിന്റെ വില, get_price ലഭിക്കുന്നതിനുള്ള ഒരു ഫംഗ്‌ഷൻ ഉണ്ട്. A ആണെങ്കിൽ, ഇതൊരു സംഭരിച്ച ഫംഗ്‌ഷനോ കാഴ്‌ചയോ ആണ്; B ആണെങ്കിൽ, JDBC വഴി ഒരു SQL ചോദ്യം എക്‌സിക്യൂട്ട് ചെയ്യുന്ന ഒരു ജാവ നടപടിക്രമം എന്ന് പറയാം. ഒരു ടാസ്ക് ഉണ്ട് - വെയർഹൗസിലെ സാധനങ്ങളുടെ ആകെ വില ലഭിക്കാൻ. A ആണെങ്കിൽ, വെയർഹൗസിലെ സാധനങ്ങളുടെ ഒരു ലിസ്റ്റ് ലഭിക്കുന്ന ഒരു അന്വേഷണത്തിലേക്ക് ഞങ്ങൾ get_price-ൽ നേരിട്ട് ചേരുന്നു (Get_price എന്നത് PostgreSQL പോലെയുള്ള SQL-ലെ ഒരു വ്യൂ അല്ലെങ്കിൽ HF ആണെങ്കിൽ, ഒപ്റ്റിമൈസർ ഇൻലൈൻ അന്വേഷണം വിപുലീകരിക്കുന്നു - അതുവഴി പെട്ടെന്ന് ഒരു ചോദ്യം ലഭിക്കും. തുക കണ്ടെത്തുന്നു).
B ആണെങ്കിൽ, രണ്ട് ഓപ്ഷനുകളുണ്ട് - ഒന്നുകിൽ വെയർഹൗസിലെ സാധനങ്ങൾ തിരഞ്ഞെടുത്ത് കഴ്‌സറിലൂടെ ഓടിച്ചിട്ട് get_price n തവണ വിളിക്കുക (അതായത് മുഴുവൻ തിരഞ്ഞെടുപ്പും ക്ലയന്റിലേക്ക് നെറ്റ്‌വർക്കിലൂടെ കൈമാറണം) അല്ലെങ്കിൽ പുനരുപയോഗം മറന്ന് എഴുതുക get_price-ൽ ഇതിനകം എഴുതിയതിന്റെ തനിപ്പകർപ്പ് നൽകുന്ന ഒരു സബ്ക്വറി. രണ്ട് ഓപ്ഷനുകളും മോശമാണ്.

എളുപ്പമുള്ള SQL ഡീബഗ്ഗിംഗ്

ഡീബഗ്ഗിംഗ് ലളിതമാക്കിയിരിക്കുന്നു (വിജാതീയമായ നടപടിക്രമവുമായി താരതമ്യം ചെയ്യുമ്പോൾ ബാഹ്യ കോഡ് + sql)
ചലനാത്മക SQL (ഏതെങ്കിലും ORM) ഉള്ള സിസ്റ്റങ്ങളിൽ, SQL-ന്റെ ഒരു പ്രശ്നമുള്ള ഭാഗം കണ്ടെത്തുക എന്ന ലളിതമായ ജോലി പോലും ബുദ്ധിമുട്ടായിരിക്കും.
സമാഹാര ഘട്ടത്തിൽ SQL-ന്റെ സെമാന്റിക്, വാക്യഘടന പരിശോധന.
പ്രവർത്തനങ്ങൾ പ്രൊഫൈൽ ചെയ്യാനും തടസ്സങ്ങൾ കണ്ടെത്താനുമുള്ള കഴിവ്.
ഇതിനകം പ്രവർത്തിക്കുന്നതും പ്രവർത്തിക്കുന്നതുമായ സിസ്റ്റം കണ്ടെത്താനുള്ള കഴിവ്.
ഓട്ടോമാറ്റിക് ഡിപൻഡൻസി നിയന്ത്രണം - ഒരു വസ്തുവിന്റെ നിർവചനം മാറ്റുമ്പോൾ, ആശ്രിത എന്റിറ്റികൾ അസാധുവാകും.

ഡാറ്റാബേസിൽ ബിസിനസ് ലോജിക് എഴുതേണ്ടത് എപ്പോഴാണ്?

ഡാറ്റ പ്രോസസ്സിംഗ് വേഗത പ്രധാനമാണെങ്കിൽ

ഡാറ്റ സംഭരിച്ചിരിക്കുന്നിടത്ത് നേരിട്ട് പ്രോസസ്സ് ചെയ്യുന്നത് പലപ്പോഴും പ്രോസസ്സിംഗ് വേഗതയിൽ ഗണ്യമായ വർദ്ധനവ് നൽകുന്നു. ഉദാഹരണത്തിന്, ഡാറ്റാ സ്റ്റോറേജ് ലെവലിലെ അഗ്രഗേഷനുകൾ പോലുള്ള ഒപ്റ്റിമൈസേഷനുകൾ സാധ്യമാകുന്നു - അറേയിൽ നിന്നുള്ള ഡാറ്റ DBMS സെർവറിലേക്ക് പോലും കൈമാറ്റം ചെയ്യപ്പെടുന്നില്ല, ക്ലയന്റിനെക്കുറിച്ച് പരാമർശിക്കേണ്ടതില്ല.

ഡാറ്റ സമഗ്രതയും സ്ഥിരതയും പ്രധാനമാകുമ്പോൾ

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

ഡാറ്റയ്ക്ക് സങ്കീർണ്ണവും എന്നാൽ നന്നായി സ്ഥാപിതവുമായ ഘടനയുണ്ട്

പരന്നതും അയഞ്ഞതുമായ ഘടനകൾക്ക് പലപ്പോഴും ഡിബിഎംഎസുകൾ നൽകുന്ന പ്രോസസ്സിംഗ് ടൂളുകളുടെ സമ്പത്ത് ആവശ്യമില്ല. അവർക്കായി, നിങ്ങൾക്ക് അൾട്രാ-ഫാസ്റ്റ് കീ-വാല്യൂ സ്റ്റോറേജും മെമ്മറി കാഷിംഗും ഉപയോഗിക്കാം.
നിങ്ങളുടെ RDBMS അറിവ് ഉപയോഗപ്രദമാകുമെന്നതിന്റെ വ്യക്തമായ സൂചകമാണ് സങ്കീർണ്ണവും കർശനമായി കപ്പിൾഡ് ശ്രേണിയിലുള്ളതും നെറ്റ്‌വർക്ക് ഘടനകളും!

എപ്പോഴാണ് കോഡ് റിലീസ് ചെയ്യേണ്ടത്?

ബാഹ്യ ഡാറ്റയുമായി പ്രവർത്തിക്കുന്നു

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

സങ്കീർണ്ണമായ അൽഗോരിതങ്ങൾ

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

ഹൈലോഡ്

അൾട്രാ-ഹൈ-ലോഡ് സിസ്റ്റങ്ങളിൽ, ട്രാൻസാക്ഷൻ സീരിയലൈസേഷനും ക്ലസ്റ്റർ സെർവറുകളുടെ സമന്വയത്തിനും ഉള്ള പരമ്പരാഗത സമീപനങ്ങൾ ഒരു തടസ്സമായി മാറുന്നു. നിർദ്ദിഷ്ട ജോലികൾക്കുള്ള സവിശേഷമായ പരിഹാരങ്ങളാൽ അത്തരം സിസ്റ്റങ്ങളുടെ സവിശേഷതയുണ്ട്; സാർവത്രികവും ശക്തവുമായ RDBMS സിസ്റ്റങ്ങൾ സെക്കൻഡിൽ ലക്ഷക്കണക്കിന് സമകാലിക ഇടപാടുകളുടെ ലോഡിന് കീഴിൽ പലപ്പോഴും വളരെ മന്ദഗതിയിലാണ്.

വ്യക്തമായ അൽഗോരിതം ഇല്ലെന്നാണ് നിഗമനം. ഓരോ തവണയും, തീരുമാനം ആർക്കിടെക്‌റ്റുകളുടെയും മാനേജരുടെയും പക്കലായിരിക്കും, കൂടാതെ റേസ് സാഹചര്യങ്ങളും NoSQL ഡാറ്റാ പൊരുത്തക്കേടും, പ്രകടനത്തിലെ പ്രശ്‌നങ്ങൾ, ORM അന്വേഷണങ്ങൾ ഡീബഗ്ഗിംഗ് എന്നിവയിലെ പ്രശ്‌നങ്ങളിൽ പ്രോജക്റ്റ് കുടുങ്ങിപ്പോകുമോ, അല്ലെങ്കിൽ DBMS സ്കെയിൽ ചെയ്യുന്നതിൽ പ്രശ്‌നങ്ങൾ നേരിടുമോ എന്ന് ഇത് നിർണ്ണയിക്കുന്നു. സംഭരിച്ച പ്രവർത്തനങ്ങൾ ഉപയോഗിച്ച്. അതിനാൽ, ശരിയായ തീരുമാനങ്ങൾ എടുക്കുക :)

നിനക്കറിയാമോ, "ഫിസിക്കൽ വാക്വം" എന്ന ആശയത്തിന്റെ തെറ്റ് എന്താണ്?

ഫിസിക്കൽ വാക്വം - ആപേക്ഷിക ക്വാണ്ടം ഫിസിക്‌സിന്റെ ആശയം, അതിലൂടെ അവർ അർത്ഥമാക്കുന്നത് ഒരു ക്വാണ്ടൈസ്ഡ് ഫീൽഡിന്റെ ഏറ്റവും താഴ്ന്ന (ഗ്രൗണ്ട്) ഊർജ്ജ നിലയാണ്, അതിൽ പൂജ്യം, കോണീയ ആക്കം, മറ്റ് ക്വാണ്ടം സംഖ്യകൾ എന്നിവയുണ്ട്. ആപേക്ഷിക സിദ്ധാന്തക്കാർ ഫിസിക്കൽ വാക്വം എന്ന് വിളിക്കുന്നത് ദ്രവ്യം പൂർണ്ണമായും ഇല്ലാത്തതും അളക്കാനാവാത്തതും അതിനാൽ സാങ്കൽപ്പികവുമായ ഒരു ഫീൽഡ് കൊണ്ട് നിറഞ്ഞതുമായ ഒരു ഇടമാണ്. അത്തരമൊരു അവസ്ഥ, ആപേക്ഷികവാദികളുടെ അഭിപ്രായത്തിൽ, ഒരു കേവല ശൂന്യമല്ല, മറിച്ച് ചില ഫാന്റം (വെർച്വൽ) കണങ്ങളാൽ നിറഞ്ഞ ഒരു ഇടമാണ്. ആപേക്ഷിക ക്വാണ്ടം ഫീൽഡ് സിദ്ധാന്തം പറയുന്നത്, ഹൈസൻബെർഗ് അനിശ്ചിതത്വ തത്വത്തിന് അനുസൃതമായി, വെർച്വൽ, അതായത്, പ്രത്യക്ഷമായ (ആർക്ക്?) കണികകൾ സ്ഥിരമായി ജനിച്ച് ഭൌതിക ശൂന്യതയിൽ അപ്രത്യക്ഷമാകുന്നു: സീറോ-പോയിന്റ് ഫീൽഡ് ആന്ദോളനങ്ങൾ സംഭവിക്കുന്നു. ഫിസിക്കൽ വാക്വത്തിന്റെ വെർച്വൽ കണങ്ങൾക്ക്, അതിനാൽ തന്നെ, നിർവചനം അനുസരിച്ച്, ഒരു റഫറൻസ് സിസ്റ്റം ഇല്ല, അല്ലാത്തപക്ഷം ആപേക്ഷികതാ സിദ്ധാന്തത്തെ അടിസ്ഥാനമാക്കിയുള്ള ഐൻ‌സ്റ്റൈന്റെ ആപേക്ഷികതാ തത്വം ലംഘിക്കപ്പെടും (അതായത്, റഫറൻസോടുകൂടിയ ഒരു കേവല അളവെടുപ്പ് സിസ്റ്റം ഫിസിക്കൽ വാക്വം കണികകൾക്ക് സാധ്യമാകും, അത് SRT അടിസ്ഥാനമാക്കിയുള്ള ആപേക്ഷികതാ തത്വത്തെ വ്യക്തമായി നിരാകരിക്കും). അതിനാൽ, ഫിസിക്കൽ വാക്വവും അതിന്റെ കണങ്ങളും ഭൗതിക ലോകത്തിന്റെ ഘടകങ്ങളല്ല, മറിച്ച് ആപേക്ഷികതാ സിദ്ധാന്തത്തിന്റെ ഘടകങ്ങൾ മാത്രമാണ്, അവ യഥാർത്ഥ ലോകത്ത് നിലവിലില്ല, മറിച്ച് ആപേക്ഷിക സൂത്രവാക്യങ്ങളിൽ മാത്രം, കാര്യകാരണ തത്വം ലംഘിക്കുമ്പോൾ (അവ പ്രത്യക്ഷപ്പെടുകയും കാരണമില്ലാതെ അപ്രത്യക്ഷമാകും), വസ്തുനിഷ്ഠതയുടെ തത്വം (വിർച്വൽ കണങ്ങളെ സൈദ്ധാന്തികന്റെ ആഗ്രഹത്തെ ആശ്രയിച്ച്, നിലവിലുള്ളതോ അല്ലാത്തതോ ആയ ഒന്നുകിൽ പരിഗണിക്കാം), വസ്തുതാപരമായ അളവുകോലിൻറെ തത്വം (നിരീക്ഷണമല്ല, അവരുടേതായ ISO ഇല്ല).

ഒന്നോ അതിലധികമോ ഭൗതികശാസ്ത്രജ്ഞൻ "ഫിസിക്കൽ വാക്വം" എന്ന ആശയം ഉപയോഗിക്കുമ്പോൾ, അയാൾ ഒന്നുകിൽ ഈ പദത്തിന്റെ അസംബന്ധം മനസ്സിലാക്കുന്നില്ല, അല്ലെങ്കിൽ ആപേക്ഷിക സിദ്ധാന്തത്തിന്റെ മറഞ്ഞിരിക്കുന്നതോ പരസ്യമായതോ ആയ അനുയായിയായതിനാൽ വെറുപ്പാണ്.

ഈ ആശയത്തിന്റെ അസംബന്ധം മനസ്സിലാക്കാനുള്ള ഏറ്റവും എളുപ്പ മാർഗം അതിന്റെ സംഭവത്തിന്റെ ഉത്ഭവത്തിലേക്ക് തിരിയുക എന്നതാണ്. 1930-കളിൽ പോൾ ഡിറക് ആണ് ഇത് ജനിച്ചത്, മഹാനായ ഗണിതശാസ്ത്രജ്ഞനും എന്നാൽ ശരാശരി ഭൗതികശാസ്ത്രജ്ഞനുമായ ഹെൻറി പോയിൻകാറെ ചെയ്തതുപോലെ ഈഥറിനെ അതിന്റെ ശുദ്ധമായ രൂപത്തിൽ നിഷേധിക്കുന്നത് ഇനി സാധ്യമല്ലെന്ന് വ്യക്തമായപ്പോൾ. ഇതിന് വിരുദ്ധമായ നിരവധി വസ്തുതകളുണ്ട്.

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

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

സംഭരിച്ച നടപടിക്രമങ്ങളുടെ തരങ്ങൾ

SQL സെർവറിന് നിരവധി തരം സംഭരിച്ച നടപടിക്രമങ്ങളുണ്ട്.

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

ഇഷ്‌ടാനുസൃതമായി സംഭരിച്ച നടപടിക്രമങ്ങൾ ചില പ്രവർത്തനങ്ങൾ നടപ്പിലാക്കുന്നു. സംഭരിച്ച നടപടിക്രമങ്ങൾ ഒരു പൂർണ്ണമായ ഡാറ്റാബേസ് ഒബ്ജക്റ്റാണ്. തൽഫലമായി, സംഭരിച്ച ഓരോ നടപടിക്രമവും ഒരു നിർദ്ദിഷ്ട ഡാറ്റാബേസിൽ സ്ഥിതിചെയ്യുന്നു, അവിടെ അത് നടപ്പിലാക്കുന്നു.

താൽക്കാലികമായി സംഭരിച്ച നടപടിക്രമങ്ങൾ കുറച്ച് സമയത്തേക്ക് മാത്രമേ നിലനിൽക്കൂ, അതിനുശേഷം അവ സെർവർ സ്വയമേവ നശിപ്പിക്കപ്പെടും. അവ പ്രാദേശികവും ആഗോളവുമായി തിരിച്ചിരിക്കുന്നു. പ്രാദേശിക താൽക്കാലിക സംഭരിച്ച നടപടിക്രമങ്ങൾ സൃഷ്ടിക്കപ്പെട്ട കണക്ഷനിൽ നിന്ന് മാത്രമേ വിളിക്കാൻ കഴിയൂ. അത്തരമൊരു നടപടിക്രമം സൃഷ്ടിക്കുമ്പോൾ, ഒരൊറ്റ # പ്രതീകത്തിൽ ആരംഭിക്കുന്ന ഒരു പേര് നിങ്ങൾ നൽകണം. എല്ലാ താൽക്കാലിക വസ്തുക്കളെയും പോലെ, ഉപയോക്താവ് വിച്ഛേദിക്കുമ്പോഴോ സെർവർ പുനരാരംഭിക്കുകയോ നിർത്തുകയോ ചെയ്യുമ്പോൾ ഇത്തരത്തിലുള്ള സംഭരിച്ച നടപടിക്രമങ്ങൾ സ്വയമേവ ഇല്ലാതാക്കപ്പെടും. സമാന നടപടിക്രമമുള്ള ഒരു സെർവറിൽ നിന്നുള്ള ഏത് കണക്ഷനിലും ആഗോള താൽക്കാലിക സംഭരിച്ച നടപടിക്രമങ്ങൾ ലഭ്യമാണ്. ഇത് നിർവചിക്കുന്നതിന്, ## എന്ന അക്ഷരങ്ങളിൽ തുടങ്ങുന്ന പേര് നൽകിയാൽ മതി. സെർവർ പുനരാരംഭിക്കുമ്പോഴോ നിർത്തുമ്പോഴോ അല്ലെങ്കിൽ അവ സൃഷ്ടിച്ച സന്ദർഭത്തിലെ കണക്ഷൻ അടയ്ക്കുമ്പോഴോ ഈ നടപടിക്രമങ്ങൾ ഇല്ലാതാക്കപ്പെടും.

ട്രിഗറുകൾ

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

ട്രിഗർഒരു കംപൈൽ ചെയ്ത SQL നടപടിക്രമമാണ്, ഇതിന്റെ നിർവ്വഹണം റിലേഷണൽ ഡാറ്റാബേസിനുള്ളിൽ ചില ഇവന്റുകൾ സംഭവിക്കുന്നത് കൊണ്ട് വ്യവസ്ഥ ചെയ്യുന്നു. ട്രിഗറുകളുടെ ഉപയോഗം, മിക്കവാറും, ഡാറ്റാബേസ് ഉപയോക്താക്കൾക്ക് വളരെ സൗകര്യപ്രദമാണ്. എന്നിരുന്നാലും, അവയുടെ ഉപയോഗം പലപ്പോഴും I/O പ്രവർത്തനങ്ങൾക്കായുള്ള അധിക വിഭവ ചെലവുകൾ ഉൾക്കൊള്ളുന്നു. സംഭരിച്ച നടപടിക്രമങ്ങളോ ആപ്ലിക്കേഷൻ പ്രോഗ്രാമുകളോ ഉപയോഗിച്ച് സമാന ഫലങ്ങൾ (വളരെ കുറഞ്ഞ ഓവർഹെഡിൽ) നേടാനാകുമ്പോൾ, ട്രിഗറുകളുടെ ഉപയോഗം പ്രായോഗികമല്ല.

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

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

സൃഷ്ടിക്കുന്നു ട്രിഗർഡാറ്റാബേസ് ഉടമ മാത്രം. പട്ടികകളുടെ ഘടനയിൽ ആകസ്മികമായ മാറ്റങ്ങൾ, അവയുമായി മറ്റ് വസ്തുക്കളെ ബന്ധിപ്പിക്കുന്നതിനുള്ള വഴികൾ മുതലായവ ഒഴിവാക്കാൻ ഈ നിയന്ത്രണം നിങ്ങളെ അനുവദിക്കുന്നു.

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

ഒരു സാധാരണ സബ്റൂട്ടിനിൽ നിന്ന് വ്യത്യസ്തമായി, ട്രിഗർഒരു ട്രിഗർ ഇവന്റ് സംഭവിക്കുമ്പോഴെല്ലാം പരോക്ഷമായി നടപ്പിലാക്കുന്നു, അതിന് വാദങ്ങളൊന്നുമില്ല. ഇത് സജീവമാക്കുന്നത് ചിലപ്പോൾ ട്രിഗർ ഫയറിംഗ് എന്ന് വിളിക്കുന്നു. ട്രിഗറുകൾ ഉപയോഗിച്ച്, ഇനിപ്പറയുന്ന ലക്ഷ്യങ്ങൾ കൈവരിക്കുന്നു:

നൽകിയ ഡാറ്റയുടെ കൃത്യത സ്ഥിരീകരിക്കുകയും ഒരു പട്ടികയിൽ സജ്ജീകരിച്ചിരിക്കുന്ന സമഗ്രത നിയന്ത്രണങ്ങൾ ഉപയോഗിച്ച് നിലനിർത്താൻ ബുദ്ധിമുട്ടുള്ള, അസാധ്യമല്ലെങ്കിൽ, സങ്കീർണ്ണമായ ഡാറ്റ സമഗ്രത നിയന്ത്രണങ്ങൾ നടപ്പിലാക്കുകയും ചെയ്യുക;

ഒരു പ്രത്യേക രീതിയിൽ നടപ്പിലാക്കിയ ഒരു പട്ടിക അപ്‌ഡേറ്റ് ചെയ്യുമ്പോൾ ചില പ്രവർത്തനങ്ങൾ ചെയ്യാൻ നിങ്ങളെ ഓർമ്മിപ്പിക്കുന്ന മുന്നറിയിപ്പുകൾ നൽകുന്നു;

വരുത്തിയ മാറ്റങ്ങളെയും അവ നിർവഹിച്ച വ്യക്തികളെയും കുറിച്ചുള്ള വിവരങ്ങൾ രേഖപ്പെടുത്തിക്കൊണ്ട് ഓഡിറ്റ് വിവരങ്ങളുടെ ശേഖരണം;

അനുകരണ പിന്തുണ.

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

<Определение_триггера>::=

ട്രിഗർ ട്രിഗർ_നാമം സൃഷ്‌ടിക്കുക

മുമ്പ് | ശേഷം<триггерное_событие>

ഓൺ<имя_таблицы>

<список_старых_или_новых_псевдонимов>]

<тело_триггера>

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

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

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

ട്രിഗർനിലവിലെ ഡാറ്റാബേസിൽ മാത്രമേ സൃഷ്ടിക്കാൻ കഴിയൂ, എന്നാൽ റിമോട്ട് സെർവറിൽ സ്ഥിതി ചെയ്യുന്നവ ഉൾപ്പെടെ, ട്രിഗറിനുള്ളിൽ മറ്റ് ഡാറ്റാബേസുകൾ ആക്സസ് ചെയ്യാൻ കഴിയും.

സംഭരിച്ച നടപടിക്രമങ്ങൾ

ബിസിനസ് ലോജിക് നടപ്പിലാക്കുന്നതിനായി ഇന്റർബേസ് ഡാറ്റാബേസ് ആപ്ലിക്കേഷനുകളുടെ ഡെവലപ്പർമാർക്ക് വാഗ്ദാനം ചെയ്യുന്ന ഏറ്റവും ശക്തമായ ടൂളുകളിൽ ഒന്നാണ് ഈ അധ്യായത്തിലെ വിഷയം. സംഭരിച്ച നടപടിക്രമങ്ങൾ (ഇംഗ്ലീഷ്, സ്റ്റൈഡ് നടപടിക്രമങ്ങൾ) ഡാറ്റാബേസ് തലത്തിൽ ആപ്ലിക്കേഷൻ ലോജിക്കിന്റെ ഒരു പ്രധാന ഭാഗം നടപ്പിലാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. മുഴുവൻ ആപ്ലിക്കേഷന്റെയും പ്രകടനം, ഡാറ്റാ പ്രോസസ്സിംഗ് കേന്ദ്രീകൃതമാക്കുക, അസൈൻ ചെയ്ത ജോലികൾ പൂർത്തിയാക്കാൻ ആവശ്യമായ കോഡിന്റെ അളവ് കുറയ്ക്കുക, സംഭരിച്ച നടപടിക്രമങ്ങൾ ഉപയോഗിക്കാതെ വളരെ സങ്കീർണ്ണമായ ഏതൊരു ഡാറ്റാബേസ് ആപ്ലിക്കേഷനും ചെയ്യാൻ കഴിയില്ല.
മിക്ക റിലേഷണൽ ഡിബിഎംഎസുകൾക്കും പൊതുവായ, സംഭരിച്ച നടപടിക്രമങ്ങൾ ഉപയോഗിക്കുന്നതിന്റെ ഈ അറിയപ്പെടുന്ന നേട്ടങ്ങൾക്ക് പുറമേ, ഇന്റർബേസ് സംഭരിച്ച നടപടിക്രമങ്ങൾക്ക് ഏതാണ്ട് പൂർണ്ണമായ ഡാറ്റാ സെറ്റുകളായി പ്രവർത്തിക്കാൻ കഴിയും, ഇത് സാധാരണ SQL അന്വേഷണങ്ങളിൽ അവ തിരികെ നൽകുന്ന ഫലങ്ങൾ ഉപയോഗിക്കാൻ അനുവദിക്കുന്നു.
മിക്കപ്പോഴും, പുതിയ ഡെവലപ്പർമാർ സംഭരിച്ച നടപടിക്രമങ്ങളെ ഡാറ്റാബേസിനുള്ളിൽ എന്തെങ്കിലും ചെയ്യുന്ന നിർദ്ദിഷ്ട SQL അന്വേഷണങ്ങളുടെ ഒരു കൂട്ടം മാത്രമായി സങ്കൽപ്പിക്കുന്നു, കൂടാതെ സംഭരിച്ച നടപടിക്രമങ്ങളുമായി പ്രവർത്തിക്കുന്നത് ഒരു ക്ലയന്റ് ആപ്ലിക്കേഷനിൽ അതേ പ്രവർത്തനം നടപ്പിലാക്കുന്നതിനേക്കാൾ വളരെ ബുദ്ധിമുട്ടാണ് എന്ന അഭിപ്രായമുണ്ട്. ലെവൽ ഭാഷ
അപ്പോൾ ഇന്റർബേസിൽ സംഭരിച്ച നടപടിക്രമങ്ങൾ എന്തൊക്കെയാണ്?
ഒരു സംഭരിച്ച നടപടിക്രമം (SP) ഡാറ്റാബേസ് മെറ്റാഡാറ്റയുടെ ഭാഗമാണ്, ഇത് ഇന്റർബേസിന്റെ ആന്തരിക പ്രാതിനിധ്യത്തിലേക്ക് സമാഹരിച്ച ഒരു സബ്റൂട്ടീനാണ്, ഒരു പ്രത്യേക ഭാഷയിൽ എഴുതിയിരിക്കുന്നു, ഇതിന്റെ കംപൈലർ InteiBase സെർവറിന്റെ കേന്ദ്രത്തിൽ നിർമ്മിച്ചിരിക്കുന്നു.
ക്ലയന്റ് ആപ്ലിക്കേഷനുകളിൽ നിന്നും ട്രിഗറുകളിൽ നിന്നും മറ്റ് സംഭരിച്ച നടപടിക്രമങ്ങളിൽ നിന്നും ഒരു സംഭരിച്ച നടപടിക്രമം വിളിക്കാം. സംഭരിച്ച നടപടിക്രമം സെർവർ പ്രോസസിനുള്ളിൽ പ്രവർത്തിക്കുന്നു, കൂടാതെ ഡാറ്റാബേസിൽ ഡാറ്റ കൈകാര്യം ചെയ്യാനും അതുപോലെ തന്നെ അതിന്റെ നിർവ്വഹണ ഫലങ്ങൾ അതിനെ വിളിച്ച ക്ലയന്റിലേക്ക് തിരികെ നൽകാനും കഴിയും (അതായത് ട്രിഗർ, എച്ച്പി, ആപ്ലിക്കേഷൻ)
HP-യിൽ അന്തർലീനമായ ശക്തമായ കഴിവുകളുടെ അടിസ്ഥാനം ഒരു പ്രൊസീജറൽ പ്രോഗ്രാമിംഗ് ഭാഷയാണ്, അതിൽ INSERT, UPDATE, SELECT എന്നിങ്ങനെയുള്ള സാധാരണ SQL-ന്റെ പരിഷ്‌ക്കരിച്ച രണ്ട് പ്രസ്താവനകളും ശാഖകളും ലൂപ്പുകളും സംഘടിപ്പിക്കുന്നതിനുള്ള ഉപകരണങ്ങളും (IF, WHILE) ഉൾപ്പെടുന്നു. പിശക് കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഉപകരണങ്ങളും അസാധാരണമായ സാഹചര്യങ്ങളും സംഭരിച്ച നടപടിക്രമങ്ങളുടെ ഭാഷ, ഡാറ്റയുമായി പ്രവർത്തിക്കുന്നതിന് സങ്കീർണ്ണമായ അൽഗോരിതങ്ങൾ നടപ്പിലാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു, കൂടാതെ റിലേഷണൽ ഡാറ്റയുമായി പ്രവർത്തിക്കുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നതിനാൽ, പരമ്പരാഗത ഭാഷകളിലെ സമാന നടപടിക്രമങ്ങളേക്കാൾ വളരെ ഒതുക്കമുള്ളതാണ് HP.
നിരവധി സവിശേഷതകളും പരിമിതികളും ഒഴികെ, ട്രിഗറുകൾക്കും ഒരേ പ്രോഗ്രാമിംഗ് ഭാഷയാണ് ഉപയോഗിക്കുന്നത് എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. ട്രിഗറുകളിൽ ഉപയോഗിക്കുന്ന ഭാഷയുടെ ഉപവിഭാഗവും HP ഭാഷയും തമ്മിലുള്ള വ്യത്യാസങ്ങൾ "ട്രിഗറുകൾ" (ഭാഗം 1) എന്ന അധ്യായത്തിൽ വിശദമായി ചർച്ചചെയ്യുന്നു.

ലളിതമായ സംഭരിച്ച നടപടിക്രമത്തിന്റെ ഉദാഹരണം

നിങ്ങളുടെ ആദ്യത്തെ സംഭരിച്ച നടപടിക്രമം സൃഷ്‌ടിക്കാനും സംഭരിച്ച നടപടിക്രമങ്ങൾ സൃഷ്‌ടിക്കുന്ന പ്രക്രിയ പഠിക്കാൻ ഒരു ഉദാഹരണമായി ഉപയോഗിക്കാനുമുള്ള സമയമാണിത്. എന്നാൽ ആദ്യം, സംഭരിച്ച നടപടിക്രമങ്ങൾ ഉപയോഗിച്ച് എങ്ങനെ പ്രവർത്തിക്കാം എന്നതിനെക്കുറിച്ച് കുറച്ച് വാക്കുകൾ പറയണം, സംഭരിച്ച നടപടിക്രമങ്ങൾ വികസിപ്പിക്കുന്നതിനും ഡീബഗ്ഗിംഗ് ചെയ്യുന്നതിനുമുള്ള വളരെ മോശം നിലവാരമുള്ള ഉപകരണങ്ങൾക്ക് അവ്യക്തവും അസൗകര്യമുള്ളതുമായ ഉപകരണമെന്ന നിലയിൽ HP അതിന്റെ പ്രശസ്തിക്ക് കടപ്പെട്ടിരിക്കുന്നു എന്നതാണ് വസ്തുത. ഇൻറർബേസ് ഡോക്യുമെന്റേഷൻ, എച്ച്പി ടെക്‌സ്‌റ്റ് അടങ്ങിയ എസ്‌ക്യുഎൽ സ്‌ക്രിപ്റ്റ് ഫയലുകൾ ഉപയോഗിച്ച് പ്രൊസീജറുകൾ സൃഷ്‌ടിക്കാൻ ശുപാർശ ചെയ്യുന്നു, അവ isql ഇന്റർപ്രെറ്ററിലേക്ക് ഇൻപുട്ടായി വിതരണം ചെയ്യുന്നു, അങ്ങനെ BLR-ൽ നടപടിക്രമത്തിന്റെ ടെക്‌സ്‌റ്റ് കംപൈൽ ചെയ്യുന്ന ഘട്ടത്തിൽ HP സൃഷ്‌ടിക്കുകയും പരിഷ്‌ക്കരിക്കുകയും ചെയ്യുന്നു. BLR, "ഇന്റർബേസ് ഡാറ്റാബേസ് ഘടന" (ഭാഗം 4)) എന്ന അധ്യായം കാണുക, ഒരു പിശക് സംഭവിക്കുകയാണെങ്കിൽ, ഈ പിശക് സംഭവിച്ച SQL സ്ക്രിപ്റ്റ് ഫയലിന്റെ ഏത് ലൈനിനെക്കുറിച്ചുള്ള ഒരു സന്ദേശം isql പ്രദർശിപ്പിക്കും. തെറ്റ് തിരുത്തി വീണ്ടും ആവർത്തിക്കുക. വേരിയബിളുകളുടെ ഇന്റർമീഡിയറ്റ് മൂല്യങ്ങൾ കാണാനുള്ള കഴിവുള്ള വാക്കിന്റെ ആധുനിക അർത്ഥത്തിൽ ഡീബഗ്ഗിംഗിനെക്കുറിച്ച്, അതായത് എക്സിക്യൂഷൻ ട്രെയ്‌സിംഗിനെക്കുറിച്ച് ഒരു സംസാരവുമില്ല. വ്യക്തമായും, ഈ സമീപനം ഡവലപ്പറുടെ ദൃഷ്ടിയിൽ സംഭരിച്ച നടപടിക്രമങ്ങളുടെ ആകർഷണീയതയുടെ വളർച്ചയ്ക്ക് കാരണമാകില്ല.
എന്നിരുന്നാലും, HP വികസനത്തിനായുള്ള സ്റ്റാൻഡേർഡ് മിനിമലിസ്റ്റ് സമീപനത്തിന് പുറമേ<_\ществ\ют также инструменты сторонних разработчиков, которые делают работу с хранимыми процедурами весьма удобной Большинство универсальных продуктов для работы с InterBase, перечисленных в приложении "Инструменты администратора и разработчика InterBase", предоставляют удобный инструментарий для работы с ХП. Мы рекомендуем обязательно воспользоваться одним из этих инструментов для работы с хранимыми процедурами и изложение материала будем вести в предположении, что у вас имеется удобный GUI-инструмент, избавляющий от написания традиционных SQL-скриптов
സംഭരിച്ച നടപടിക്രമങ്ങളുടെ വാക്യഘടന ഇനിപ്പറയുന്ന രീതിയിൽ വിവരിച്ചിരിക്കുന്നു:

നടപടിക്രമത്തിന്റെ പേര് സൃഷ്ടിക്കുക
[ (പാരം ഡാറ്റാടൈപ്പ് [, പാരം ഡാറ്റാടൈപ്പ് ...]) ]
)]
എ.എസ്
;
< procedure_body> = []
< block>
< vanable_declaration_list> =
വേരിയബിൾ var ഡാറ്റാടൈപ്പ് പ്രഖ്യാപിക്കുക;

=
ആരംഭിക്കുന്നു
< compound_statement>
[< compound_statement> ...]
അവസാനിക്കുന്നു
< compound_statement> = (പ്രസ്താവന;)

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

SP_Add (first_arg DOUBLE PRECISION,
second_arg DOUBLE PRECISION)
റിട്ടേണുകൾ (ഫലം ഇരട്ട പ്രിസിഷൻ)
എ.എസ്
ആരംഭിക്കുന്നു
ഫലം=first_arg+second_arg;
സസ്പെൻഡ് ചെയ്യുക;
അവസാനിക്കുന്നു

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, എല്ലാം ലളിതമാണ്: CREATE PROCEDURE കമാൻഡിന് ശേഷം, പുതുതായി സൃഷ്ടിച്ച നടപടിക്രമത്തിന്റെ പേര് സൂചിപ്പിച്ചിരിക്കുന്നു (ഇത് ഡാറ്റാബേസിൽ അദ്വിതീയമായിരിക്കണം) - ഈ സാഹചര്യത്തിൽ SP_Add, തുടർന്ന് HP ഇൻപുട്ട് പാരാമീറ്ററുകൾ - first_arg, second_arg - ഇവയാണ് പരാൻതീസിസിൽ ലിസ്റ്റുചെയ്‌തു, കോമകളാൽ വേർതിരിച്ച് അവയുടെ തരങ്ങളെ സൂചിപ്പിക്കുന്നു.
ഇൻപുട്ട് പാരാമീറ്ററുകളുടെ ലിസ്റ്റ് ക്രിയേറ്റ് പ്രൊസീഡർ സ്റ്റേറ്റ്‌മെന്റിന്റെ ഒരു ഓപ്‌ഷണൽ ഭാഗമാണ് - നടപടിക്രമത്തിന്റെ ബോഡിക്കുള്ളിലെ പട്ടികകളിലേക്കുള്ള അന്വേഷണങ്ങളിലൂടെ ഒരു നടപടിക്രമത്തിന് അതിന്റെ പ്രവർത്തനത്തിനുള്ള എല്ലാ ഡാറ്റയും ലഭിക്കുന്ന സന്ദർഭങ്ങളുണ്ട്.

സംഭരിച്ച നടപടിക്രമങ്ങൾ ഏതെങ്കിലും സ്കെയിലർ ഡാറ്റ തരങ്ങൾ ഉപയോഗിക്കുന്നു InteiBase ഇത് അറേകളുടെയും ഉപയോക്തൃ-നിർവചിച്ച തരങ്ങളുടെയും ഉപയോഗം അനുവദിക്കുന്നില്ല - ഡൊമെയ്‌നുകൾ

അടുത്തതായി റിട്ടേൺസ് കീവേഡ് വരുന്നു, അതിനുശേഷം മടങ്ങിയ പാരാമീറ്ററുകൾ പരാൻതീസിസിൽ പട്ടികപ്പെടുത്തിയിരിക്കുന്നു, അവയുടെ തരങ്ങളെ സൂചിപ്പിക്കുന്നു - ഈ സാഹചര്യത്തിൽ, ഒന്ന് മാത്രം - ഫലം.
നടപടിക്രമം പാരാമീറ്ററുകൾ നൽകേണ്ടതില്ലെങ്കിൽ, റിട്ടേൺസ് എന്ന വാക്കും തിരികെ നൽകിയ പാരാമീറ്ററുകളുടെ ലിസ്റ്റും കാണുന്നില്ല.
RETURNSQ-ന് ശേഷം AS എന്ന കീവേഡ് വ്യക്തമാക്കിയിരിക്കുന്നു. AS എന്ന കീവേഡ് പോകുന്നതിന് മുമ്പ് തലക്കെട്ട്,പിന്നെ അതിനു ശേഷം - ടെക്കോനടപടിക്രമങ്ങൾ.
സംഭരിച്ച നടപടിക്രമത്തിന്റെ ബോഡി അതിന്റെ ആന്തരിക (പ്രാദേശിക) വേരിയബിളുകളുടെ വിവരണങ്ങളുടെ ഒരു പട്ടികയാണ് (എന്തെങ്കിലും ഉണ്ടെങ്കിൽ, ഞങ്ങൾ അവയെ കൂടുതൽ വിശദമായി ചുവടെ നോക്കും), ഒരു അർദ്ധവിരാമം (;), കൂടാതെ ഓപ്പറേറ്റർ ബ്രാക്കറ്റുകളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന പ്രസ്താവനകളുടെ ഒരു ബ്ലോക്കും ആരംഭിക്കുക. ഈ സാഹചര്യത്തിൽ, HP യുടെ ബോഡി വളരെ ലളിതമാണ് - രണ്ട് ഇൻപുട്ട് ആർഗ്യുമെന്റുകൾ ചേർത്ത് അവയുടെ ഫലം ഔട്ട്പുട്ടിലേക്ക് അസൈൻ ചെയ്യാൻ ഞങ്ങൾ ആവശ്യപ്പെടുന്നു, തുടർന്ന് SUSPEND കമാൻഡ് വിളിക്കുക. കുറച്ച് കഴിഞ്ഞ് ഈ കമാൻഡിന്റെ പ്രവർത്തനത്തിന്റെ സാരാംശം ഞങ്ങൾ വിശദീകരിക്കും, എന്നാൽ സംഭരിച്ച നടപടിക്രമം എവിടെ നിന്ന് വിളിച്ചോ അവിടെ നിന്ന് റിട്ടേൺ പാരാമീറ്ററുകൾ കൈമാറേണ്ടത് ആവശ്യമാണെന്ന് ഞങ്ങൾ ഇപ്പോൾ ശ്രദ്ധിക്കും.

സംഭരിച്ച നടപടിക്രമങ്ങളിലെ ഡിലിമിറ്ററുകൾ

ഒരു നടപടിക്രമത്തിനുള്ളിലെ ഒരു പ്രസ്താവന ഒരു അർദ്ധവിരാമത്തിൽ അവസാനിക്കുന്നു (;). നിങ്ങൾക്കറിയാവുന്നതുപോലെ, അർദ്ധവിരാമം SQL-ലെ ഒരു സ്റ്റാൻഡേർഡ് കമാൻഡ് സെപ്പറേറ്ററാണ് - ഇത് കമാൻഡ് ടെക്സ്റ്റ് പൂർണ്ണമായി നൽകിയിട്ടുണ്ടെന്നും അത് പ്രോസസ്സ് ചെയ്യാൻ ആരംഭിക്കണമെന്നും SQL വ്യാഖ്യാതാവിനുള്ള ഒരു സിഗ്നലാണ്. SQL വ്യാഖ്യാതാവ് HP യുടെ മധ്യത്തിൽ ഒരു അർദ്ധവിരാമം കണ്ടെത്തിയാൽ, കമാൻഡ് പൂർണ്ണമായി നൽകിയെന്നും സംഭരിച്ച നടപടിക്രമത്തിന്റെ ഒരു ഭാഗം നടപ്പിലാക്കാൻ ശ്രമിക്കുമെന്നും അത് അനുമാനിക്കുമോ? ഈ അനുമാനം അർഹതയില്ലാത്തതല്ല. തീർച്ചയായും, മുകളിലുള്ള ഉദാഹരണം എഴുതാൻ നിങ്ങൾ ഒരു ഫയൽ സൃഷ്‌ടിച്ചാൽ, ഡാറ്റാബേസിൽ നിന്ന് ഒരു കണക്ഷൻ കമാൻഡ് ചേർക്കുകയും isql ഇന്റർപ്രെറ്റർ ഉപയോഗിച്ച് ഈ SQL സ്‌ക്രിപ്റ്റ് എക്‌സിക്യൂട്ട് ചെയ്യാൻ ശ്രമിക്കുകയും ചെയ്താൽ, വ്യാഖ്യാതാവിന്റെ അഭിപ്രായത്തിൽ അവസാനിക്കുന്നത് അപ്രതീക്ഷിതമായതിനാൽ ഒരു പിശക് ലഭിക്കും. സംഭരിച്ച നടപടിക്രമം സൃഷ്ടിക്കുന്നതിനുള്ള കമാൻഡിന്റെ. പ്രത്യേക ഇന്റർബേസ് ഡെവലപ്പർ ടൂളുകൾ ഉപയോഗിക്കാതെ, SQL സ്‌ക്രിപ്റ്റ് ഫയലുകൾ ഉപയോഗിച്ച് നിങ്ങൾ സംഭരിച്ച നടപടിക്രമങ്ങൾ സൃഷ്‌ടിക്കുന്നുവെങ്കിൽ, ഓരോ HP സൃഷ്‌ടി കമാൻഡിനും മുമ്പായി (ട്രിഗറുകൾക്കും ഇത് ബാധകമാണ്) നിങ്ങൾ സ്‌ക്രിപ്റ്റ് കമാൻഡ് സെപ്പറേറ്ററിനെ അർദ്ധവിരാമമല്ലാത്ത മറ്റൊരു പ്രതീകത്തിലേക്ക് മാറ്റേണ്ടതുണ്ട്, കൂടാതെ HP ടെക്‌സ്‌റ്റിന് ശേഷം അത് പുനഃസ്ഥാപിക്കാൻ. SQL ക്ലോസ് സെപ്പറേറ്റർ മാറ്റുന്ന isql കമാൻഡ് ഇതുപോലെ കാണപ്പെടുന്നു:

നിബന്ധന സജ്ജീകരിക്കുക

ഒരു സംഭരിച്ച നടപടിക്രമം സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു സാധാരണ കേസിൽ, ഇത് ഇതുപോലെ കാണപ്പെടുന്നു:

സെറ്റ് ടേം^;
ചില_നടപടിക്രമം സൃഷ്ടിക്കുക
... . .
അവസാനിക്കുന്നു
^
സെറ്റ് ടേം ;^

ഒരു സംഭരിച്ച നടപടിക്രമം വിളിക്കുന്നു

എന്നാൽ നമുക്ക് നമ്മുടെ സംഭരിച്ച നടപടിക്രമത്തിലേക്ക് മടങ്ങാം. ഇപ്പോൾ അത് സൃഷ്ടിച്ചു, നിങ്ങൾ എങ്ങനെയെങ്കിലും അതിനെ വിളിക്കേണ്ടതുണ്ട്, അതിലേക്ക് പാരാമീറ്ററുകൾ കൈമാറുകയും ഫലങ്ങൾ തിരികെ നേടുകയും വേണം. ഇത് ചെയ്യാൻ വളരെ എളുപ്പമാണ് - ഇതുപോലെ ഒരു SQL അന്വേഷണം എഴുതുക:

തിരഞ്ഞെടുക്കുക *
Sp_add-ൽ നിന്ന് (181.35, 23.09)

ഈ അന്വേഷണം ഞങ്ങൾക്ക് ഒരു ഫല ഫീൽഡ് മാത്രമുള്ള ഒരു വരി തിരികെ നൽകും, അതിൽ 181.35, 23.09 എന്നീ സംഖ്യകളുടെ ആകെത്തുക, അതായത് 204.44.
അതിനാൽ, ക്ലയന്റ് പ്രോഗ്രാമുകളിലും മറ്റ് HP അല്ലെങ്കിൽ ട്രിഗറുകളിലും എക്സിക്യൂട്ട് ചെയ്യുന്ന സാധാരണ SQL അന്വേഷണങ്ങളിൽ ഞങ്ങളുടെ നടപടിക്രമം ഉപയോഗിക്കാം. സംഭരിച്ച നടപടിക്രമത്തിന്റെ അവസാനം SUSPEND കമാൻഡ് ഉപയോഗിച്ചാണ് ഞങ്ങളുടെ നടപടിക്രമത്തിന്റെ ഈ ഉപയോഗം സാധ്യമാക്കുന്നത്.
ഇന്റർബേസിൽ (അതിന്റെ എല്ലാ ക്ലോണുകളിലും) രണ്ട് തരം സംഭരിച്ച നടപടിക്രമങ്ങളുണ്ട് എന്നതാണ് വസ്തുത: തിരഞ്ഞെടുക്കാവുന്ന നടപടിക്രമങ്ങളും എക്സിക്യൂട്ടബിൾ നടപടിക്രമങ്ങളും. ഈ രണ്ട് തരം HP കളുടെ പ്രവർത്തനത്തിലെ വ്യത്യാസം എന്തെന്നാൽ, സാംപ്ലിംഗ് നടപടിക്രമങ്ങൾ സാധാരണയായി നിരവധി സെറ്റ് ഔട്ട്‌പുട്ട് പാരാമീറ്ററുകൾ നൽകുന്നു, ഒരു കൂട്ടം ഡാറ്റ പോലെ കാണപ്പെടുന്ന വരി വരിയായി ഗ്രൂപ്പുചെയ്‌തിരിക്കുന്നു, കൂടാതെ എക്‌സിക്യൂട്ടബിൾ നടപടിക്രമങ്ങൾക്ക് പാരാമീറ്ററുകൾ തിരികെ നൽകില്ല, അല്ലെങ്കിൽ തിരികെ നൽകാനാവില്ല. ഒരു കൂട്ടം ഔട്ട്‌പുട്ട് പാരാമീറ്ററുകൾ, റിട്ടേണുകളിൽ ലിസ്‌റ്റ് ചെയ്‌തിരിക്കുന്നു, ഇവിടെ പരാമീറ്ററുകളുടെ ഒരു വരി. തിരഞ്ഞെടുത്ത നടപടിക്രമങ്ങളെ SELECT ചോദ്യങ്ങളിൽ വിളിക്കുന്നു, കൂടാതെ എക്സിക്യൂട്ടബിൾ നടപടിക്രമങ്ങളെ EXECUTE PROCEDURE കമാൻഡ് ഉപയോഗിച്ച് വിളിക്കുന്നു.
രണ്ട് തരത്തിലുള്ള സംഭരിച്ച നടപടിക്രമങ്ങൾക്കും ഒരേ സൃഷ്ടിക്കൽ വാക്യഘടനയുണ്ട്, അവ ഔപചാരികമായി വ്യത്യസ്തമല്ല, അതിനാൽ എക്സിക്യൂട്ടബിൾ ഏത് നടപടിക്രമവും ഒരു SELECT ചോദ്യത്തിൽ വിളിക്കാം, കൂടാതെ ഏത് തിരഞ്ഞെടുക്കൽ നടപടിക്രമവും EXECUTE PROCEDURE ഉപയോഗിച്ച് വിളിക്കാം. വ്യത്യസ്ത തരം കോളുകൾക്ക് കീഴിൽ HP എങ്ങനെ പ്രവർത്തിക്കും എന്നതാണ് ചോദ്യം. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഒരു പ്രത്യേക തരം കോളിനുള്ള നടപടിക്രമം രൂപകൽപ്പന ചെയ്യുന്നതിലാണ് വ്യത്യാസം. അതായത്, തിരഞ്ഞെടുത്ത നടപടിക്രമം ഒരു SELECT ചോദ്യത്തിൽ നിന്ന് വിളിക്കുന്നതിനായി പ്രത്യേകം സൃഷ്‌ടിച്ചതാണ്, കൂടാതെ എക്‌സിക്യൂട്ടബിൾ നടപടിക്രമം എക്‌സിക്യുട്ട് പ്രൊസീഡർ ഉപയോഗിച്ച് വിളിക്കുന്നതിനായി പ്രത്യേകം സൃഷ്‌ടിച്ചതാണ്. ഈ രണ്ട് തരത്തിലുള്ള എച്ച്പിയുടെ രൂപകൽപ്പനയിലെ വ്യത്യാസങ്ങൾ എന്തൊക്കെയാണെന്ന് നോക്കാം.
സാമ്പിൾ നടപടിക്രമം എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് മനസിലാക്കാൻ, നിങ്ങൾ സിദ്ധാന്തത്തിലേക്ക് അൽപ്പം ആഴത്തിൽ പരിശോധിക്കേണ്ടതുണ്ട്. SELECT ID പോലെയുള്ള ഒരു സാധാരണ SQL അന്വേഷണം നമുക്ക് സങ്കൽപ്പിക്കാം, പട്ടിക_ഉദാഹരണത്തിൽ നിന്ന് NAME. അതിന്റെ നിർവ്വഹണത്തിന്റെ ഫലമായി, രണ്ട് നിരകളും (ID, NAME) ഒരു നിശ്ചിത എണ്ണം വരികളും (Table_example പട്ടികയിലെ വരികളുടെ എണ്ണത്തിന് തുല്യമായത്) അടങ്ങുന്ന ഒരു പട്ടിക നമുക്ക് ലഭിക്കും. ഈ അന്വേഷണത്തിന്റെ ഫലമായി ലഭിച്ച പട്ടികയെ SQL ഡാറ്റാ സെറ്റ് എന്നും വിളിക്കുന്നു. ഈ ചോദ്യം നിർവ്വഹിക്കുമ്പോൾ ഡാറ്റാ സെറ്റ് എങ്ങനെ രൂപപ്പെടുന്നുവെന്ന് നമുക്ക് ചിന്തിക്കാം. സെർവർ, അന്വേഷണം സ്വീകരിച്ച്, അത് ഏത് പട്ടികകളെയാണ് സൂചിപ്പിക്കുന്നതെന്ന് നിർണ്ണയിക്കുന്നു, തുടർന്ന് കണ്ടെത്തുന്നു. ഈ പട്ടികകളിൽ നിന്നുള്ള ഏത് ഉപസെറ്റ് റെക്കോർഡുകളാണ് അന്വേഷണ ഫലത്തിൽ ഉൾപ്പെടുത്തേണ്ടത്. അടുത്തതായി, അന്വേഷണ ഫലങ്ങൾ തൃപ്തിപ്പെടുത്തുന്ന ഓരോ റെക്കോർഡും സെർവർ വായിക്കുന്നു, അതിൽ നിന്ന് ആവശ്യമായ ഫീൽഡുകൾ തിരഞ്ഞെടുത്ത് (ഞങ്ങളുടെ കാര്യത്തിൽ, ഐഡിയും NAME ഉം) ക്ലയന്റിലേക്ക് അയയ്ക്കുന്നു. തുടർന്ന് പ്രക്രിയ വീണ്ടും ആവർത്തിക്കുന്നു - തിരഞ്ഞെടുത്ത ഓരോ റെക്കോർഡിനും അങ്ങനെ.
സംഭരിച്ച നടപടിക്രമങ്ങൾ ഉൾപ്പെടെ എല്ലാ SQL ഡാറ്റാ സെറ്റുകളും വരിവരിയായി ജനറേറ്റുചെയ്യുന്നുവെന്ന് പ്രിയ വായനക്കാരന് മനസ്സിലാക്കാൻ ഈ വ്യതിചലനങ്ങളെല്ലാം ആവശ്യമാണ്! കൂടാതെ, ലഭ്യമാക്കുന്നതിനുള്ള നടപടിക്രമങ്ങളും എക്സിക്യൂട്ടബിൾ നടപടിക്രമങ്ങളും തമ്മിലുള്ള പ്രധാന വ്യത്യാസം, ആദ്യത്തേത് നിരവധി വരികൾ തിരികെ നൽകുന്നതിനാണ് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്, രണ്ടാമത്തേത് ഒരെണ്ണം മാത്രം തിരികെ നൽകുന്നതിനാണ് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. അതുകൊണ്ടാണ് അവ വ്യത്യസ്തമായി ഉപയോഗിക്കുന്നത്: തിരഞ്ഞെടുത്ത നടപടിക്രമത്തെ SELECT കമാൻഡ് ഉപയോഗിച്ച് വിളിക്കുന്നു, അത് തിരികെ നൽകാനാകുന്ന എല്ലാ രേഖകളും ഉപേക്ഷിക്കാനുള്ള നടപടിക്രമം "ആവശ്യമാണ്". എക്‌സിക്യൂട്ടബിൾ പ്രൊസീജറിനെ എക്‌സിക്യുട്ട് പ്രൊസീഡർ എന്ന് വിളിക്കുന്നു, ഇത് എച്ച്പിയിൽ നിന്ന് ഒരു വരി മാത്രം "എടുക്കുന്നു", ബാക്കിയുള്ളവ അവഗണിക്കുന്നു (അവ നിലവിലുണ്ടെങ്കിൽ പോലും!).
ഇത് വ്യക്തമാക്കുന്നതിന് ഒരു സാമ്പിൾ നടപടിക്രമത്തിന്റെ ഒരു ഉദാഹരണം നോക്കാം. > ക്ഷമയ്ക്കായി, ഒരു SELECT ഐഡി പോലെ പ്രവർത്തിക്കുന്ന ഒരു സംഭരിച്ച നടപടിക്രമം നമുക്ക് സൃഷ്ടിക്കാം, പട്ടിക_ഉദാഹരണ ചോദ്യത്തിൽ നിന്ന് NAME, അതായത്, ഇത് മുഴുവൻ പട്ടികയിൽ നിന്നും ഐഡിയും NAME ഫീൽഡുകളും തിരഞ്ഞെടുക്കുന്നു. ഈ ഉദാഹരണം ഇതാ:

ലളിതമായ_Select_SP നടപടിക്രമം സൃഷ്ടിക്കുക
റിട്ടേണുകൾ (
procID INTEGER,
procNAME VARCHAR(80))
എ.എസ്
ആരംഭിക്കുന്നു
വേണ്ടി
പട്ടിക_ഉദാഹരണത്തിൽ നിന്ന് ഐഡി, NAME തിരഞ്ഞെടുക്കുക
INTO:procID, :procNAME
DO
ആരംഭിക്കുന്നു
സസ്പെൻഡ് ചെയ്യുക;
അവസാനിക്കുന്നു
അവസാനിക്കുന്നു

Simple_Select_SP എന്ന് വിളിക്കുന്ന ഈ നടപടിക്രമത്തിന്റെ ഘട്ടങ്ങൾ നോക്കാം. നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഇതിന് ഇൻപുട്ട് പാരാമീറ്ററുകളില്ല കൂടാതെ രണ്ട് ഔട്ട്പുട്ട് പാരാമീറ്ററുകളുണ്ട് - ഐഡിയും NAME ഉം. ഏറ്റവും രസകരമായ കാര്യം, തീർച്ചയായും, നടപടിക്രമത്തിന്റെ ശരീരത്തിൽ കിടക്കുന്നു. FOR SELECT നിർമ്മാണം ഇവിടെ ഉപയോഗിക്കുന്നു:

വേണ്ടി
പട്ടിക_ഉദാഹരണത്തിൽ നിന്ന് ഐഡി, NAME തിരഞ്ഞെടുക്കുക
INTO:procID, :procNAME
DO
ആരംഭിക്കുന്നു

/* procID, procName എന്നീ വേരിയബിളുകൾ ഉപയോഗിച്ച് എന്തെങ്കിലും ചെയ്യുക*/

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

ഈ കോഡിന്റെ അർത്ഥം ഇനിപ്പറയുന്നവയാണ്: Table_example പട്ടികയിൽ നിന്ന് തിരഞ്ഞെടുത്ത ഓരോ വരിയിലും, തിരഞ്ഞെടുത്ത മൂല്യങ്ങൾ procID, procName വേരിയബിളുകളിൽ ഇടുക, തുടർന്ന് ഈ വേരിയബിളുകൾ ഉപയോഗിച്ച് എന്തെങ്കിലും ചെയ്യുക.
നിങ്ങൾ ആശ്ചര്യപ്പെട്ട മുഖം ഉണ്ടാക്കി, "വേരിയബിളുകൾ? മറ്റെന്തൊക്കെ വേരിയബിളുകൾ? 9" എന്ന് ചോദിച്ചേക്കാം, സംഭരിച്ച നടപടിക്രമങ്ങളിൽ നമുക്ക് വേരിയബിളുകൾ ഉപയോഗിക്കാൻ കഴിയുന്നത് ഈ അധ്യായത്തിലെ ഒരു അത്ഭുതമാണ്. HP ഭാഷയിൽ, നിങ്ങൾക്ക് ഒരു നടപടിക്രമത്തിനുള്ളിൽ നിങ്ങളുടെ സ്വന്തം പ്രാദേശിക വേരിയബിളുകൾ പ്രഖ്യാപിക്കാനും ഇൻപുട്ട്, ഔട്ട്പുട്ട് പാരാമീറ്ററുകൾ വേരിയബിളുകളായി ഉപയോഗിക്കാനും കഴിയും.
സംഭരിച്ച നടപടിക്രമത്തിൽ ഒരു ലോക്കൽ വേരിയബിൾ പ്രഖ്യാപിക്കുന്നതിന്, നിങ്ങൾ അതിന്റെ വിവരണം AS കീവേഡിന് ശേഷവും BEGIN എന്ന ആദ്യ വാക്കിന് മുമ്പും നൽകേണ്ടതുണ്ട്. ഒരു പ്രാദേശിക വേരിയബിളിന്റെ വിവരണം ഇതുപോലെ കാണപ്പെടുന്നു:

ഡിക്ലെയർ വേരിയബിൾ ;

ഉദാഹരണത്തിന്, ഒരു പൂർണ്ണസംഖ്യ ലോക്കൽ വേരിയബിൾ Mylnt പ്രഖ്യാപിക്കാൻ, നിങ്ങൾ AS-നും BEGIN-നും ഇടയിൽ ഇനിപ്പറയുന്ന പ്രഖ്യാപനം ചേർക്കണം.

ഡിക്ലെയർ വേരിയബിൾ മൈൽന്റ് ഇന്റിജർ;

നമ്മുടെ ഉദാഹരണത്തിലെ വേരിയബിളുകൾ ഒരു കോളനിൽ നിന്നാണ് ആരംഭിക്കുന്നത്. FOR SELECT SQL കമാൻഡിനുള്ളിൽ അവ ആക്‌സസ് ചെയ്‌തിരിക്കുന്നതിനാലാണ് ഇത് ചെയ്യുന്നത്, അതിനാൽ SELECT, വേരിയബിളുകൾ എന്നിവയിൽ ഉപയോഗിക്കുന്ന പട്ടികകളിലെ ഫീൽഡുകൾ തമ്മിൽ വേർതിരിച്ചറിയാൻ, രണ്ടാമത്തേതിന് മുമ്പായി ഒരു കോളൻ ഉണ്ടായിരിക്കണം. എല്ലാത്തിനുമുപരി, പട്ടികകളിലെ ഫീൽഡുകളുടെ അതേ പേര് വേരിയബിളുകൾക്ക് ഉണ്ടായിരിക്കാം!
എന്നാൽ ഒരു വേരിയബിൾ പേരിന് മുമ്പുള്ള കോളൻ SQL അന്വേഷണങ്ങളിൽ മാത്രമേ ഉപയോഗിക്കാവൂ. ടെക്സ്റ്റുകൾക്ക് പുറത്ത്, കോളൺ ഇല്ലാതെ ഒരു വേരിയബിളിനെ പരാമർശിക്കുന്നു, ഉദാഹരണത്തിന്:

procName="ചില പേര്";

എന്നാൽ നമുക്ക് നമ്മുടെ നടപടിക്രമത്തിന്റെ ശരീരത്തിലേക്ക് മടങ്ങാം. FOR SELECT ക്ലോസ് ഡാറ്റ നൽകുന്നത് ഒരു പട്ടികയുടെ രൂപത്തിലല്ല - ഡാറ്റയുടെ ഒരു കൂട്ടം, എന്നാൽ ഒരു സമയത്ത് ഒരു വരി. മടങ്ങിയ ഓരോ ഫീൽഡും അതിന്റേതായ വേരിയബിളിൽ സ്ഥാപിക്കണം: ID => procID, NAME => procName. DO ഭാഗത്ത്, ഈ വേരിയബിളുകൾ SUSPEND കമാൻഡ് ഉപയോഗിച്ച് നടപടിക്രമം എന്ന് വിളിക്കുന്ന ക്ലയന്റിലേക്ക് അയയ്ക്കുന്നു
അങ്ങനെ, FOR SELECT...DO കമാൻഡ് കമാൻഡിന്റെ SELECT ഭാഗത്ത് തിരഞ്ഞെടുത്ത റെക്കോർഡുകളിലൂടെ ലൂപ്പ് ചെയ്യുന്നു. DO ഭാഗം രൂപീകരിച്ച ലൂപ്പിന്റെ ബോഡിയിൽ, അടുത്തതായി സൃഷ്ടിച്ച റെക്കോർഡ് SUSPEND കമാൻഡ് ഉപയോഗിച്ച് ക്ലയന്റിലേക്ക് മാറ്റുന്നു.
അതിനാൽ, തിരഞ്ഞെടുക്കൽ നടപടിക്രമം രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത് ഒന്നോ അതിലധികമോ വരികൾ തിരികെ നൽകുന്നതിനാണ്, അതിനായി HP ബോഡിക്കുള്ളിൽ ഒരു ലൂപ്പ് ക്രമീകരിച്ചിരിക്കുന്നു, അത് ഫലമായുണ്ടാകുന്ന വേരിയബിൾ പാരാമീറ്ററുകൾ പൂരിപ്പിക്കുന്നു. ഈ ലൂപ്പിന്റെ ബോഡിയുടെ അവസാനം എല്ലായ്പ്പോഴും ഒരു സസ്പെൻഡ് കമാൻഡ് ഉണ്ട്, അത് ക്ലയന്റിലേക്ക് ഡാറ്റയുടെ അടുത്ത വരി തിരികെ നൽകും.

ലൂപ്പുകളും ബ്രാഞ്ച് പ്രസ്താവനകളും

ഒരു തിരഞ്ഞെടുപ്പിന്റെ രേഖകളിലൂടെ ഒരു ലൂപ്പ് സംഘടിപ്പിക്കുന്ന FOR SELECT...DO കമാൻഡിന് പുറമേ, മറ്റൊരു തരം ലൂപ്പും ഉണ്ട് - WHILE...DO, ഏതെങ്കിലും വ്യവസ്ഥകൾ പരിശോധിച്ച് ഒരു ലൂപ്പ് സംഘടിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. WHILE..DO ലൂപ്പ് ഉപയോഗിക്കുന്ന HP യുടെ ഒരു ഉദാഹരണം ഇതാ. ഈ നടപടിക്രമം 0 മുതൽ 99 വരെയുള്ള പൂർണ്ണസംഖ്യകളുടെ ചതുരങ്ങൾ നൽകുന്നു:

പ്രോസസ്സ് ക്വാഡ് സൃഷ്ടിക്കുക
റിട്ടേണുകൾ (ക്വാഡ്രാറ്റ് പൂർണ്ണസംഖ്യ)
എ.എസ്
ഡിക്ലെയർ വേരിയബിൾ I ഇന്റിജർ;
ആരംഭിക്കുന്നു
I = 1;
അതേസമയം(ഐ<100) DO
ആരംഭിക്കുന്നു
ക്വാഡ്രറ്റ്= I*I;
I=I+1;
സസ്പെൻഡ് ചെയ്യുക;
അവസാനിക്കുന്നു
അവസാനിക്കുന്നു

SELECT FROM QUAD ചോദ്യം നിർവ്വഹിക്കുന്നതിന്റെ ഫലമായി, 1 മുതൽ 99 വരെയുള്ള പൂർണ്ണസംഖ്യകളുടെ ചതുരങ്ങൾ ഉൾക്കൊള്ളുന്ന ഒരു QUADRAT കോളം അടങ്ങിയ ഒരു പട്ടിക ഞങ്ങൾക്ക് ലഭിക്കും.
ഒരു SQL സാമ്പിളിന്റെയും ഒരു ക്ലാസിക് ലൂപ്പിന്റെയും ഫലങ്ങൾ ആവർത്തിക്കുന്നതിനു പുറമേ, സംഭരിച്ച നടപടിക്രമ ഭാഷ IF...THEN..ELSE ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്നു, ഇത് ഏത് വ്യവസ്ഥകളുടെയും നിർവ്വഹണത്തെ ആശ്രയിച്ച് ബ്രാഞ്ചിംഗ് സംഘടിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. അതിന്റെ വാക്യഘടന സമാനമാണ്. പാസ്കൽ, സി തുടങ്ങിയ ഉയർന്ന തലത്തിലുള്ള പ്രോഗ്രാമിംഗ് ഭാഷകളിലെ മിക്ക ബ്രാഞ്ചിംഗ് ഓപ്പറേറ്റർമാർക്കും.
ഇനിപ്പറയുന്നവ ചെയ്യുന്ന ഒരു സംഭരിച്ച നടപടിക്രമത്തിന്റെ കൂടുതൽ സങ്കീർണ്ണമായ ഉദാഹരണം നോക്കാം.

1. Table_example പട്ടികയിലെ ശരാശരി വില കണക്കാക്കുന്നു ("പട്ടികകളുടെ പ്രാഥമിക കീകളും ജനറേറ്ററുകളും" എന്ന അധ്യായം കാണുക)
2. അടുത്തതായി, പട്ടികയിലെ ഓരോ എൻട്രിക്കും, ഇത് ഇനിപ്പറയുന്ന പരിശോധന നടത്തുന്നു: നിലവിലുള്ള വില (PRICE) ശരാശരി വിലയേക്കാൾ കൂടുതലാണെങ്കിൽ, അത് ശരാശരി വിലയ്ക്ക് തുല്യമായ വിലയും ഒരു നിശ്ചിത നിശ്ചിത ശതമാനവും സജ്ജീകരിക്കുന്നു
3. നിലവിലുള്ള വില ശരാശരി വിലയേക്കാൾ കുറവോ തുല്യമോ ആണെങ്കിൽ, മുമ്പത്തെ വിലയ്ക്ക് തുല്യമായ വിലയും മുൻ വിലയും ശരാശരി വിലയും തമ്മിലുള്ള പകുതി വ്യത്യാസവും സജ്ജീകരിക്കുന്നു.
4. പട്ടികയിലെ എല്ലാ പരിഷ്കരിച്ച വരികളും നൽകുന്നു.

ആദ്യം, നമുക്ക് HP യുടെ പേരും ഇൻപുട്ട്, ഔട്ട്പുട്ട് പാരാമീറ്ററുകളും നിർവചിക്കാം, ഇതെല്ലാം സംഭരിച്ച നടപടിക്രമത്തിന്റെ തലക്കെട്ടിൽ എഴുതിയിരിക്കുന്നു.

ക്രിയേറ്റ് പ്രൊസീജർ വർദ്ധന വിലകൾ (
ശതമാനം2ഇരട്ടി കൃത്യത)
റിട്ടേണുകൾ (ഐഡി INTEGER, NAME VARCHAR(SO), new_price DOUBLE
പ്രിസിഷൻ എഎസ്

നടപടിക്രമത്തെ IncreasePrices എന്ന് വിളിക്കും, ഇതിന് ഒരു ഇൻപുട്ട് പാരാമീറ്റർ Peiceni21nciease എന്ന തരത്തിലുള്ള ഇരട്ട പ്രിസിഷൻ ഉണ്ട്, കൂടാതെ 3 ഔട്ട്‌പുട്ട് പാരാമീറ്ററുകൾ - ID, NAME, new_pnce. ഞങ്ങൾ പ്രവർത്തിക്കാൻ പോകുന്ന Table_example പട്ടികയിലെ ഫീൽഡുകളുടെ അതേ പേരുകളാണ് ആദ്യത്തെ രണ്ട് ഔട്ട്‌പുട്ട് പാരാമീറ്ററുകൾക്കുള്ളത് എന്നത് ശ്രദ്ധിക്കുക. സംഭരിച്ച നടപടിക്രമ ഭാഷയുടെ നിയമങ്ങളാൽ ഇത് അനുവദനീയമാണ്.
ശരാശരി മൂല്യം സംഭരിക്കുന്നതിന് ഉപയോഗിക്കുന്ന ഒരു ലോക്കൽ വേരിയബിൾ നമുക്ക് ഇപ്പോൾ പ്രഖ്യാപിക്കേണ്ടതുണ്ട്. ഡിക്ലറേഷൻ ഇതുപോലെ കാണപ്പെടും:

വേരിയബിൾ ശരാശരി_വില ഇരട്ട പ്രിസിഷൻ പ്രഖ്യാപിക്കുക;

ഇനി നമുക്ക് സംഭരിച്ച നടപടിക്രമത്തിന്റെ ബോഡിയിലേക്ക് പോകാം HP യുടെ ബോഡി തുറക്കുക കീവേഡ് BEGIN.
ആദ്യം നമ്മുടെ അൽഗോരിതത്തിന്റെ ആദ്യ ഘട്ടം നിർവഹിക്കേണ്ടതുണ്ട് - ശരാശരി വില കണക്കാക്കുക. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ ഇനിപ്പറയുന്ന തരത്തിലുള്ള ചോദ്യം ഉപയോഗിക്കും:

AVG തിരഞ്ഞെടുക്കുക(Price_l)
പട്ടിക_ഉദാഹരണത്തിൽ നിന്ന്
INTO:ശരാശരി_വില,-

ഈ ചോദ്യം AVG അഗ്രഗേറ്റ് ഫംഗ്‌ഷൻ ഉപയോഗിക്കുന്നു, ഇത് തിരഞ്ഞെടുത്ത അന്വേഷണ വരികൾക്കിടയിലുള്ള PRICE_1 ഫീൽഡിന്റെ ശരാശരി നൽകുന്നു—ഞങ്ങളുടെ കാര്യത്തിൽ, Table_example പട്ടികയിൽ ഉടനീളമുള്ള PRICE_1 ന്റെ ശരാശരി. അഭ്യർത്ഥന നൽകുന്ന മൂല്യം avg_price വേരിയബിളിൽ സ്ഥാപിച്ചിരിക്കുന്നു. അഭ്യർത്ഥനയിൽ ഉപയോഗിച്ചിരിക്കുന്ന ഫീൽഡുകളിൽ നിന്ന് വേർതിരിക്കാൻ avg_pnce വേരിയബിളിന് മുമ്പായി ഒരു കോളൻ ഉണ്ടെന്ന് ശ്രദ്ധിക്കുക.
ഈ അന്വേഷണത്തിന്റെ പ്രത്യേകത അത് എല്ലായ്പ്പോഴും ഒരു റെക്കോർഡ് കൃത്യമായി നൽകുന്നു എന്നതാണ്. അത്തരം അന്വേഷണങ്ങളെ സിംഗിൾടൺ അന്വേഷണങ്ങൾ എന്ന് വിളിക്കുന്നു.സംഭരിച്ച നടപടിക്രമങ്ങളിൽ അത്തരം തിരഞ്ഞെടുക്കലുകൾ മാത്രമേ ഉപയോഗിക്കാൻ കഴിയൂ. ഒരു ചോദ്യം ഒന്നിൽ കൂടുതൽ വരികൾ നൽകുകയാണെങ്കിൽ, അത് ഫോർമാറ്റ് ചെയ്യപ്പെടണം, തിരഞ്ഞെടുത്തവയ്‌ക്കായി... DO നിർമ്മിതി, അത് മടങ്ങിയ ഓരോ വരിയും പ്രോസസ്സ് ചെയ്യുന്നതിന് ഒരു ലൂപ്പ് ഓർഗനൈസ് ചെയ്യുന്നു
അതിനാൽ, ഞങ്ങൾക്ക് ശരാശരി വില ലഭിച്ചു. ഇപ്പോൾ നിങ്ങൾ മുഴുവൻ പട്ടികയിലൂടെയും പോകേണ്ടതുണ്ട്, ഓരോ എൻട്രിയിലെയും വില മൂല്യവും ശരാശരി വിലയുമായി താരതമ്യം ചെയ്ത് ഉചിതമായ നടപടികൾ കൈക്കൊള്ളുക.
തുടക്കം മുതൽ, ഞങ്ങൾ പട്ടിക_ഉദാഹരണ പട്ടികയിൽ നിന്ന് ഓരോ റെക്കോർഡിനും വേണ്ടിയുള്ള തിരച്ചിൽ സംഘടിപ്പിക്കുന്നു

വേണ്ടി
ഐഡി, NAME, PRICE_1 തിരഞ്ഞെടുക്കുക
പട്ടിക_ഉദാഹരണത്തിൽ നിന്ന്
INTO:ID, :NAME, :new_price
DO
ആരംഭിക്കുന്നു
/*_ഇവിടെ ഞങ്ങൾ ഓരോ എൻട്രിയും വിവരിക്കുന്നു*/
അവസാനിക്കുന്നു

ഈ നിർമ്മാണം നിർവ്വഹിക്കുമ്പോൾ, പട്ടിക_ഉദാഹരണ പട്ടിക വരിയിൽ നിന്ന് വരികൾ അനുസരിച്ച് ഡാറ്റ എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യപ്പെടും, കൂടാതെ ഓരോ വരിയിലെയും ഫീൽഡ് മൂല്യങ്ങൾ വേരിയബിളുകൾ ഐഡി, NAME, new_pnce എന്നിവയിലേക്ക് അസൈൻ ചെയ്യപ്പെടും. തീർച്ചയായും, ഈ വേരിയബിളുകൾ ഔട്ട്‌പുട്ട് പാരാമീറ്ററുകളായി പ്രഖ്യാപിച്ചിട്ടുണ്ടെന്ന് നിങ്ങൾ ഓർക്കുക, പക്ഷേ തിരഞ്ഞെടുത്ത ഡാറ്റ ഫലങ്ങളായി തിരികെ നൽകുമെന്ന് വിഷമിക്കേണ്ടതില്ല: ഔട്ട്‌പുട്ട് പാരാമീറ്ററുകൾ എന്തെങ്കിലും നൽകിയിട്ടുണ്ട് എന്നതിന്റെ അർത്ഥം ക്ലയന്റ് HP-യെ വിളിക്കുന്നു എന്നല്ല. ഈ മൂല്യങ്ങൾ ഉടനടി ലഭിക്കും! SUSPEND കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ മാത്രമേ പാരാമീറ്ററുകൾ കൈമാറുകയുള്ളൂ, അതിനുമുമ്പ് നമുക്ക് ഔട്ട്പുട്ട് പാരാമീറ്ററുകൾ സാധാരണ വേരിയബിളുകളായി ഉപയോഗിക്കാം - ഞങ്ങളുടെ ഉദാഹരണത്തിൽ നമ്മൾ new_price പാരാമീറ്റർ ഉപയോഗിച്ച് അത് ചെയ്യുന്നു.
അതിനാൽ, BEGIN... END ലൂപ്പിന്റെ ബോഡിക്കുള്ളിൽ നമുക്ക് ഓരോ വരിയുടെയും മൂല്യങ്ങൾ പ്രോസസ്സ് ചെയ്യാൻ കഴിയും. നിങ്ങൾ ഓർക്കുന്നതുപോലെ, നിലവിലുള്ള വില ശരാശരിയുമായി എങ്ങനെ താരതമ്യം ചെയ്യുന്നുവെന്ന് ഞങ്ങൾ കണ്ടെത്തുകയും ഉചിതമായ നടപടി സ്വീകരിക്കുകയും വേണം. IF പ്രസ്താവന ഉപയോഗിച്ച് ഞങ്ങൾ ഈ താരതമ്യ നടപടിക്രമം നടപ്പിലാക്കുന്നു:

IF (new_price > avg_price) അപ്പോൾ /*നിലവിലുള്ള വില ശരാശരി വിലയേക്കാൾ കൂടുതലാണെങ്കിൽ*/
ആരംഭിക്കുന്നു
/*അപ്പോൾ ഞങ്ങൾ ശരാശരി വിലയ്ക്ക് തുല്യമായ ഒരു പുതിയ വിലയും ഒരു നിശ്ചിത ശതമാനവും സജ്ജീകരിക്കും */
new_price = (avg_price + avg_price*(Percent2Increase/100));
പട്ടിക_ഉദാഹരണം അപ്‌ഡേറ്റ് ചെയ്യുക
SET PRICE_1 = :new_price
എവിടെ ഐഡി = :ID;
അവസാനിക്കുന്നു
വേറെ
ആരംഭിക്കുന്നു
/* നിലവിലുള്ള വില ശരാശരി വിലയേക്കാൾ കുറവോ തുല്യമോ ആണെങ്കിൽ, മുമ്പത്തെ വിലയ്ക്ക് തുല്യമായ വിലയും കൂടാതെ മുമ്പത്തേതും ശരാശരി വിലയും തമ്മിലുള്ള പകുതി വ്യത്യാസവും സജ്ജീകരിക്കുക */
new_price = (new_pnce + ((avg_pnce new_price)/2)) ;
പട്ടിക_ഉദാഹരണം അപ്‌ഡേറ്റ് ചെയ്യുക
SET PRICE_1 = :new_price
എവിടെ ഐഡി = .ഐഡി;
അവസാനിക്കുന്നു

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഫലം വളരെ വലിയ IF നിർമ്മാണമാണ്, അത് /**/ ചിഹ്നങ്ങളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന അഭിപ്രായങ്ങൾ ഇല്ലെങ്കിൽ മനസ്സിലാക്കാൻ പ്രയാസമായിരിക്കും.
കണക്കാക്കിയ വ്യത്യാസത്തിന് അനുസൃതമായി വില മാറ്റുന്നതിന്, ഞങ്ങൾ അപ്ഡേറ്റ് സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിക്കും, അത് നിലവിലുള്ള രേഖകൾ പരിഷ്കരിക്കാൻ ഞങ്ങളെ അനുവദിക്കുന്നു - ഒന്നോ അതിലധികമോ. ഏത് റെക്കോർഡിലാണ് വില മാറ്റേണ്ടതെന്ന് അവ്യക്തമായി സൂചിപ്പിക്കാൻ, ഞങ്ങൾ WHERE അവസ്ഥയിലെ പ്രാഥമിക കീ ഫീൽഡ് ഉപയോഗിക്കുന്നു, നിലവിലെ റെക്കോർഡിനായി ഐഡി മൂല്യം സംഭരിക്കുന്ന വേരിയബിളിന്റെ മൂല്യവുമായി താരതമ്യം ചെയ്യുന്നു: ID=:ID. ഐഡി വേരിയബിളിന് മുമ്പായി ഒരു കോളൻ ഉണ്ടെന്ന് ശ്രദ്ധിക്കുക.
IF...THEN...ELSE കൺസ്ട്രക്റ്റ് എക്സിക്യൂട്ട് ചെയ്ത ശേഷം, ID, NAME, new_price വേരിയബിളുകൾ എന്നിവയിൽ ഡാറ്റ അടങ്ങിയിരിക്കുന്നു, അത് നടപടിക്രമം എന്ന് വിളിക്കുന്ന ക്ലയന്റിലേക്ക് ഞങ്ങൾ മടങ്ങണം. ഇത് ചെയ്യുന്നതിന്, IF-ന് ശേഷം, നിങ്ങൾ സസ്പെൻഡ് കമാൻഡ് ചേർക്കേണ്ടതുണ്ട്, അത് എച്ച്പി വിളിച്ച സ്ഥലത്തേക്ക് ഡാറ്റ അയയ്ക്കും. കൈമാറ്റ സമയത്ത്, നടപടിക്രമം താൽക്കാലികമായി നിർത്തിവയ്ക്കും, കൂടാതെ എച്ച്പിയിൽ നിന്ന് ഒരു പുതിയ റെക്കോർഡ് ആവശ്യമുള്ളപ്പോൾ, അത് വീണ്ടും തുടരും - കൂടാതെ ഇത് തിരഞ്ഞെടുക്കുന്നത് വരെ തുടരും...DO അതിന്റെ അന്വേഷണത്തിലെ എല്ലാ രേഖകളിലൂടെയും ആവർത്തിക്കില്ല.
സംഭരിച്ച നടപടിക്രമം മാത്രം താൽക്കാലികമായി നിർത്തുന്ന SUSPEND കമാൻഡിന് പുറമേ, സ്ട്രിംഗ് പാസ്സാക്കിയ ശേഷം സംഭരിച്ച നടപടിക്രമം അവസാനിപ്പിക്കുന്ന ഒരു EXIT കമാൻഡ് ഉണ്ടെന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. എന്നിരുന്നാലും, EXIT കമാൻഡ് വളരെ അപൂർവമായി മാത്രമേ ഉപയോഗിക്കുന്നുള്ളൂ, കാരണം ഒരു അവസ്ഥയിൽ എത്തുമ്പോൾ പ്രധാനമായും ലൂപ്പിനെ തടസ്സപ്പെടുത്താൻ ഇത് ആവശ്യമാണ്.
എന്നിരുന്നാലും, ഒരു SELECT പ്രസ്‌താവനയ്‌ക്കൊപ്പം നടപടിക്രമം വിളിക്കുകയും എക്‌സിറ്റ് ഉപയോഗിച്ച് പൂർത്തിയാക്കുകയും ചെയ്‌ത സാഹചര്യത്തിൽ, വീണ്ടെടുക്കപ്പെട്ട അവസാന വരി തിരികെ നൽകില്ല. അതായത്, നിങ്ങൾക്ക് നടപടിക്രമം തടസ്സപ്പെടുത്തുകയും ഈ സ്ട്രിംഗ് ലഭിക്കുകയും ചെയ്യണമെങ്കിൽ, നിങ്ങൾ ക്രമം ഉപയോഗിക്കേണ്ടതുണ്ട്

സസ്പെൻഡ് ചെയ്യുക;
പുറത്ത്;

എക്സിറ്റിന്റെ പ്രധാന ലക്ഷ്യം സിംഗിൾടൺ ഡാറ്റ സെറ്റുകൾ സ്വീകരിക്കുക എന്നതാണ്, എക്‌സിക്യുട്ട് പ്രൊസീഡർ എന്ന് വിളിച്ച് പാരാമീറ്ററുകൾ തിരികെ നൽകുക. ഈ സാഹചര്യത്തിൽ, ഔട്ട്പുട്ട് പാരാമീറ്ററുകളുടെ മൂല്യങ്ങൾ സജ്ജീകരിച്ചിരിക്കുന്നു, എന്നാൽ SQL ഡാറ്റാ സെറ്റ് അവയിൽ നിന്ന് സൃഷ്ടിക്കപ്പെടുന്നില്ല, കൂടാതെ നടപടിക്രമത്തിന്റെ നിർവ്വഹണം അവസാനിക്കുന്നു.
നമ്മുടെ സംഭരിച്ച നടപടിക്രമത്തിന്റെ മുഴുവൻ വാചകവും നമുക്ക് എഴുതാം, അതിലൂടെ നമുക്ക് അതിന്റെ യുക്തി ഒറ്റനോട്ടത്തിൽ പകർത്താനാകും:

ക്രിയേറ്റ് പ്രൊസീജർ വർദ്ധന വിലകൾ (
ശതമാനം2 ഇരട്ടി കൃത്യത വർദ്ധിപ്പിക്കുക)
റിട്ടേണുകൾ (ഐഡി പൂർണ്ണസംഖ്യ, പേര് വർചാർ(80),
new_price DOUBLE PRECISION) AS
വേരിയബിൾ ശരാശരി_വില ഇരട്ട പ്രിസിഷൻ പ്രഖ്യാപിക്കുക;
ആരംഭിക്കുന്നു
AVG തിരഞ്ഞെടുക്കുക(Price_l)
പട്ടിക_ഉദാഹരണത്തിൽ നിന്ന്
INTO:ശരാശരി_വില;
വേണ്ടി
ഐഡി, NAME, PRICE_1 തിരഞ്ഞെടുക്കുക
പട്ടിക_ഉദാഹരണത്തിൽ നിന്ന്
INTO:ID, :NAME, :new_price
DO
ആരംഭിക്കുന്നു
/*ഓരോ റെക്കോർഡും ഇവിടെ പ്രോസസ്സ് ചെയ്യുക*/
IF (new_pnce > avg_price) അപ്പോൾ /*നിലവിലുള്ള വില ശരാശരി വിലയേക്കാൾ കൂടുതലാണെങ്കിൽ*/
ആരംഭിക്കുന്നു
/* ശരാശരി വിലയും ഒരു നിശ്ചിത ശതമാനവും തുല്യമായ ഒരു പുതിയ വില നിശ്ചയിക്കുക */
new_price = (avg_price + avg_price*(Percent2lncrease/100));
പട്ടിക_ഉദാഹരണം അപ്‌ഡേറ്റ് ചെയ്യുക
SET PRICE_1 = :new_price
എവിടെ ഐഡി = :ID;
അവസാനിക്കുന്നു
വേറെ
ആരംഭിക്കുന്നു
/* നിലവിലുള്ള വില ശരാശരി വിലയേക്കാൾ കുറവോ തുല്യമോ ആണെങ്കിൽ, മുമ്പത്തെ വിലയ്ക്ക് തുല്യമായ വിലയും മുമ്പത്തെ വിലയും ശരാശരി വിലയും തമ്മിലുള്ള പകുതി വ്യത്യാസവും സജ്ജീകരിക്കുന്നു */
new_price = (new_price + ((Avg_price - new_price)/2));
പട്ടിക_ഉദാഹരണം അപ്‌ഡേറ്റ് ചെയ്യുക
SET PRICE_1 = :new_price
എവിടെ ഐഡി = :ID;
അവസാനിക്കുന്നു
സസ്പെൻഡ് ചെയ്യുക;
അവസാനിക്കുന്നു
അവസാനിക്കുന്നു

ഈ സംഭരിച്ച നടപടിക്രമ ഉദാഹരണം അടിസ്ഥാന സംഭരിച്ച നടപടിക്രമ ഭാഷാ നിർമ്മാണങ്ങളുടെയും ട്രിഗറുകളുടെയും ഉപയോഗം വ്യക്തമാക്കുന്നു. അടുത്തതായി, ചില പൊതുവായ പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിന് സംഭരിച്ച നടപടിക്രമങ്ങൾ ഉപയോഗിക്കുന്നതിനുള്ള വഴികൾ ഞങ്ങൾ നോക്കാം.

ആവർത്തന സംഭരിച്ച നടപടിക്രമങ്ങൾ

ഇന്റർബേസ് സംഭരിച്ച നടപടിക്രമങ്ങൾ ആവർത്തിക്കാം. ഇതിനർത്ഥം സംഭരിച്ച നടപടിക്രമത്തിന് സ്വയം വിളിക്കാൻ കഴിയും എന്നാണ്. സംഭരിച്ച നടപടിക്രമങ്ങളുടെ 1000 ലെവലുകൾ വരെ നെസ്റ്റിംഗ് അനുവദനീയമാണ്, എന്നാൽ HP യുടെ പരമാവധി നെസ്റ്റിംഗ് എത്തുന്നതിന് മുമ്പ് സെർവറിലെ സൗജന്യ ഉറവിടങ്ങൾ തീർന്നുപോയേക്കാമെന്ന് ഞങ്ങൾ ഓർക്കണം.
സംഭരിച്ച നടപടിക്രമങ്ങളുടെ ഒരു സാധാരണ ഉപയോഗം ഒരു ഡാറ്റാബേസിൽ സംഭരിച്ചിരിക്കുന്ന ട്രീ ഘടനകളെ പ്രോസസ്സ് ചെയ്യുക എന്നതാണ്. ഉൽപ്പന്നങ്ങളുടെ ഘടന, വെയർഹൗസ്, ഉദ്യോഗസ്ഥർ, മറ്റ് സാധാരണ ആപ്ലിക്കേഷനുകൾ എന്നിവയിൽ മരങ്ങൾ പലപ്പോഴും ഉപയോഗിക്കുന്നു.
ഒരു പ്രത്യേക നെസ്റ്റിംഗ് ലെവലിൽ നിന്ന് ആരംഭിച്ച് ഒരു പ്രത്യേക തരത്തിലുള്ള എല്ലാ ഉൽപ്പന്നങ്ങളും തിരഞ്ഞെടുക്കുന്ന ഒരു സംഭരിച്ച നടപടിക്രമത്തിന്റെ ഒരു ഉദാഹരണം നോക്കാം.
പ്രശ്‌നത്തിന്റെ ഇനിപ്പറയുന്ന ഫോർമുലേഷൻ നമുക്ക് നൽകാം: ഇനിപ്പറയുന്ന തരത്തിലുള്ള ഒരു ശ്രേണി ഘടനയുള്ള സാധനങ്ങളുടെ ഒരു ഡയറക്ടറി ഞങ്ങളുടെ പക്കലുണ്ട്:

സാധനങ്ങൾ
- വീട്ടുപകരണങ്ങൾ
- റഫ്രിജറേറ്ററുകൾ
- മൂന്ന് അറകൾ
- ഇരട്ട അറ
- സിംഗിൾ ചേമ്പർ
- തുണിയലക്ക് യന്ത്രം
- ലംബമായ
- ഫ്രണ്ടൽ
- ക്ലാസിക്
- ഇടുങ്ങിയ
- കമ്പ്യൂട്ടർ സാങ്കേതികവിദ്യ
....

ഉൽപ്പന്ന വിഭാഗ ഡയറക്ടറിയുടെ ഈ ഘടനയ്ക്ക് വ്യത്യസ്ത ആഴത്തിലുള്ള ശാഖകൾ ഉണ്ടാകാം. കൂടാതെ കാലക്രമേണ വർദ്ധിക്കുകയും ചെയ്യുന്നു. ഏത് നോഡിൽ നിന്നും ആരംഭിച്ച് "പൂർണ്ണമായ പേര് വികസിപ്പിക്കൽ" ഉപയോഗിച്ച് ഡയറക്ടറിയിൽ നിന്ന് എല്ലാ പരിമിത ഘടകങ്ങളുടെയും തിരഞ്ഞെടുപ്പ് ഉറപ്പാക്കുക എന്നതാണ് ഞങ്ങളുടെ ചുമതല. ഉദാഹരണത്തിന്, ഞങ്ങൾ "വാഷിംഗ് മെഷീനുകൾ" നോഡ് തിരഞ്ഞെടുക്കുകയാണെങ്കിൽ, നമുക്ക് ഇനിപ്പറയുന്ന വിഭാഗങ്ങൾ ലഭിക്കേണ്ടതുണ്ട്:

വാഷിംഗ് മെഷീനുകൾ - ലംബം
വാഷിംഗ് മെഷീനുകൾ - ഫ്രണ്ട് ക്ലാസിക്
വാഷിംഗ് മെഷീനുകൾ - ഫ്രണ്ട് നാരോ

ഉൽപ്പന്ന ഡയറക്‌ടറി വിവരങ്ങൾ സംഭരിക്കുന്നതിനുള്ള പട്ടിക ഘടന നമുക്ക് നിർവചിക്കാം. ഒരു ടേബിളിൽ ട്രീ ഓർഗനൈസുചെയ്യാൻ ഞങ്ങൾ ലളിതമായ ഒരു സ്കീം ഉപയോഗിക്കുന്നു:

ടേബിൾ ഗുഡ്‌സ്‌ട്രീ സൃഷ്‌ടിക്കുക
(ID_GOOD പൂർണ്ണസംഖ്യ ശൂന്യമല്ല,
ID_PARENT_GOOD INTEGER,
GOOD_NAME VARCHAR(80),
കൺസ്ട്രൈന്റ് pkGooci പ്രാഥമിക കീ (ID_GOOD));

ഞങ്ങൾ ഒരു ടേബിൾ GoodsTree സൃഷ്‌ടിക്കുന്നു, അതിൽ 3 ഫീൽഡുകൾ മാത്രമേയുള്ളൂ: ID_GOOD - വിഭാഗത്തിന്റെ സ്‌മാർട്ട് ഐഡന്റിഫയർ, ID_PARENT_GOOD - ഈ വിഭാഗത്തിനായുള്ള മാതൃ കമ്പനിയുടെ ഐഡന്റിഫയർ, GOOD_NAME - വിഭാഗത്തിന്റെ പേര്. ഈ പട്ടികയിലെ ഡാറ്റയുടെ സമഗ്രത ഉറപ്പാക്കാൻ, ഈ പട്ടികയിൽ ഞങ്ങൾ ഒരു വിദേശ കീ നിയന്ത്രണം ഏർപ്പെടുത്തും:

ആൾട്ടർ ടേബിൾ ഗുഡ്‌സ്‌ട്രീ
പരിമിതമായ FK_goodstree ചേർക്കുക
ഫോറിൻ കീ (ID_PARENT_GOOD)
റഫറൻസുകൾ ഗുഡ്‌സ്‌റ്റ്‌പീ (ID__GOOD)

പട്ടിക സ്വയം പരാമർശിക്കുന്നു, ഈ വിദേശ കീ അത് ട്രാക്ക് ചെയ്യുന്നു. അതിനാൽ പട്ടികയിൽ നിലവിലില്ലാത്ത മാതാപിതാക്കളെക്കുറിച്ചുള്ള പരാമർശങ്ങൾ അടങ്ങിയിരിക്കില്ല, കൂടാതെ കുട്ടികളുള്ള ഉൽപ്പന്ന വിഭാഗങ്ങൾ ഇല്ലാതാക്കാനുള്ള ശ്രമങ്ങളെ തടയുകയും ചെയ്യുന്നു.
ഇനിപ്പറയുന്ന ഡാറ്റ ഞങ്ങളുടെ പട്ടികയിലേക്ക് നൽകാം:

ഐഡി_നല്ലത് 1 2 3 4 5 6 7 8 9 10 11 12

ID_PARENT_GOOD 0 1 1 2 2 4 4 4 5 5 10 10

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

ഇപ്പോൾ ഞങ്ങൾക്ക് ഡാറ്റ സംഭരിക്കുന്നതിനുള്ള ഒരു സ്ഥലമുണ്ട്, എല്ലാ "അവസാന" ഉൽപ്പന്ന വിഭാഗങ്ങളെയും ഒരു "വികസിപ്പിച്ച" രൂപത്തിൽ ഔട്ട്‌പുട്ട് ചെയ്യുന്ന ഒരു സംഭരിച്ച നടപടിക്രമം സൃഷ്ടിക്കാൻ നമുക്ക് ആരംഭിക്കാം - ഉദാഹരണത്തിന്, "ത്രീ-ചേംബർ" വിഭാഗത്തിന്, പൂർണ്ണ വിഭാഗം "ഗൃഹോപകരണങ്ങളുടെ റഫ്രിജറേറ്ററുകൾ" ത്രീ-ചേമ്പർ എന്നായിരിക്കും പേര്.
ട്രീ ഘടനകളെ പ്രോസസ്സ് ചെയ്യുന്ന സംഭരിച്ച നടപടിക്രമങ്ങൾക്ക് അവരുടേതായ പദാവലി ഉണ്ട്. വൃക്ഷത്തിന്റെ ഓരോ മൂലകത്തെയും ഒരു നോഡ് എന്ന് വിളിക്കുന്നു; പരസ്പരം പരാമർശിക്കുന്ന നോഡുകൾ തമ്മിലുള്ള ബന്ധത്തെ പേരന്റ്-ചൈൽഡ് ബന്ധം എന്ന് വിളിക്കുന്നു. മരത്തിന്റെ ഏറ്റവും അറ്റത്തുള്ളതും കുട്ടികളില്ലാത്തതുമായ നോഡുകളെ "ഇലകൾ" എന്ന് വിളിക്കുന്നു.
ഈ സംഭരിച്ച നടപടിക്രമത്തിനായി, ഇൻപുട്ട് പാരാമീറ്റർ കാറ്റഗറി ഐഡന്റിഫയർ ആയിരിക്കും, അതിൽ നിന്ന് ഞങ്ങൾ ഡ്രിൽഡൗൺ ആരംഭിക്കേണ്ടതുണ്ട്. സംഭരിച്ച നടപടിക്രമം ഇതുപോലെ കാണപ്പെടും:

നടപടിക്രമം സൃഷ്‌ടിക്കുക പൂർണ്ണനാമം (ID_GOOD2Show INTEGER)
മടക്കങ്ങൾ (FULL_GOODS_NAME VARCHAR(1000),
ID_CHILD_GOOD INTEGER)
എ.എസ്
വേരിയബിൾ CURR_CHILD_NAME VARCHAR(80) പ്രഖ്യാപിക്കുക;
ആരംഭിക്കുന്നു
/*0 ID_GOOD=ID_GOOD2SHOW */ ഉപയോഗിച്ച് ഉൽപ്പന്നത്തിന്റെ ഉടനടിയുള്ള പിൻഗാമികൾക്കനുസൃതമായി തിരഞ്ഞെടുക്കാനുള്ള ബാഹ്യ ലൂപ്പ് സംഘടിപ്പിക്കുക
തിരഞ്ഞെടുക്കുന്നതിന് gtl.id_good, gtl.good_name
ഗുഡ്‌സ്‌ട്രീയിൽ നിന്ന്
എവിടെയാണ് gtl.id_parent_good=:ID_good2show
INTO:ID_CHILD_GOOD, :full_goods_name
DO
ആരംഭിക്കുന്നു
/" EXISTS ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് പരിശോധിക്കുക, ബ്രാക്കറ്റിലെ ചോദ്യം കുറഞ്ഞത് ഒരു വരിയെങ്കിലും നൽകുകയാണെങ്കിൽ TRUE എന്ന് നൽകുന്നു. ID_PARENT_GOOD = ID_CHILD_GOOD ഉള്ള കണ്ടെത്തിയ നോഡിന് കുട്ടികളില്ലെങ്കിൽ, അത് ട്രീയുടെ ഒരു "ഇല" ആണ്, ഫലങ്ങളിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. */
എങ്കിൽ (നിലവിലില്ല
ഗുഡ്‌സ്‌ട്രീയിൽ നിന്ന് * തിരഞ്ഞെടുക്കുക
GoodsTree.id_parent_good=:id_child_good))
പിന്നെ
ആരംഭിക്കുന്നു
/* ഫലങ്ങളിലേക്ക് വൃക്ഷത്തിന്റെ "ഇല" കടന്നുപോകുക */
സസ്പെൻഡ് ചെയ്യുക;
അവസാനിക്കുന്നു
വേറെ
/* കുട്ടികളുള്ള നോഡുകൾക്ക്*/
ആരംഭിക്കുന്നു
/*പാരന്റ് നോഡിന്റെ പേര് ഒരു താൽക്കാലിക വേരിയബിളിൽ സംരക്ഷിക്കുക */
CURR_CHILD_NAME=full_goods_name;
/* ഈ നടപടിക്രമം ആവർത്തിക്കുക */
വേണ്ടി
ID_CHILD_GOOD, പൂർണ്ണ_ചരക്കുകളുടെ_പേര് തിരഞ്ഞെടുക്കുക
GETFULLNAME-ൽ നിന്ന് (:ID_CHILD_GOOD)
INTO:ID_CHILD_GOOD, :full_goods_name
ആരംഭിക്കുക
/*സ്ട്രിംഗ് കോൺകറ്റനേഷൻ ഓപ്പറേഷൻ ഉപയോഗിച്ച് കണ്ടെത്തിയ കുട്ടിയുടെ പേരിലേക്ക് പാരന്റ് നോഡിന്റെ പേര് ചേർക്കുക || */
full_goods_name=CURR_CHILD_NAME| "" | f ull_goods_name,-
സസ്പെൻഡ് ചെയ്യുക; /* ഉൽപ്പന്നത്തിന്റെ മുഴുവൻ പേര് തിരികെ നൽകുക*/
അവസാനിക്കുന്നു
അവസാനിക്കുന്നു
അവസാനിക്കുന്നു
അവസാനിക്കുന്നു

ID_GOOD2SHOW= 1 എന്ന ഇൻപുട്ട് പാരാമീറ്റർ ഉപയോഗിച്ച് ഞങ്ങൾ ഈ നടപടിക്രമം നടപ്പിലാക്കുകയാണെങ്കിൽ, നമുക്ക് ഇനിപ്പറയുന്നവ ലഭിക്കും:

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഒരു ആവർത്തന സംഭരിച്ച നടപടിക്രമം ഉപയോഗിച്ച്, ഞങ്ങൾ മുഴുവൻ കാറ്റഗറി ട്രീയിലൂടെയും പോയി ശാഖകളുടെ ഏറ്റവും അറ്റത്ത് സ്ഥിതി ചെയ്യുന്ന "ഇല" വിഭാഗങ്ങളുടെ മുഴുവൻ പേര് പ്രദർശിപ്പിക്കും.

ഉപസംഹാരം

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