Mssql എങ്ങനെയാണ് ഒരു സംഭരിച്ച നടപടിക്രമം നടപ്പിലാക്കുന്നത് എന്ന് കണ്ടെത്തുന്നത്. SQL-ൽ സംഭരിച്ച നടപടിക്രമങ്ങൾ. വേരിയബിൾ ഡിക്ലറേഷൻ വാക്യഘടന ഇതുപോലെ കാണപ്പെടുന്നു

നിങ്ങളുടെ നടപടിക്രമങ്ങളിൽ ഒരു ലൈൻ ഉൾപ്പെടുത്തുക - എണ്ണം സജ്ജീകരിക്കുക:

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

ഇടപാട്-SQL

വസ്തുവിന്റെ പേരിനൊപ്പം സ്കീമ നാമം ഉപയോഗിക്കുക:

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

ഇടപാട്-SQL

തിരഞ്ഞെടുക്കുക * dbo.MyTable-ൽ നിന്ന് --ഇത് ചെയ്യുന്നത് നല്ലതാണ് -- മൈടേബിളിൽ നിന്ന് തിരഞ്ഞെടുക്കുന്നതിന് പകരം --ഇങ്ങനെ ചെയ്യുന്നത് മോശമാണ് --EXEC dbo.MyProc നടപടിക്രമത്തിലേക്ക് വിളിക്കുന്നത് --നല്ലത് വീണ്ടും --EXEC MyProc-ന് പകരം --മോശം!

നിങ്ങളുടെ സംഭരിച്ച നടപടിക്രമങ്ങളുടെ പേരിൽ "sp_" പ്രിഫിക്സ് ഉപയോഗിക്കരുത്:

ഞങ്ങളുടെ നടപടിക്രമത്തിന്റെ പേര് "sp_" എന്നതിൽ ആരംഭിക്കുന്നുവെങ്കിൽ, SQL സെർവർആദ്യം അതിന്റെ പ്രധാന ഡാറ്റാബേസ് തിരയും. സെർവറിന്റെ വ്യക്തിഗത ആന്തരിക സംഭരിച്ച നടപടിക്രമങ്ങൾക്കായി ഈ പ്രിഫിക്സ് ഉപയോഗിക്കുന്നു എന്നതാണ് വസ്തുത. അതിനാൽ, നിങ്ങളുടെ അതേ പേരിലുള്ള ഒരു നടപടിക്രമം അതിന്റെ ഡാറ്റാബേസിൽ കണ്ടെത്തിയാൽ അതിന്റെ ഉപയോഗം അധിക ചിലവുകളിലേക്കും തെറ്റായ ഫലങ്ങളിലേക്കും നയിച്ചേക്കാം.

IF EXISTS എന്നതിനുപകരം IF EXISTS (SELECT *) ഉപയോഗിക്കുക:

മറ്റൊരു പട്ടികയിൽ ഒരു റെക്കോർഡ് ഉണ്ടോ എന്ന് പരിശോധിക്കാൻ, ഞങ്ങൾ IF EXISTS സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിക്കുന്നു. ഇന്റേണൽ എക്‌സ്‌പ്രഷനിൽ നിന്ന് ഒരു മൂല്യമെങ്കിലും നൽകിയാൽ ഈ എക്‌സ്‌പ്രഷൻ ശരിയാണെന്ന് നൽകുന്നു, അത് “1”, എല്ലാ കോളങ്ങളും അല്ലെങ്കിൽ പട്ടികയും പ്രശ്നമല്ല. തിരികെ നൽകിയ ഡാറ്റ അടിസ്ഥാനപരമായി ഒരു തരത്തിലും ഉപയോഗിക്കുന്നില്ല. അതിനാൽ, ഡാറ്റാ ട്രാൻസ്മിഷൻ സമയത്ത് ട്രാഫിക് കംപ്രസ് ചെയ്യുന്നതിന്, ചുവടെ കാണിച്ചിരിക്കുന്നതുപോലെ "1" ഉപയോഗിക്കുന്നത് കൂടുതൽ യുക്തിസഹമാണ്.

ജോലിയുടെ ലക്ഷ്യം- ഡാറ്റാബേസ് സെർവറിൽ സംഭരിച്ച നടപടിക്രമങ്ങൾ സൃഷ്ടിക്കാനും ഉപയോഗിക്കാനും പഠിക്കുക.

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

2. ലബോറട്ടറി പ്രവർത്തന സമയത്ത് എല്ലാ ഉദാഹരണങ്ങളും ജോലികളും പൂർത്തിയാക്കുന്നു.

3. ഓപ്ഷനുകൾ അനുസരിച്ച് വ്യക്തിഗത ജോലികൾ പൂർത്തിയാക്കുന്നു.

ജോലി നിർവഹിക്കുന്നതിനുള്ള വിശദീകരണങ്ങൾ

സംഭരിച്ച നടപടിക്രമ പ്രോഗ്രാമിംഗ് മാസ്റ്റർ ചെയ്യുന്നതിന്, ഞങ്ങൾ ഒരു ഉദാഹരണ ഡാറ്റാബേസ് ഉപയോഗിക്കുന്നു DB_Books, ലബോറട്ടറി വർക്ക് നമ്പർ 1 ൽ സൃഷ്ടിച്ചത്. ഉദാഹരണങ്ങളും ടാസ്ക്കുകളും പൂർത്തിയാക്കുമ്പോൾ, ഡാറ്റാബേസ്, പട്ടികകൾ, മറ്റ് പ്രോജക്റ്റ് ഒബ്ജക്റ്റുകൾ എന്നിവയുടെ പേരുകളുടെ കത്തിടപാടുകൾ ശ്രദ്ധിക്കുക.

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

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

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

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

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

സംഭരിച്ച നടപടിക്രമങ്ങൾ സൃഷ്ടിക്കുന്നു, പരിഷ്ക്കരിക്കുന്നു

ഒരു സംഭരിച്ച നടപടിക്രമം സൃഷ്ടിക്കുന്നത് ഇനിപ്പറയുന്ന പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിൽ ഉൾപ്പെടുന്നു: ആക്സസ് അവകാശങ്ങൾ ആസൂത്രണം ചെയ്യുക. നിങ്ങൾ ഒരു സംഭരിച്ച നടപടിക്രമം സൃഷ്‌ടിക്കുമ്പോൾ, അത് സൃഷ്‌ടിച്ച ഉപയോക്താവിന് ഡാറ്റാബേസ് ഒബ്‌ജക്‌റ്റുകളിലേക്കുള്ള അതേ ആക്‌സസ് അവകാശങ്ങൾ അതിന് ഉണ്ടായിരിക്കുമെന്ന് അറിഞ്ഞിരിക്കുക; സംഭരിച്ച നടപടിക്രമത്തിന്റെ പാരാമീറ്ററുകൾ നിർവചിക്കുന്നു, സംഭരിച്ച നടപടിക്രമങ്ങൾക്ക് ഇൻപുട്ട്, ഔട്ട്പുട്ട് പാരാമീറ്ററുകൾ ഉണ്ടായിരിക്കാം; സംഭരിച്ച നടപടിക്രമ കോഡ് വികസനം. സംഭരിച്ച മറ്റ് നടപടിക്രമങ്ങളിലേക്കുള്ള കോളുകൾ ഉൾപ്പെടെ ഏത് SQL കമാൻഡുകളുടെയും ഒരു ക്രമം നടപടിക്രമ കോഡിൽ അടങ്ങിയിരിക്കാം.

MS SQL സെർവർ നൊട്ടേഷനിൽ ഒരു പുതിയ അല്ലെങ്കിൽ നിലവിലുള്ള സംഭരിച്ച നടപടിക്രമം മാറ്റുന്നതിനുള്ള ഓപ്പറേറ്ററുടെ വാക്യഘടന:

( സൃഷ്‌ടിക്കുക [പ്രതികരണത്തിന്] AS sql_statement [ ... n]

ഈ കമാൻഡിന്റെ പാരാമീറ്ററുകൾ നോക്കാം.

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

ഇൻപുട്ട്, ഔട്ട്പുട്ട് ഡാറ്റ കൈമാറാൻ, നിങ്ങൾ സൃഷ്ടിക്കുന്ന സംഭരിച്ച നടപടിക്രമത്തിലെ പാരാമീറ്റർ പേരുകൾ @ പ്രതീകത്തിൽ ആരംഭിക്കണം. കോമകളാൽ വേർതിരിച്ച ഒരൊറ്റ സംഭരിച്ച നടപടിക്രമത്തിൽ നിങ്ങൾക്ക് ഒന്നിലധികം പാരാമീറ്ററുകൾ വ്യക്തമാക്കാൻ കഴിയും. ഒരു നടപടിക്രമത്തിന്റെ ബോഡി ഈ നടപടിക്രമത്തിന്റെ പാരാമീറ്ററുകളുടെ പേരുകളുമായി പൊരുത്തപ്പെടുന്ന പ്രാദേശിക വേരിയബിളുകൾ ഉപയോഗിക്കരുത്. സംഭരിച്ച നടപടിക്രമ പാരാമീറ്ററുകളുടെ ഡാറ്റ തരം നിർണ്ണയിക്കുന്നതിന് ഉപയോക്തൃ-നിർവചിച്ചവ ഉൾപ്പെടെ ഏത് SQL ഡാറ്റ തരവും അനുയോജ്യമാണ്. എന്നിരുന്നാലും, CURSOR ഡാറ്റ തരം സംഭരിച്ച നടപടിക്രമത്തിന്റെ ഔട്ട്‌പുട്ട് പാരാമീറ്ററായി മാത്രമേ ഉപയോഗിക്കാൻ കഴിയൂ, അതായത്. OUTPUT കീവേഡ് വ്യക്തമാക്കുന്നു.

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

DEFAULT കീവേഡ്, അനുബന്ധ പാരാമീറ്റർ സ്ഥിരസ്ഥിതിയായി എടുക്കുന്ന മൂല്യത്തെ പ്രതിനിധീകരിക്കുന്നു. അതിനാൽ, ഒരു നടപടിക്രമം വിളിക്കുമ്പോൾ, അനുബന്ധ പാരാമീറ്ററിന്റെ മൂല്യം നിങ്ങൾ വ്യക്തമായി വ്യക്തമാക്കേണ്ടതില്ല.

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

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

സംഭരിച്ച നടപടിക്രമം നീക്കംചെയ്യുന്നു

ഡ്രോപ്പ് നടപടിക്രമം (പ്രക്രിയ_നാമം) [,...n]

ഒരു സംഭരിച്ച നടപടിക്രമം നടപ്പിലാക്കുന്നു

ഒരു സംഭരിച്ച നടപടിക്രമം നടപ്പിലാക്കാൻ, കമാൻഡ് ഉപയോഗിക്കുക: [ [ EXEC [ UTE] process_name [ ;number] [ [ @parameter_name= ] ( value | @variable_name) [ OUTPUT ] | [ ഡിഫോൾട്ട് ] ] [ ,... n]

സംഭരിച്ച നടപടിക്രമ കോൾ ബാച്ചിലെ ഒരേയൊരു കമാൻഡ് അല്ലെങ്കിൽ, EXECUTE കമാൻഡ് ആവശ്യമാണ്. മാത്രമല്ല, മറ്റൊരു നടപടിക്രമത്തിന്റെ അല്ലെങ്കിൽ ട്രിഗറിന്റെ ശരീരത്തിൽ നിന്ന് ഒരു നടപടിക്രമം വിളിക്കാൻ ഈ കമാൻഡ് ആവശ്യമാണ്.

ഒരു നടപടിക്രമം വിളിക്കുമ്പോൾ OUTPUT കീവേഡ് ഉപയോഗിക്കുന്നത് OUTPUT കീവേഡ് ഉപയോഗിച്ച് നടപടിക്രമം സൃഷ്‌ടിച്ചപ്പോൾ പ്രഖ്യാപിച്ച പാരാമീറ്ററുകൾക്ക് മാത്രമേ അനുവദിക്കൂ.

ഒരു നടപടിക്രമം വിളിക്കുമ്പോൾ ഒരു പരാമീറ്ററിനായി DEFAULT കീവേഡ് വ്യക്തമാക്കുമ്പോൾ, സ്ഥിരസ്ഥിതി മൂല്യം ഉപയോഗിക്കും. സ്വാഭാവികമായും, സ്ഥിരസ്ഥിതി മൂല്യം നിർവചിച്ചിരിക്കുന്ന പരാമീറ്ററുകൾക്ക് മാത്രമേ DEFAULT എന്ന നിർദ്ദിഷ്ട വാക്ക് അനുവദനീയമാണ്.

EXECUTE കമാൻഡിന്റെ വാക്യഘടന ഒരു നടപടിക്രമം വിളിക്കുമ്പോൾ പാരാമീറ്റർ പേരുകൾ ഒഴിവാക്കാമെന്ന് കാണിക്കുന്നു. എന്നിരുന്നാലും, ഈ സാഹചര്യത്തിൽ, നടപടിക്രമം സൃഷ്ടിക്കുമ്പോൾ ലിസ്റ്റുചെയ്ത അതേ ക്രമത്തിൽ തന്നെ പാരാമീറ്ററുകൾക്കായുള്ള മൂല്യങ്ങൾ ഉപയോക്താവ് വ്യക്തമാക്കണം. എണ്ണൽ സമയത്ത് അത് ഒഴിവാക്കിക്കൊണ്ട് നിങ്ങൾക്ക് ഒരു പരാമീറ്ററിന് സ്ഥിരസ്ഥിതി മൂല്യം നൽകാനാവില്ല. ഡിഫോൾട്ട് മൂല്യമുള്ള പാരാമീറ്ററുകൾ നിങ്ങൾക്ക് ഒഴിവാക്കണമെങ്കിൽ, സംഭരിച്ച നടപടിക്രമം വിളിക്കുമ്പോൾ പരാമീറ്റർ പേരുകൾ വ്യക്തമായി വ്യക്തമാക്കിയാൽ മതിയാകും. കൂടാതെ, ഈ രീതിയിൽ നിങ്ങൾക്ക് പാരാമീറ്ററുകളും അവയുടെ മൂല്യങ്ങളും ഏത് ക്രമത്തിലും ലിസ്റ്റുചെയ്യാനാകും.

ഒരു നടപടിക്രമം വിളിക്കുമ്പോൾ, ഒന്നുകിൽ മൂല്യങ്ങളുള്ള പാരാമീറ്റർ പേരുകൾ അല്ലെങ്കിൽ ഒരു പാരാമീറ്റർ പേരില്ലാത്ത മൂല്യങ്ങൾ മാത്രമേ വ്യക്തമാക്കിയിട്ടുള്ളൂ എന്നത് ശ്രദ്ധിക്കുക. അവ സംയോജിപ്പിക്കുന്നത് അനുവദനീയമല്ല.

സംഭരിച്ച നടപടിക്രമത്തിൽ റിട്ടേൺ ഉപയോഗിക്കുന്നു

ഒരു നിർദ്ദിഷ്ട വ്യവസ്ഥ അനുസരിച്ച് ഏത് ഘട്ടത്തിലും നടപടിക്രമത്തിൽ നിന്ന് പുറത്തുകടക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു, കൂടാതെ നടപടിക്രമത്തിന്റെ ഫലം ഒരു സംഖ്യയായി അറിയിക്കാനും നിങ്ങളെ അനുവദിക്കുന്നു, അതിലൂടെ നിങ്ങൾക്ക് നടപടിക്രമത്തിന്റെ ഗുണനിലവാരവും കൃത്യതയും വിലയിരുത്താനാകും. പാരാമീറ്ററുകൾ ഇല്ലാതെ ഒരു നടപടിക്രമം സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം:

പുസ്‌തകങ്ങളിൽ നിന്ന് COUNT (കോഡ്_ബുക്ക്) തിരഞ്ഞെടുക്കുന്നതുപോലെ നടപടിക്രമങ്ങളുടെ എണ്ണം_ബുക്കുകൾ സൃഷ്‌ടിക്കുക

വ്യായാമം 1.

EXEC കൗണ്ട്_ബുക്കുകൾ

ഫലം പരിശോധിക്കുക.

ഒരു ഇൻപുട്ട് പാരാമീറ്റർ ഉപയോഗിച്ച് ഒരു നടപടിക്രമം സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം:

പുസ്‌തകങ്ങളിൽ നിന്ന് എവിടേക്കാണ് പേജുകൾ>= @Count_pages പോകുക

ടാസ്ക് 2. SQL സെർവർ മാനേജ്മെന്റ് സ്റ്റുഡിയോ യൂട്ടിലിറ്റി ഉപയോഗിച്ച് DB_Books ഡാറ്റാബേസിന്റെ സംഭരിച്ച നടപടിക്രമങ്ങൾ വിഭാഗത്തിൽ ഈ നടപടിക്രമം സൃഷ്ടിക്കുക. കമാൻഡ് ഉപയോഗിച്ച് ഇത് പ്രവർത്തിപ്പിക്കുക

EXEC Count_Books_Pages 100

ഫലം പരിശോധിക്കുക.

ഇൻപുട്ട് പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് ഒരു നടപടിക്രമം സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം:

നടപടിക്രമം സൃഷ്‌ടിക്കുക Count_Books_Title @Count_pages AS INT , @Title AS CHAR (10 ) എന്ന നിലയിൽ ബുക്കുകളിൽ നിന്ന് COUNT (കോഡ്_ബുക്ക്) തിരഞ്ഞെടുക്കുക.

ടാസ്ക് 3. SQL സെർവർ മാനേജ്മെന്റ് സ്റ്റുഡിയോ യൂട്ടിലിറ്റി ഉപയോഗിച്ച് DB_Books ഡാറ്റാബേസിന്റെ സംഭരിച്ച നടപടിക്രമങ്ങൾ വിഭാഗത്തിൽ ഈ നടപടിക്രമം സൃഷ്ടിക്കുക. കമാൻഡ് ഉപയോഗിച്ച് ഇത് പ്രവർത്തിപ്പിക്കുക

EXEC Count_Books_Title 100 , "P%"

ഫലം പരിശോധിക്കുക.

ഇൻപുട്ട് പാരാമീറ്ററുകളും ഔട്ട്പുട്ട് പാരാമീറ്ററും ഉപയോഗിച്ച് ഒരു നടപടിക്രമം സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം:

നടപടിക്രമം Count_Books_Itogo @Count_pages INT , @Title CHAR (10 ) , @Itogo INT ഔട്ട്പുട്ട് ആയി തിരഞ്ഞെടുക്കുക @Itogo = COUNT (കോഡ്_ബുക്ക്) എവിടെയാണ് പേജുകൾ>= @Count_pages കൂടാതെ @Titlebook @LKEGO

ടാസ്ക് 4. SQL സെർവർ മാനേജ്മെന്റ് സ്റ്റുഡിയോ യൂട്ടിലിറ്റി ഉപയോഗിച്ച് DB_Books ഡാറ്റാബേസിന്റെ സംഭരിച്ച നടപടിക്രമങ്ങൾ വിഭാഗത്തിൽ ഈ നടപടിക്രമം സൃഷ്ടിക്കുക. കമാൻഡ് സെറ്റ് ഉപയോഗിച്ച് പ്രവർത്തിപ്പിക്കുക:

Sql> @q ആയി പ്രഖ്യാപിക്കുക EXEC Count_Books_Itogo 100, "P%", @q ഔട്ട്‌പുട്ട് തിരഞ്ഞെടുക്കുക @q

ഫലം പരിശോധിക്കുക.

ഇൻപുട്ട് പാരാമീറ്ററുകളും റിട്ടേണും ഉപയോഗിച്ച് ഒരു നടപടിക്രമം സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം:

എങ്കിൽ @param INT എന്ന രീതിയിലുള്ള പ്രൊസീഡർ ചെക്ക്‌നാമം സൃഷ്‌ടിക്കുക (രചയിതാക്കളിൽ നിന്ന് Name_author തിരഞ്ഞെടുക്കുക. Code_author = @param) = "Pushkin A.S." റിട്ടേൺ 1 വേറെ റിട്ടേൺ 2

ടാസ്ക് 5. SQL സെർവർ മാനേജ്മെന്റ് സ്റ്റുഡിയോ യൂട്ടിലിറ്റി ഉപയോഗിച്ച് DB_Books ഡാറ്റാബേസിന്റെ സംഭരിച്ച നടപടിക്രമങ്ങൾ വിഭാഗത്തിൽ ഈ നടപടിക്രമം സൃഷ്ടിക്കുക. കമാൻഡുകൾ ഉപയോഗിച്ച് ഇത് പ്രവർത്തിപ്പിക്കുക:

പ്രഖ്യാപിക്കുക @return_status INT EXEC @return_status = ചെക്ക് നെയിം 1 തിരഞ്ഞെടുക്കുക "റിട്ടേൺ സ്റ്റാറ്റസ്" = @return_status

വാങ്ങൽ പട്ടികയിലെ ഒരു കീ ഫീൽഡിന്റെ മൂല്യം 2 മടങ്ങ് വർദ്ധിപ്പിക്കുന്നതിന് പാരാമീറ്ററുകൾ ഇല്ലാതെ ഒരു നടപടിക്രമം സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം:

വാങ്ങലുകൾ അപ്‌ഡേറ്റ് ചെയ്യുന്നതുപോലെ PROC update_proc സൃഷ്‌ടിക്കുക SET Code_purchase = Code_purchase* 2

ടാസ്ക് 6. SQL സെർവർ മാനേജ്മെന്റ് സ്റ്റുഡിയോ യൂട്ടിലിറ്റി ഉപയോഗിച്ച് DB_Books ഡാറ്റാബേസിന്റെ സംഭരിച്ച നടപടിക്രമങ്ങൾ വിഭാഗത്തിൽ ഈ നടപടിക്രമം സൃഷ്ടിക്കുക. കമാൻഡ് ഉപയോഗിച്ച് ഇത് പ്രവർത്തിപ്പിക്കുക

EXEC update_proc

ഒരു നിർദ്ദിഷ്‌ട രചയിതാവിനെക്കുറിച്ചുള്ള എല്ലാ വിവരങ്ങളും നേടുന്നതിനുള്ള ഇൻപുട്ട് പാരാമീറ്ററുള്ള ഒരു നടപടിക്രമത്തിന്റെ ഉദാഹരണം:

രചയിതാക്കളിൽ നിന്ന് തിരഞ്ഞെടുക്കുന്നതുപോലെ PROC select_author @k CHAR (30 ) സൃഷ്ടിക്കുക name_author= @k

ടാസ്ക് 7.

EXEC select_author "പുഷ്കിൻ എ.എസ്." അല്ലെങ്കിൽ select_author @k= "Pushkin A.S." അല്ലെങ്കിൽ EXEC select_author @k= "Pushkin A.S."

വാങ്ങൽ പട്ടികയിലെ ഒരു കീ ഫീൽഡിന്റെ മൂല്യം ഒരു നിശ്ചിത തവണ (സ്ഥിരസ്ഥിതിയായി 2 തവണ) വർദ്ധിപ്പിക്കുന്നതിന് ഇൻപുട്ട് പാരാമീറ്ററും സ്ഥിരസ്ഥിതി മൂല്യവും ഉപയോഗിച്ച് ഒരു നടപടിക്രമം സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം:

PROC സൃഷ്‌ടിക്കുക update_proc @p INT = 2 വാങ്ങലുകൾ അപ്‌ഡേറ്റ് ചെയ്യുന്നതുപോലെ, SET Code_purchase = Code_purchase * @p

നടപടിക്രമം ഡാറ്റയൊന്നും നൽകുന്നില്ല.

ടാസ്ക് 8. SQL സെർവർ മാനേജ്മെന്റ് സ്റ്റുഡിയോ യൂട്ടിലിറ്റി ഉപയോഗിച്ച് DB_Books ഡാറ്റാബേസിന്റെ സംഭരിച്ച നടപടിക്രമങ്ങൾ വിഭാഗത്തിൽ ഈ നടപടിക്രമം സൃഷ്ടിക്കുക. കമാൻഡുകൾ ഉപയോഗിച്ച് ഇത് പ്രവർത്തിപ്പിക്കുക:

EXEC update_proc 4 അല്ലെങ്കിൽ EXEC update_proc @p = 4 അല്ലെങ്കിൽ EXEC update_proc --ഡിഫോൾട്ട് മൂല്യം ഉപയോഗിക്കും.

ഇൻപുട്ട്, ഔട്ട്പുട്ട് പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് ഒരു നടപടിക്രമം സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം. ഒരു നിശ്ചിത കാലയളവിൽ പൂർത്തിയാക്കിയ ഓർഡറുകളുടെ എണ്ണം നിർണ്ണയിക്കാൻ ഒരു നടപടിക്രമം സൃഷ്ടിക്കുക:

@d1 നും @d2 നും ഇടയിലുള്ള തീയതി_ഓർഡർ എവിടെനിന്ന് വാങ്ങലുകളിൽ നിന്ന് @d1 ചെറിയ തീയതിയിൽ, @d2 ചെറിയ തീയതിയിൽ, @c INT ഔട്ട്‌പുട്ട് ആയി @c= എണ്ണം (കോഡ്_പർച്ചേസ്) എന്നിവ സൃഷ്‌ടിക്കുക.

ടാസ്ക് 9. SQL സെർവർ മാനേജ്മെന്റ് സ്റ്റുഡിയോ യൂട്ടിലിറ്റി ഉപയോഗിച്ച് DB_Books ഡാറ്റാബേസിന്റെ സംഭരിച്ച നടപടിക്രമങ്ങൾ വിഭാഗത്തിൽ ഈ നടപടിക്രമം സൃഷ്ടിക്കുക. കമാൻഡുകൾ ഉപയോഗിച്ച് ഇത് പ്രവർത്തിപ്പിക്കുക:

@c2 INT EXEC count_purchases '01-jun-2006', '01-jul-2006', @c2 ഔട്ട്‌പുട്ട് തിരഞ്ഞെടുക്കുക @c2 പ്രഖ്യാപിക്കുക

ലബോറട്ടറി വർക്ക് നമ്പർ 4-നുള്ള ചുമതലകൾക്കുള്ള ഓപ്ഷനുകൾ

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

ഉദാഹരണത്തിന്, ലബോറട്ടറി വർക്ക് നമ്പർ 2 ലെ പ്രാരംഭ ചുമതലയും അഭ്യർത്ഥനയും:

/*വിതരണ ഡയറക്‌ടറിയിൽ നിന്ന് (ഡെലിവറി ടേബിൾ) കമ്പനികളുടെ പേരുകൾ, ടെലിഫോൺ നമ്പറുകൾ, INN (ഫീൽഡുകൾ Name_company, Phone, INN) എന്നിവ തിരഞ്ഞെടുക്കുക, അതിന്റെ കമ്പനിയുടെ പേര് (ഫീൽഡ് Name_company) “OJSC MIR” ആണ്.

ഡെലിവറികളിൽ നിന്ന് Name_company, Phone, INN തിരഞ്ഞെടുക്കുക Name_company = "OJSC MIR"

*/ -ഈ ജോലിയിൽ ഇനിപ്പറയുന്ന നടപടിക്രമം സൃഷ്ടിക്കും:

PROC സെലക്ട്_നെയിം_കമ്പനി @comp CHAR (30 ) ക്രിയേറ്റ് ചെയ്യുക പേര്_കമ്പനി, ഫോൺ, INN എന്നിവയിൽ നിന്ന് ഡെലിവറികളിൽ നിന്ന് തിരഞ്ഞെടുക്കുക Name_company = @comp

- നടപടിക്രമം ആരംഭിക്കുന്നതിന്, കമാൻഡ് ഉപയോഗിക്കുക:

EXEC select_name_company "JSC MIR"

കൃത്യനിർവഹണ പട്ടിക

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

ഓപ്ഷൻ 1

1. ഒരു കുട്ടിയെങ്കിലും ഉള്ള ജീവനക്കാരുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

2. നിശ്ചിത കാലയളവിൽ സമ്മാനങ്ങൾ ലഭിച്ച കുട്ടികളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

3. പ്രായപൂർത്തിയാകാത്ത കുട്ടികളുള്ള മാതാപിതാക്കളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

4. തീയതി പ്രകാരം അടുക്കിയ നിശ്ചിത നമ്പറിനേക്കാൾ വലിയ മൂല്യമുള്ള സമ്മാനങ്ങളെക്കുറിച്ചുള്ള വിവരങ്ങൾ പ്രദർശിപ്പിക്കുക.

ഓപ്ഷൻ 2

1. നിർദ്ദിഷ്ട തരത്തിലുള്ള ഉപകരണങ്ങളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

2. അറ്റകുറ്റപ്പണി നടത്തിയ ഉപകരണങ്ങളുടെ എണ്ണവും അറ്റകുറ്റപ്പണികളുടെ ആകെ ചെലവും നിർദ്ദിഷ്ട ടെക്നീഷ്യനിൽ നിന്ന് പ്രദർശിപ്പിക്കുക.

3. അവരോഹണ ക്രമത്തിലുള്ള അഭ്യർത്ഥനകളുടെ എണ്ണം അനുസരിച്ച് അടുക്കിയ ഉപകരണ ഉടമകളുടെ ഒരു ലിസ്റ്റും അവരുടെ അഭ്യർത്ഥനകളുടെ എണ്ണവും പ്രദർശിപ്പിക്കുക.

4. നിർദ്ദിഷ്‌ട സംഖ്യയേക്കാൾ ഉയർന്ന റാങ്കുള്ള അല്ലെങ്കിൽ നിശ്ചിത തീയതിയേക്കാൾ കുറഞ്ഞ നിയമന തീയതിയുള്ള കരകൗശല വിദഗ്ധരെക്കുറിച്ചുള്ള വിവരങ്ങൾ പ്രദർശിപ്പിക്കുക.

ഓപ്ഷൻ 3

2. നിർദ്ദിഷ്ട സംഖ്യയേക്കാൾ വലിയ തുകയ്ക്ക് പൂക്കൾ വിറ്റ വിൽപ്പന കോഡുകളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

3. നിർദ്ദിഷ്ട വിൽപ്പന കോഡ് അനുസരിച്ച് വിൽപ്പന തീയതി, തുക, വിൽപ്പനക്കാരൻ, പൂവ് എന്നിവ പ്രദർശിപ്പിക്കുക.

4. പൂക്കളുടെ ലിസ്റ്റും പൂക്കളുടെ ഇനവും നിർദ്ദിഷ്‌ട സംഖ്യയേക്കാൾ ഉയർന്നതോ പൂക്കുന്നതോ ആയ ഉയരത്തിൽ പ്രദർശിപ്പിക്കുക.

ഓപ്ഷൻ 4

1. ഉപയോഗത്തിനുള്ള നിർദ്ദിഷ്ട സൂചനയുള്ള മരുന്നുകളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

2. അതേ പേരിലുള്ള മരുന്നിന്റെ നിർദ്ദിഷ്ട എണ്ണത്തേക്കാൾ കൂടുതൽ വിറ്റ ഡെലിവറി തീയതികളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

3. ഡെലിവറി തീയതി, തുക, വിതരണക്കാരനിൽ നിന്നുള്ള മാനേജരുടെ പൂർണ്ണമായ പേര്, നിർദ്ദിഷ്ട നമ്പറിനേക്കാൾ വലിയ രസീത് കോഡ് ഉപയോഗിച്ച് മരുന്നിന്റെ പേര് എന്നിവ പ്രദർശിപ്പിക്കുക.

ഓപ്ഷൻ 5

2. നിർദ്ദിഷ്ട കാരണത്താൽ ഡീകമ്മീഷൻ ചെയ്ത ഉപകരണങ്ങളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

3. രസീത് തീയതി, ഉപകരണത്തിന്റെ പേര്, ഉത്തരവാദിത്തപ്പെട്ട വ്യക്തിയുടെ മുഴുവൻ പേര്, നിർദ്ദിഷ്ട കാലയളവിൽ എഴുതിത്തള്ളപ്പെട്ട ഉപകരണങ്ങൾ എഴുതിത്തള്ളുന്ന തീയതി എന്നിവ പ്രദർശിപ്പിക്കുക.

4. ഒരു നിർദ്ദിഷ്ട തരം അല്ലെങ്കിൽ ഒരു നിശ്ചിത മൂല്യത്തേക്കാൾ കൂടുതൽ രസീത് തീയതി ഉപയോഗിച്ച് ഉപകരണങ്ങളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക

ഓപ്ഷൻ 6

1. നിർദിഷ്ട എണ്ണത്തേക്കാൾ വലിയ ഭാരമുള്ള വിഭവങ്ങളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

2. പേരുകളിൽ നിർദ്ദിഷ്‌ട പദ ശകലം അടങ്ങിയിരിക്കുന്ന ഉൽപ്പന്നങ്ങളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

3. നിർദ്ദിഷ്ട പ്രാരംഭ മൂല്യത്തിൽ നിന്ന് ഒരു നിശ്ചിത അന്തിമ മൂല്യത്തിലേക്ക് ഉൽപ്പന്നത്തിന്റെ അളവ്, വിഭവത്തിന്റെ പേര്, ഡിഷ് കോഡ് ഉപയോഗിച്ച് ഉൽപ്പന്നത്തിന്റെ പേര് എന്നിവ പ്രദർശിപ്പിക്കുക.

4. ഒരു വിഭവം തയ്യാറാക്കുന്നതിന്റെ ക്രമവും ഒരു വിഭവത്തിന്റെ പേരും ഒരു നിശ്ചിത മൂല്യത്തേക്കാൾ കൂടുതലുള്ള കാർബോഹൈഡ്രേറ്റിന്റെ അളവ് അല്ലെങ്കിൽ ഒരു നിശ്ചിത മൂല്യത്തേക്കാൾ കൂടുതൽ കലോറിയുടെ അളവ് പ്രദർശിപ്പിക്കുക.

ഓപ്ഷൻ 7

1. നിർദ്ദിഷ്ട സ്ഥാനത്തുള്ള ജീവനക്കാരുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

3. നിർദ്ദിഷ്ട കാലയളവിൽ രജിസ്റ്റർ ചെയ്ത രേഖകളുടെ രജിസ്ട്രേഷൻ തീയതി, പ്രമാണ തരം, രജിസ്ട്രാറുടെ മുഴുവൻ പേര്, ഓർഗനൈസേഷന്റെ പേര് എന്നിവ പ്രദർശിപ്പിക്കുക.

4. ഒരു നിർദ്ദിഷ്ട ഡോക്യുമെന്റ് തരം അല്ലെങ്കിൽ നിർദ്ദിഷ്ട മൂല്യത്തേക്കാൾ വലിയ രജിസ്ട്രേഷൻ തീയതി ഉപയോഗിച്ച് രജിസ്റ്റർ ചെയ്ത പ്രമാണങ്ങളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

ഓപ്ഷൻ 8

1. പിരിച്ചുവിടലിനുള്ള നിർദ്ദിഷ്ട കാരണവുമായി ജീവനക്കാരുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

3. നിർദ്ദിഷ്ട കാലയളവിൽ രജിസ്റ്റർ ചെയ്ത രേഖകൾക്കായി രജിസ്ട്രേഷൻ തീയതി, പിരിച്ചുവിടൽ കാരണം, ജീവനക്കാരന്റെ മുഴുവൻ പേര് എന്നിവ പ്രദർശിപ്പിക്കുക.

ഓപ്ഷൻ 9

1. നിർദ്ദിഷ്ട തരത്തിലുള്ള അവധി എടുത്ത ജീവനക്കാരുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

2. നിർദ്ദിഷ്ട കാലയളവിൽ രജിസ്ട്രേഷൻ തീയതിയുള്ള പ്രമാണങ്ങളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

3. നിർദ്ദിഷ്ട കാലയളവിൽ രജിസ്റ്റർ ചെയ്ത രേഖകളുടെ രജിസ്ട്രേഷൻ തീയതി, അവധി തരം, ജീവനക്കാരന്റെ മുഴുവൻ പേര് എന്നിവ പ്രദർശിപ്പിക്കുക.

4. നിർദ്ദിഷ്ട ശ്രേണിയിൽ ഒരു ഡോക്യുമെന്റ് കോഡ് ഉപയോഗിച്ച് രജിസ്റ്റർ ചെയ്ത പ്രമാണങ്ങളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

ഓപ്ഷൻ 10

1. നിർദ്ദിഷ്ട സ്ഥാനത്തുള്ള ജീവനക്കാരുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

2. നിർദ്ദിഷ്ട പദ ശകലം അടങ്ങിയിരിക്കുന്ന പ്രമാണങ്ങളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

3. നിർദ്ദിഷ്ട കാലയളവിൽ രജിസ്റ്റർ ചെയ്ത രേഖകൾക്കായി രജിസ്ട്രേഷൻ തീയതി, പ്രമാണ തരം, അയച്ചയാളുടെ മുഴുവൻ പേര്, ഓർഗനൈസേഷന്റെ പേര് എന്നിവ പ്രദർശിപ്പിക്കുക.

4. നിർദ്ദിഷ്ട ഡോക്യുമെന്റ് തരം അല്ലെങ്കിൽ ഒരു നിശ്ചിത മൂല്യത്തിൽ കുറവുള്ള ഒരു ഡോക്യുമെന്റ് കോഡ് ഉപയോഗിച്ച് രജിസ്റ്റർ ചെയ്ത പ്രമാണങ്ങളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

ഓപ്ഷൻ 11

1. നിർദ്ദിഷ്ട സ്ഥാനത്തേക്ക് നിയോഗിച്ചിട്ടുള്ള ജീവനക്കാരുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

3. നിർദ്ദിഷ്ട കാലയളവിൽ രജിസ്റ്റർ ചെയ്ത രേഖകൾക്കായി രജിസ്ട്രേഷൻ തീയതി, സ്ഥാനം, ജീവനക്കാരന്റെ മുഴുവൻ പേര് എന്നിവ പ്രദർശിപ്പിക്കുക.

ഓപ്ഷൻ 12

3. ഉപകരണങ്ങൾ വാടകയ്‌ക്കെടുത്ത ആളുകളുടെ ഒരു ലിസ്റ്റും അവരുടെ അഭ്യർത്ഥനകളുടെ എണ്ണവും, അവരോഹണ ക്രമത്തിൽ അഭ്യർത്ഥനകളുടെ എണ്ണം അനുസരിച്ച് അടുക്കുക.

ഓപ്ഷൻ 13

1. നിർദ്ദിഷ്ട തരത്തിലുള്ള ഉപകരണങ്ങളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക. 2. ഒരു പ്രത്യേക ജീവനക്കാരൻ എഴുതിത്തള്ളപ്പെട്ട ഉപകരണങ്ങളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

3. ഡീകമ്മീഷൻ ചെയ്ത ഉപകരണങ്ങളുടെ അളവ് പ്രദർശിപ്പിക്കുക, ഉപകരണ തരം അനുസരിച്ച് ഗ്രൂപ്പുചെയ്യുക.

4. ഒരു നിശ്ചിത തീയതിയേക്കാൾ കൂടുതലുള്ള വാടക തീയതിയുള്ള ജീവനക്കാരെക്കുറിച്ചുള്ള വിവരങ്ങൾ പ്രദർശിപ്പിക്കുക.

ഓപ്ഷൻ 14

1. നിർദ്ദിഷ്ട ഇല തരം പൂക്കളുടെ ഒരു ലിസ്റ്റ് പ്രിന്റ് ചെയ്യുക.

2. ഒരു നിശ്ചിത മൂല്യത്തേക്കാൾ വലിയ തുകയ്ക്ക് പൂക്കൾ വിറ്റ രസീത് കോഡുകളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

3. രസീത് തീയതി, തുക, വിതരണക്കാരന്റെ പേര്, നിറങ്ങൾ എന്നിവ ഒരു പ്രത്യേക വിതരണ കോഡ് ഉപയോഗിച്ച് പ്രദർശിപ്പിക്കുക.

4. കൂടുതൽ ഉയരമുള്ള പൂക്കളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക ഒരു നിശ്ചിത സംഖ്യഅല്ലെങ്കിൽ പൂക്കുന്നു.

ഓപ്ഷൻ 15

1. നിർദ്ദിഷ്ട കാലയളവിൽ മുറികളിൽ ചെക്ക് ഇൻ ചെയ്ത ക്ലയന്റുകളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

2. ഓരോ ക്ലയന്റിനുമുള്ള മുറികൾക്കുള്ള പേയ്മെന്റുകളുടെ ആകെ തുക പ്രദർശിപ്പിക്കുക.

3. എത്തിച്ചേരുന്ന തീയതി, റൂം തരം, നിർദ്ദിഷ്ട കാലയളവിൽ രജിസ്റ്റർ ചെയ്ത ക്ലയന്റുകളുടെ മുഴുവൻ പേര് എന്നിവ പ്രദർശിപ്പിക്കുക.

4. മുറികളിൽ രജിസ്റ്റർ ചെയ്ത ക്ലയന്റുകളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക ചില തരം.

ഓപ്ഷൻ 16

1. നിർദ്ദിഷ്ട തരത്തിലുള്ള ഉപകരണങ്ങളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

2. ഒരു പ്രത്യേക ക്ലയന്റ് വാടകയ്‌ക്കെടുത്ത ഉപകരണങ്ങളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

4. വിലാസം അനുസരിച്ച് അടുക്കിയിരിക്കുന്ന ക്ലയന്റുകളെക്കുറിച്ചുള്ള വിവരങ്ങൾ പ്രദർശിപ്പിക്കുക.

ഓപ്ഷൻ 17

1. വിലപിടിപ്പുള്ള വസ്തുക്കളുടെ ഒരു ലിസ്റ്റ് ഒരു നിശ്ചിത മൂല്യത്തേക്കാൾ കൂടുതലുള്ള വാങ്ങൽ വിലയോ ഒരു നിശ്ചിത സംഖ്യയേക്കാൾ വലിയ വാറന്റി കാലയളവോ പ്രദർശിപ്പിക്കുക.

2. നിർദ്ദിഷ്‌ട പദം ഉൾക്കൊള്ളുന്ന പേരുകളിൽ മെറ്റീരിയൽ അസറ്റുകളുടെ ലൊക്കേഷനുകളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

3. നിർദ്ദിഷ്ട ശ്രേണിയിൽ ഒരു കോഡ് ഉപയോഗിച്ച് മൂല്യങ്ങളുടെ മൂല്യത്തിന്റെ ആകെത്തുക പ്രദർശിപ്പിക്കുക.

4. നിർദിഷ്ട ശ്രേണിയിൽ തൊഴിൽ തീയതിയുമായി സാമ്പത്തികമായി ഉത്തരവാദിത്തമുള്ള വ്യക്തികളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

ഓപ്ഷൻ 18

1. ഒരു പ്രത്യേക ടെക്നീഷ്യൻ നടത്തുന്ന അറ്റകുറ്റപ്പണികളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

2. കൃതിയിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന വർക്ക് ഘട്ടങ്ങളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക, അതിന്റെ ശീർഷകത്തിൽ നിർദ്ദിഷ്ട വാക്ക് അടങ്ങിയിരിക്കുന്നു.

3. നിർദ്ദിഷ്‌ട ശ്രേണിയിൽ ഒരു കോഡ് ഉപയോഗിച്ച് ജോലിക്ക് വേണ്ടിയുള്ള റിപ്പയർ വർക്ക് ഘട്ടങ്ങളുടെ വിലയുടെ ആകെത്തുക പ്രദർശിപ്പിക്കുക.

4. നിർദ്ദിഷ്‌ട ശ്രേണിയിൽ നിയമന തീയതിയുമായി ഫോർമാൻമാരുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

ഓപ്ഷൻ 19

1. ഒരു പ്രത്യേക സൂചനയുള്ള മരുന്നുകളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

2. നിശ്ചിത എണ്ണത്തിൽ കൂടുതൽ മരുന്നുകൾ വിറ്റ രസീത് നമ്പറുകളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

3. വിൽപ്പന തീയതി, തുക, കാഷ്യറുടെ പേര്, മരുന്ന് എന്നിവ റസീറ്റിൽ നിർദ്ദിഷ്ട നമ്പറിനൊപ്പം പ്രദർശിപ്പിക്കുക.

4. മരുന്നുകളുടെ ഒരു ലിസ്റ്റ്, മരുന്നുകൾക്കായുള്ള അളവെടുപ്പ് യൂണിറ്റുകൾ എന്നിവ പാക്കേജിൽ നിർദ്ദിഷ്ട സംഖ്യയേക്കാൾ കൂടുതലോ അല്ലെങ്കിൽ ഒരു നിശ്ചിത മൂല്യത്തിൽ കുറവുള്ള ഒരു ഡ്രഗ് കോഡോ പ്രദർശിപ്പിക്കുക.

ഓപ്ഷൻ 20

1. നിർദ്ദിഷ്ട സ്ഥാനത്തുള്ള ജീവനക്കാരുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

3. നിർദ്ദിഷ്ട കാലയളവിൽ രജിസ്റ്റർ ചെയ്ത രേഖകളുടെ രജിസ്ട്രേഷൻ തീയതി, പ്രമാണ തരം, എക്സിക്യൂട്ടറുടെ മുഴുവൻ പേര്, നിർവ്വഹണ വസ്തുത എന്നിവ പ്രദർശിപ്പിക്കുക.

4. നിർദ്ദിഷ്ട ഡോക്യുമെന്റ് തരം അല്ലെങ്കിൽ ഒരു നിശ്ചിത ശ്രേണിയിൽ ഡോക്യുമെന്റ് കോഡ് ഉപയോഗിച്ച് രജിസ്റ്റർ ചെയ്ത പ്രമാണങ്ങളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

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

ഈ അധ്യായത്തിലെ വിഷയം ഡാറ്റാബേസ് ആപ്ലിക്കേഷൻ ഡെവലപ്പർമാർക്ക് വാഗ്ദാനം ചെയ്യുന്ന ഏറ്റവും ശക്തമായ ടൂളുകളിൽ ഒന്നാണ്. ഇന്റർബേസ് ഡാറ്റബിസിനസ് ലോജിക് നടപ്പിലാക്കാൻ സംഭരിച്ച നടപടിക്രമങ്ങൾ (ഇംഗ്ലീഷ്, സ്റ്റൈഡ് നടപടിക്രമങ്ങൾ) ആപ്ലിക്കേഷൻ ലോജിക്കിന്റെ ഒരു പ്രധാന ഭാഗം ഡാറ്റാബേസ് തലത്തിൽ നടപ്പിലാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു, അങ്ങനെ മുഴുവൻ ആപ്ലിക്കേഷന്റെയും പ്രകടനം വർദ്ധിപ്പിക്കുകയും ഡാറ്റ പ്രോസസ്സിംഗ് കേന്ദ്രീകരിക്കുകയും അസൈൻ ചെയ്‌തിരിക്കുന്ന പൂർത്തിയാക്കാൻ ആവശ്യമായ കോഡിന്റെ അളവ് കുറയ്ക്കുകയും ചെയ്യുന്നു. ചുമതലകൾ മിക്കവാറും എന്തും മതി സങ്കീർണ്ണമായ ആപ്ലിക്കേഷൻസംഭരിച്ച നടപടിക്രമങ്ങൾ ഉപയോഗിക്കാതെ ഡാറ്റാബേസുകൾ പൂർത്തിയാകില്ല.
മിക്ക റിലേഷണൽ ഡിബിഎംഎസുകൾക്കും പൊതുവായ, സംഭരിച്ച നടപടിക്രമങ്ങൾ ഉപയോഗിക്കുന്നതിന്റെ ഈ അറിയപ്പെടുന്ന നേട്ടങ്ങൾക്ക് പുറമേ, ഇന്റർബേസ് സംഭരിച്ച നടപടിക്രമങ്ങൾക്ക് ഏതാണ്ട് പൂർണ്ണമായ ഡാറ്റാ സെറ്റുകളായി പ്രവർത്തിക്കാൻ കഴിയും, ഇത് സാധാരണ 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;
സസ്പെൻഡ് ചെയ്യുക;
അവസാനിക്കുന്നു

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

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

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

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

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

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

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

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

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

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

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

ഈ അന്വേഷണം ഞങ്ങൾക്ക് ഒരു ഫല ഫീൽഡ് മാത്രമുള്ള ഒരു വരി തിരികെ നൽകും, അതിൽ 181.35, 23.09 എന്നീ സംഖ്യകളുടെ ആകെത്തുക, അതായത് 204.44.
അതിനാൽ, ഞങ്ങളുടെ നടപടിക്രമം സാധാരണ ഉപയോഗിക്കാനാകും SQL അന്വേഷണങ്ങൾ, ക്ലയന്റ് പ്രോഗ്രാമുകളിലും മറ്റ് HP അല്ലെങ്കിൽ ട്രിഗറുകളിലും എക്സിക്യൂട്ട് ചെയ്യുന്നു. സംഭരിച്ച നടപടിക്രമത്തിന്റെ അവസാനം 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 ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്നു, ഇത് ഏത് വ്യവസ്ഥകളുടെയും നിർവ്വഹണത്തെ ആശ്രയിച്ച് ബ്രാഞ്ചിംഗ് സംഘടിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. അതിന്റെ വാക്യഘടന സമാനമാണ്. പാസ്കൽ, സി തുടങ്ങിയ ഉയർന്ന തലത്തിലുള്ള പ്രോഗ്രാമിംഗ് ഭാഷകളിലെ മിക്ക ബ്രാഞ്ചിംഗ് ഓപ്പറേറ്റർമാർക്കും.
ഇനിപ്പറയുന്നവ ചെയ്യുന്ന ഒരു സംഭരിച്ച നടപടിക്രമത്തിന്റെ കൂടുതൽ സങ്കീർണ്ണമായ ഉദാഹരണം നോക്കാം.

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

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

IN Microsoft SQLനിങ്ങളുടെ സ്വന്തം അൽഗോരിതം നടപ്പിലാക്കുന്നതിനും ഓട്ടോമേറ്റ് ചെയ്യുന്നതിനുമുള്ള സെർവർ ( കണക്കുകൂട്ടലുകൾ) നിങ്ങൾക്ക് സംഭരിച്ച നടപടിക്രമങ്ങൾ ഉപയോഗിക്കാം, അതിനാൽ അവ എങ്ങനെ സൃഷ്‌ടിക്കുകയും പരിഷ്‌ക്കരിക്കുകയും ഇല്ലാതാക്കുകയും ചെയ്യുന്നു എന്നതിനെക്കുറിച്ച് ഇന്ന് നമ്മൾ സംസാരിക്കും.

എന്നാൽ ആദ്യം, ഒരു ചെറിയ സിദ്ധാന്തം, സംഭരിച്ച നടപടിക്രമങ്ങൾ എന്താണെന്നും അവ T-SQL-ൽ ആവശ്യമായിരിക്കുന്നത് എന്തുകൊണ്ടാണെന്നും നിങ്ങൾ മനസ്സിലാക്കുന്നു.

കുറിപ്പ്! തുടക്കക്കാരായ പ്രോഗ്രാമർമാർക്ക് ഞാൻ ഇനിപ്പറയുന്നവ ശുപാർശ ചെയ്യുന്നു: ഉപയോഗപ്രദമായ വസ്തുക്കൾ T-SQL എന്ന വിഷയത്തിൽ:

കൂടുതൽ വിശദമായ പഠനത്തിന് T-SQL ഭാഷപുസ്തകം വായിക്കാനും ഞാൻ ശുപാർശ ചെയ്യുന്നു - T-SQL പ്രോഗ്രാമറുടെ വഴി. ഇടപാട്-SQL ഭാഷാ ട്യൂട്ടോറിയൽ.

T-SQL-ൽ സംഭരിച്ചിരിക്കുന്ന നടപടിക്രമങ്ങൾ എന്തൊക്കെയാണ്?

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

SQL സെർവറിൽ ഒരു സംഭരിച്ച നടപടിക്രമം പ്രവർത്തിപ്പിക്കുന്നതിന്, നിങ്ങൾ EXECUTE കമാൻഡ് അതിന്റെ പേരിന് മുമ്പ് എഴുതണം; ഈ കമാൻഡ് EXEC എന്ന് ചുരുക്കാനും കഴിയും. ഒരു SELECT സ്റ്റേറ്റ്‌മെന്റിൽ സംഭരിച്ച നടപടിക്രമം വിളിക്കുന്നത്, ഉദാഹരണത്തിന്, ഒരു ഫംഗ്‌ഷൻ എന്ന നിലയിൽ ഇനി പ്രവർത്തിക്കില്ല, അതായത്. നടപടിക്രമങ്ങൾ പ്രത്യേകം സമാരംഭിക്കുന്നു.

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

ഒരു സംഭരിച്ച നടപടിക്രമം ഉണ്ടായിരിക്കാം ഇൻപുട്ട് പാരാമീറ്ററുകൾകൂടാതെ ഔട്ട്‌പുട്ട് പാരാമീറ്ററുകൾ, ഇതിന് ടാബ്‌ലർ ഡാറ്റ തിരികെ നൽകാം, അല്ലെങ്കിൽ അതിന് ഒന്നും നൽകാനാവില്ല, അതിൽ അടങ്ങിയിരിക്കുന്ന നിർദ്ദേശങ്ങൾ മാത്രം നടപ്പിലാക്കുക.

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

മൈക്രോസോഫ്റ്റ് SQL സെർവറിൽ സംഭരിച്ച നടപടിക്രമങ്ങളുമായി പ്രവർത്തിക്കുന്നതിനുള്ള ഉദാഹരണങ്ങൾ

ഉദാഹരണങ്ങൾക്കുള്ള ഉറവിട ഡാറ്റ

ചുവടെയുള്ള എല്ലാ ഉദാഹരണങ്ങളും Microsoft SQL Server 2016 Express-ൽ പ്രവർത്തിക്കും. യഥാർത്ഥ ഡാറ്റയുമായി സംഭരിച്ച നടപടിക്രമങ്ങൾ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് കാണിക്കുന്നതിന്, ഞങ്ങൾക്ക് ഈ ഡാറ്റ ആവശ്യമാണ്, നമുക്ക് ഇത് സൃഷ്ടിക്കാം. ഉദാഹരണത്തിന്, നമുക്ക് ഒരു ടെസ്റ്റ് ടേബിൾ സൃഷ്‌ടിച്ച് അതിൽ ചില റെക്കോർഡുകൾ ചേർക്കാം, അത് ഉൽപ്പന്നങ്ങളുടെ വിലകളുള്ള ഒരു പട്ടിക ഉൾക്കൊള്ളുന്ന ഒരു പട്ടികയായിരിക്കുമെന്ന് നമുക്ക് പറയാം.

ഒരു പട്ടിക സൃഷ്ടിക്കുന്നതിനുള്ള നിർദ്ദേശം ടേബിൾ ടെസ്റ്റ് ടേബിൾ സൃഷ്‌ടിക്കുക( INT ഐഡന്റിറ്റി(1,1) ശൂന്യമല്ല, INT ശൂന്യമല്ല, VARCHAR(100) അസാധുവല്ല, പണം NULL) പോകുക -- ഡാറ്റ ചേർക്കുന്നതിനുള്ള നിർദ്ദേശം ടെസ്റ്റ് ടേബിളിലേക്ക് ചേർക്കുക(വിഭാഗം, ഉൽപ്പന്നം) മൂല്യങ്ങൾ (1 , "മൗസ്", 100), (1, "കീബോർഡ്", 200), (2, "ഫോൺ", 400) GO --ടെസ്റ്റ് ടേബിളിൽ നിന്ന് ചോദ്യം തിരഞ്ഞെടുക്കുക *

ഞങ്ങൾക്ക് ഡാറ്റയുണ്ട്, ഇപ്പോൾ നമുക്ക് സംഭരിച്ച നടപടിക്രമങ്ങൾ സൃഷ്ടിക്കുന്നതിലേക്ക് പോകാം.

T-SQL-ൽ ഒരു സംഭരിച്ച നടപടിക്രമം സൃഷ്ടിക്കുന്നു - ക്രിയേറ്റ് പ്രൊസീഡർ പ്രസ്താവന

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

ഉദാഹരണത്തിന്, ചേർക്കുന്ന ഒരു സംഭരിച്ച നടപടിക്രമം എഴുതാം പുതിയ പ്രവേശനം, അതായത്. പുതിയ ഉൽപ്പന്നംഞങ്ങളുടെ ടെസ്റ്റ് ടേബിളിലേക്ക്. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ മൂന്ന് ഇൻപുട്ട് പാരാമീറ്ററുകൾ നിർവ്വചിക്കും: @CategoryId - ഉൽപ്പന്ന വിഭാഗം ഐഡന്റിഫയർ, @ProductName - ഉൽപ്പന്നത്തിന്റെ പേര്, @Price - ഉൽപ്പന്ന വില; ഈ പാരാമീറ്റർ ഓപ്ഷണൽ ആയിരിക്കും, അതായത്. ഇത് നടപടിക്രമത്തിലേക്ക് മാറ്റേണ്ട ആവശ്യമില്ല ( ഉദാഹരണത്തിന്, ഞങ്ങൾക്ക് ഇതുവരെ വില അറിയില്ല), ഈ ആവശ്യത്തിനായി ഞങ്ങൾ അതിന്റെ നിർവചനത്തിൽ ഒരു സ്ഥിര മൂല്യം സജ്ജമാക്കും. ഈ പരാമീറ്ററുകൾ നടപടിക്രമത്തിന്റെ ശരീരത്തിലാണ്, അതായത്. സാധാരണ വേരിയബിളുകൾ പോലെ തന്നെ BEGIN...END ബ്ലോക്ക് ഉപയോഗിക്കാം ( നിങ്ങൾക്കറിയാവുന്നതുപോലെ, വേരിയബിളുകൾ @ ചിഹ്നത്താൽ സൂചിപ്പിക്കുന്നു). നിങ്ങൾക്ക് ഔട്ട്പുട്ട് പാരാമീറ്ററുകൾ വ്യക്തമാക്കണമെങ്കിൽ, പരാമീറ്ററിന്റെ പേരിന് ശേഷം കീവേഡ് OUTPUT സൂചിപ്പിക്കുക ( അല്ലെങ്കിൽ ചുരുക്കത്തിൽ ഔട്ട്).

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

ഈ നടപടിക്രമത്തിനുള്ള കോഡ് ഇതാ ( ഞാനും അതിൽ അഭിപ്രായം പറഞ്ഞു).

ഒരു നടപടിക്രമം സൃഷ്‌ടിക്കുക നടപടിക്രമം സൃഷ്‌ടിക്കുക ടെസ്റ്റ് പ്രൊസീജർ (--ഇൻപുട്ട് പാരാമീറ്ററുകൾ @CategoryId INT, @ProductName VARCHAR(100), @Price MONEY = 0) തുടക്കത്തിൽ തന്നെ --നിങ്ങളുടെ അൽഗോരിതം നടപ്പിലാക്കുന്ന നിർദ്ദേശങ്ങൾ --പ്രാരംഭത്തിൽ ഇൻകമിംഗ് അധിക പാരാമീറ്ററുകൾ പ്രോസസ്സ് ചെയ്യുന്നു -- ടെക്സ്റ്റ് ലൈനിന്റെ അവസാനം @ProductName = LTRIM(RTRIM(@ProductName)); --ടെസ്റ്റ് ടേബിളിലേക്ക് ഒരു പുതിയ റെക്കോർഡ് ചേർക്കുക (വിഭാഗം ഐഡി, ഉൽപ്പന്ന നാമം, വില) മൂല്യങ്ങൾ (@CategoryId, @ProductName, @Price) --ഡാറ്റ തിരികെ നൽകുക ടെസ്റ്റ് ടേബിളിൽ നിന്ന് തിരഞ്ഞെടുക്കുക * എവിടെയാണ് CategoryId = @CategoryId അവസാനിക്കുക

T-SQL - EXECUTE കമാൻഡിൽ ഒരു സംഭരിച്ച നടപടിക്രമം പ്രവർത്തിപ്പിക്കുന്നു

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

സ്ഥിരസ്ഥിതി മൂല്യങ്ങളുള്ള പാരാമീറ്ററുകൾ വ്യക്തമാക്കേണ്ടതില്ല; ഇവ ഓപ്ഷണൽ പാരാമീറ്ററുകൾ എന്ന് വിളിക്കപ്പെടുന്നവയാണ്.

സംഭരിച്ച നടപടിക്രമങ്ങൾ പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള വ്യത്യസ്തവും എന്നാൽ തുല്യവുമായ ചില വഴികൾ ഇതാ, പ്രത്യേകിച്ച് ഞങ്ങളുടെ ടെസ്റ്റ് നടപടിക്രമം.

1. വില വ്യക്തമാക്കാതെ നടപടിക്രമത്തിലേക്ക് വിളിക്കുക ടെസ്റ്റ്പ്രോസീഡ് നടപ്പിലാക്കുക @CategoryId = 1, @ProductName = " ടെസ്റ്റ് ഉൽപ്പന്നം 1" --2. വില വ്യക്തമാക്കുന്ന നടപടിക്രമത്തിലേക്ക് വിളിക്കുക EXEC TestProcedure @CategoryId = 1, @ProductName = "ടെസ്റ്റ് ഉൽപ്പന്നം 2", @Price = 300 --3. EXEC TestProcedure 1 എന്ന പാരാമീറ്ററുകളുടെ പേര് വ്യക്തമാക്കാതെ നടപടിക്രമത്തിലേക്ക് വിളിക്കുക, "ടെസ്റ്റ് ഉൽപ്പന്നം 3", 400

സംഭരിച്ച നടപടിക്രമം T-SQL-ലേക്ക് മാറ്റുന്നു - നടപടിക്രമം മാറ്റുക

നിർദ്ദേശങ്ങൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് നടപടിക്രമത്തിന്റെ അൽഗോരിതത്തിൽ മാറ്റങ്ങൾ വരുത്താം നടപടിക്രമം മാറ്റുക. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, നിലവിലുള്ള ഒരു നടപടിക്രമം മാറ്റുന്നതിന്, നിങ്ങൾ ക്രിയേറ്റ് പ്രൊസീഡറിന് പകരം ALTER PROCEDURE എന്നെഴുതിയാൽ മതി, മറ്റെല്ലാം ആവശ്യാനുസരണം മാറ്റുക.

ഞങ്ങളുടെ ടെസ്റ്റ് നടപടിക്രമത്തിൽ മാറ്റങ്ങൾ വരുത്തേണ്ടതുണ്ടെന്ന് പറയാം, @Price പാരാമീറ്റർ പറയുക, അതായത്. വില, ഞങ്ങൾ ഇത് നിർബന്ധമാക്കും, ഇതിനായി ഞങ്ങൾ സ്ഥിരസ്ഥിതി മൂല്യം നീക്കംചെയ്യും, കൂടാതെ തത്ഫലമായുണ്ടാകുന്ന ഡാറ്റാ സെറ്റ് ഇനി ലഭിക്കേണ്ടതില്ലെന്നും സങ്കൽപ്പിക്കുക, ഇതിനായി ഞങ്ങൾ സംഭരിച്ച നടപടിക്രമത്തിൽ നിന്ന് SELECT പ്രസ്താവന നീക്കംചെയ്യും.

ALTER PROCEDURE TestProcedure (--ഇൻകമിംഗ് പാരാമീറ്ററുകൾ @CategoryId INT, @ProductName VARCHAR(100), @Price MONEY) എന്ന നടപടിക്രമം ഞങ്ങൾ മാറ്റുന്നു ടെക്സ്റ്റ് ലൈനുകളുടെ അവസാനം SET @ProductName = LTRIM(RTRIM(@ProductName)); --ഒരു പുതിയ റെക്കോർഡ് ചേർക്കുക ടെസ്റ്റ് ടേബിളിലേക്ക് ചേർക്കുക (വിഭാഗം ഐഡി, ഉൽപ്പന്നത്തിന്റെ പേര്, വില) മൂല്യങ്ങൾ (@CategoryId, @ProductName, @Price) അവസാനിപ്പിക്കുക

T-SQL-ൽ സംഭരിച്ച നടപടിക്രമം ഇല്ലാതാക്കുന്നു - ഡ്രോപ്പ് പ്രൊസീഡർ പ്രസ്താവന

ആവശ്യമെങ്കിൽ, നിങ്ങൾക്ക് സംഭരിച്ച നടപടിക്രമം ഇല്ലാതാക്കാം; ഇത് നിർദ്ദേശങ്ങൾ ഉപയോഗിച്ചാണ് ചെയ്യുന്നത് ഡ്രോപ്പ് നടപടിക്രമം.

ഉദാഹരണത്തിന്, ഞങ്ങൾ സൃഷ്ടിച്ച ടെസ്റ്റ് നടപടിക്രമം ഇല്ലാതാക്കാം.

ഡ്രോപ്പ് നടപടിക്രമം ടെസ്റ്റ് നടപടിക്രമം

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

എനിക്ക് അത്രയേയുള്ളൂ, മെറ്റീരിയൽ നിങ്ങൾക്ക് രസകരവും ഉപയോഗപ്രദവുമാണെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു, ബൈ!

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

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

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

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

ട്രിഗറുകൾ

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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