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

സംഭരിച്ച നടപടിക്രമങ്ങൾ ഉപയോക്തൃ-നിർവചിച്ച പ്രവർത്തനങ്ങൾക്ക് (യുഡിഎഫ്) സമാനമാണ്. ഒരു SQL പ്രസ്താവനയിലെ മറ്റേതൊരു എക്സ്പ്രഷനും പോലെ ഉപയോക്തൃ-നിർവചിച്ച ഫംഗ്ഷനുകൾ ഉപയോഗിക്കാമെന്നതാണ് പ്രധാന വ്യത്യാസം, അതേസമയം സംഭരിച്ച നടപടിക്രമങ്ങൾ കോൾ ഫംഗ്ഷൻ ഉപയോഗിച്ച് വിളിക്കണം:

കോൾ നടപടിക്രമം(...)

നടപടിക്രമം നടപ്പിലാക്കുക(...)

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

സംഭരിച്ച നടപടിക്രമങ്ങൾ നടപ്പിലാക്കുന്നത് ഒരു ഡിബിഎംഎസിൽ നിന്ന് മറ്റൊന്നിലേക്ക് വ്യത്യാസപ്പെടുന്നു. മിക്ക പ്രധാന ഡാറ്റാബേസ് വെണ്ടർമാരും ഒരു രൂപത്തിൽ അല്ലെങ്കിൽ മറ്റൊന്നിൽ അവരെ പിന്തുണയ്ക്കുന്നു. DBMS-നെ ആശ്രയിച്ച്, SQL, Java, C അല്ലെങ്കിൽ C++ പോലുള്ള വിവിധ പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ സംഭരിച്ച നടപടിക്രമങ്ങൾ നടപ്പിലാക്കാൻ കഴിയും. SQL-ൽ എഴുതിയിട്ടില്ലാത്ത സംഭരിച്ച നടപടിക്രമങ്ങൾ SQL ചോദ്യങ്ങൾ സ്വന്തമായി നടപ്പിലാക്കുകയോ ചെയ്യാതിരിക്കുകയോ ചെയ്യാം.

പിന്നിൽ

മറ്റ് ആപ്ലിക്കേഷനുകളുമായി യുക്തി പങ്കിടുന്നു. സംഭരിച്ച നടപടിക്രമങ്ങൾ പ്രവർത്തനക്ഷമതയെ ഉൾക്കൊള്ളുന്നു; ഇത് വിവിധ ആപ്ലിക്കേഷനുകളിലുടനീളം ഡാറ്റ ആക്‌സസ്സിനും മാനേജ്മെന്റിനുമുള്ള കണക്റ്റിവിറ്റി നൽകുന്നു.

ഡാറ്റാബേസ് പട്ടികകളിൽ നിന്ന് ഉപയോക്താക്കളെ ഒറ്റപ്പെടുത്തുന്നു. സംഭരിച്ച നടപടിക്രമങ്ങളിലേക്ക് ആക്സസ് നൽകാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു, പക്ഷേ പട്ടിക ഡാറ്റയിലേക്കല്ല.

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

കുറഞ്ഞ നെറ്റ്‌വർക്ക് ട്രാഫിക്കിന്റെ ഫലമായി മെച്ചപ്പെട്ട നിർവ്വഹണം. സംഭരിച്ച നടപടിക്രമങ്ങൾ ഉപയോഗിച്ച്, ഒന്നിലധികം ചോദ്യങ്ങൾ സംയോജിപ്പിക്കാൻ കഴിയും.

എതിരായി

ഭൂരിഭാഗം ജോലികളും സെർവർ വശത്തും ക്ലയന്റ് വശത്ത് കുറവാണ് എന്നതും കാരണം ഡാറ്റാബേസ് സെർവറിൽ ലോഡ് വർദ്ധിച്ചു.

ഒരുപാട് പഠിക്കേണ്ടി വരും. നിങ്ങളുടെ സംഭരിച്ച നടപടിക്രമങ്ങൾ എഴുതാൻ നിങ്ങൾ MySQL എക്സ്പ്രഷൻ സിന്റാക്സ് പഠിക്കേണ്ടതുണ്ട്.

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

ഒരു DBMS-ൽ നിന്ന് മറ്റൊന്നിലേക്ക് (DB2, SQL സെർവർ മുതലായവ) മൈഗ്രേഷൻ പ്രശ്‌നങ്ങളിലേക്ക് നയിച്ചേക്കാം.

സംഭരിച്ച നടപടിക്രമങ്ങളുടെ ഉദ്ദേശ്യവും പ്രയോജനങ്ങളും

സംഭരിച്ച നടപടിക്രമങ്ങൾ പ്രകടനം മെച്ചപ്പെടുത്തുന്നു, പ്രോഗ്രാമിംഗ് കഴിവുകൾ മെച്ചപ്പെടുത്തുന്നു, കൂടാതെ ഡാറ്റ സുരക്ഷാ സവിശേഷതകൾ പിന്തുണയ്ക്കുന്നു.

പതിവായി ഉപയോഗിക്കുന്ന ചോദ്യം സംഭരിക്കുന്നതിനുപകരം, ക്ലയന്റുകൾക്ക് അനുബന്ധ സംഭരിച്ച നടപടിക്രമം റഫറൻസ് ചെയ്യാൻ കഴിയും. സംഭരിച്ച നടപടിക്രമം വിളിക്കുമ്പോൾ, അതിന്റെ ഉള്ളടക്കങ്ങൾ സെർവർ ഉടൻ പ്രോസസ്സ് ചെയ്യുന്നു.

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

മിക്ക DBMS-കളിലും, ആദ്യമായി സംഭരിച്ച നടപടിക്രമം പ്രവർത്തിപ്പിക്കുമ്പോൾ, അത് കംപൈൽ ചെയ്യപ്പെടുന്നു (പാഴ്‌സ് ചെയ്യുകയും ഒരു ഡാറ്റ ആക്‌സസ് പ്ലാൻ സൃഷ്‌ടിക്കുകയും ചെയ്യുന്നു). ഭാവിയിൽ, അതിന്റെ പ്രോസസ്സിംഗ് വേഗത്തിലാണ്. ഡാറ്റാ നിഘണ്ടുവിൽ സംഭരിച്ചിരിക്കുന്ന സംഭരിച്ച നടപടിക്രമ കോഡിനെ Oracle DBMS വ്യാഖ്യാനിക്കുന്നു. Oracle 10g മുതൽ, C യിൽ സംഭരിച്ച പ്രൊസീജറൽ കോഡിന്റെ നേറ്റീവ് കംപൈലേഷൻ എന്ന് വിളിക്കപ്പെടുന്നതും തുടർന്ന് ടാർഗെറ്റ് മെഷീന്റെ മെഷീൻ കോഡിലേക്കും പിന്തുണയ്‌ക്കുന്നു, അതിനുശേഷം, ഒരു സംഭരിച്ച നടപടിക്രമം വിളിക്കുമ്പോൾ, അതിന്റെ കംപൈൽ ചെയ്ത ഒബ്‌ജക്റ്റ് കോഡ് നേരിട്ട് എക്‌സിക്യൂട്ട് ചെയ്യപ്പെടും.

പ്രോഗ്രാമിംഗ് കഴിവുകൾ

സൃഷ്ടിച്ച സംഭരിച്ച നടപടിക്രമം ഏത് സമയത്തും വിളിക്കാം, ഇത് മോഡുലാരിറ്റി നൽകുകയും കോഡ് പുനരുപയോഗം പ്രോത്സാഹിപ്പിക്കുകയും ചെയ്യുന്നു. ബിസിനസ്സ് നിയമങ്ങൾ മാറ്റുന്നതിൽ നിന്ന് ഒറ്റപ്പെട്ടതിനാൽ രണ്ടാമത്തേത് ഡാറ്റാബേസ് പരിപാലിക്കുന്നത് എളുപ്പമാക്കുന്നു. നിങ്ങൾക്ക് എപ്പോൾ വേണമെങ്കിലും പുതിയ നിയമങ്ങൾക്കനുസൃതമായി സംഭരിച്ച നടപടിക്രമം പരിഷ്കരിക്കാനാകും. ഇതിനുശേഷം, ഇത് ഉപയോഗിക്കുന്ന എല്ലാ ആപ്ലിക്കേഷനുകളും നേരിട്ട് പരിഷ്‌ക്കരിക്കാതെ തന്നെ പുതിയ ബിസിനസ്സ് നിയമങ്ങൾ പാലിക്കുന്നതിലേക്ക് വരും.

സുരക്ഷ

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

ഈ സുരക്ഷാ സവിശേഷതകൾ ഡാറ്റാബേസ് ഘടനയെ ഉപയോക്താവിൽ നിന്ന് ഒറ്റപ്പെടുത്താൻ അനുവദിക്കുന്നു, ഡാറ്റാബേസ് സമഗ്രതയും വിശ്വാസ്യതയും ഉറപ്പാക്കുന്നു.

SQL കുത്തിവയ്പ്പ് പോലുള്ള പ്രവർത്തനങ്ങളുടെ സാധ്യത കുറയുന്നു, കാരണം നന്നായി എഴുതിയ സംഭരിച്ച നടപടിക്രമങ്ങൾ DBMS-ലേക്ക് ചോദ്യം കൈമാറുന്നതിന് മുമ്പ് ഇൻപുട്ട് പാരാമീറ്ററുകൾ പരിശോധിക്കുന്നു.

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

SQL ഭാഷ ഉപയോഗിച്ചോ അല്ലെങ്കിൽ തിരഞ്ഞെടുത്ത DBMS-ൽ അതിന്റെ നിർദ്ദിഷ്‌ട നടപ്പാക്കൽ ഉപയോഗിച്ചോ ആണ് സാധാരണയായി സംഭരിച്ച നടപടിക്രമങ്ങൾ സൃഷ്ടിക്കുന്നത്. ഉദാഹരണത്തിന്, ഈ ആവശ്യങ്ങൾക്ക്, Microsoft SQL സെർവർ DBMS-ൽ Transact-SQL ഭാഷയുണ്ട്, Oracle - PL/SQL, InterBase, Firebird - PSQL, PostgreSQL-ൽ - PL/pgSQL, PL/Tcl, PL/Perl, PL/Python, IBM DB2-ൽ - SQL/PL (ഇംഗ്ലീഷ്), Informix-ൽ - SPL. MySQL SQL:2003 സ്റ്റാൻഡേർഡ് വളരെ അടുത്ത് പിന്തുടരുന്നു, അതിന്റെ ഭാഷ SQL/PL പോലെയാണ്.

സ്വതന്ത്ര എക്സിക്യൂട്ടബിൾ ഫയലുകൾ സൃഷ്ടിക്കാൻ കഴിയുന്ന ഏതെങ്കിലും പ്രോഗ്രാമിംഗ് ഭാഷയിൽ എഴുതിയ സംഭരിച്ച നടപടിക്രമങ്ങൾ ചില DBMS-കൾ അനുവദിക്കുന്നു, ഉദാഹരണത്തിന്, C++ അല്ലെങ്കിൽ Delphi. മൈക്രോസോഫ്റ്റ് SQL സെർവർ ടെർമിനോളജിയിൽ, അത്തരം നടപടിക്രമങ്ങളെ വിപുലീകൃത സംഭരിച്ച നടപടിക്രമങ്ങൾ എന്ന് വിളിക്കുന്നു, അവ ഒരു Win32 DLL-ൽ അടങ്ങിയിരിക്കുന്ന പ്രവർത്തനങ്ങളാണ്. കൂടാതെ, ഉദാഹരണത്തിന്, ഇന്റർബേസിലും ഫയർബേർഡിലും, DLL/SO-ൽ നിന്ന് വിളിക്കുന്ന ഫംഗ്‌ഷനുകൾക്ക് മറ്റൊരു പേരുണ്ട് - UDF (User Defined Function). MS SQL 2005, ഏത് .NET ഭാഷയിലും സംഭരിച്ച നടപടിക്രമങ്ങൾ എഴുതാനുള്ള കഴിവ് അവതരിപ്പിച്ചു, കൂടാതെ വിപുലമായ സംഭരിച്ച നടപടിക്രമങ്ങൾ ഭാവിയിൽ ഉപേക്ഷിക്കാൻ പദ്ധതിയിടുന്നു. Oracle DBMS, ജാവയിൽ സംഭരിച്ച നടപടിക്രമങ്ങൾ എഴുതാൻ അനുവദിക്കുന്നു. IBM DB2-ൽ, പരമ്പരാഗത പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ സംഭരിച്ച നടപടിക്രമങ്ങളും പ്രവർത്തനങ്ങളും എഴുതുന്നത് ഒരു പരമ്പരാഗത മാർഗമാണ്, ആദ്യം മുതൽ പിന്തുണയ്ക്കുന്നു, കൂടാതെ SQL പ്രൊസീജറൽ എക്സ്റ്റൻഷൻ ഈ DBMS-ലേക്ക് ANSI സ്റ്റാൻഡേർഡിൽ ഉൾപ്പെടുത്തിയതിന് ശേഷം വളരെ വൈകിയുള്ള പതിപ്പുകളിൽ മാത്രമാണ് ചേർത്തത്. Informix ജാവയിലും Cയിലും നടപടിക്രമങ്ങളെ പിന്തുണയ്ക്കുന്നു.

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

IBM DB2 DBMS-ൽ, സംഭരിച്ച നടപടിക്രമങ്ങൾ മൊഡ്യൂളുകളായി സംയോജിപ്പിക്കാൻ കഴിയും.

വാക്യഘടന

നടപടിക്രമം സൃഷ്‌ടിക്കുക `p2`()

SQL സെക്യൂരിറ്റി നിർവചനം

അഭിപ്രായം "ഒരു നടപടിക്രമം"

"ഹലോ വേൾഡ്!" തിരഞ്ഞെടുക്കുക;

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

സംഭരിച്ച നടപടിക്രമത്തിന്റെ 4 സവിശേഷതകൾ:

ഭാഷ: പോർട്ടബിലിറ്റി ആവശ്യങ്ങൾക്കായി, ഡിഫോൾട്ട് SQL ആണ്.

ഡിറ്റർമിനിസ്റ്റിക്: നടപടിക്രമം എല്ലായ്പ്പോഴും ഒരേ ഫലം നൽകുകയും ഒരേ ഇൻപുട്ട് പാരാമീറ്ററുകൾ എടുക്കുകയും ചെയ്യുന്നുവെങ്കിൽ. ഇത് പകർപ്പെടുക്കലിനും രജിസ്ട്രേഷൻ പ്രക്രിയയ്ക്കും വേണ്ടിയാണ്. ഡിഫോൾട്ട് മൂല്യം നിർണ്ണായകമല്ല.

SQL സുരക്ഷ: കോൾ സമയത്ത് ഉപയോക്തൃ അവകാശങ്ങൾ പരിശോധിക്കുന്നു. സംഭരിച്ച നടപടിക്രമം വിളിക്കുന്ന ഉപയോക്താവാണ് INVOKER. defINER ആണ് നടപടിക്രമത്തിന്റെ "സ്രഷ്ടാവ്". ഡിഫോൾട്ട് മൂല്യം DEFINER ആണ്.

അഭിപ്രായം: ഡോക്യുമെന്റേഷൻ ആവശ്യങ്ങൾക്ക്, സ്ഥിരസ്ഥിതി മൂല്യം "" ആണ്

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

സംഭരിച്ച_പ്രക്രിയ_നാമം വിളിക്കുക (പാരം1, പാരം2, ....)

കോൾ നടപടിക്രമം1(10 , "സ്ട്രിംഗ് പാരാമീറ്റർ" , @parameter_var);

സംഭരിച്ച നടപടിക്രമം പരിഷ്ക്കരിക്കുന്നു

നടപടിക്രമങ്ങൾ മാറ്റുന്നതിന് MySQL-ന് ഒരു ALTER PROCEDURE സ്റ്റേറ്റ്‌മെന്റ് ഉണ്ട്, എന്നാൽ ഇത് ചില സവിശേഷതകൾ മാറ്റുന്നതിന് മാത്രമേ അനുയോജ്യമാകൂ. നിങ്ങൾക്ക് ഒരു നടപടിക്രമത്തിന്റെ പാരാമീറ്ററുകളോ ബോഡിയോ മാറ്റണമെങ്കിൽ, നിങ്ങൾ അത് ഇല്ലാതാക്കുകയും പുനഃസൃഷ്ടിക്കുകയും വേണം.

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

നിലവിലുണ്ടെങ്കിൽ ഡ്രോപ്പ് നടപടിക്രമം p2;

ഇതൊരു ലളിതമായ ആജ്ഞയാണ്. അത്തരമൊരു നടപടിക്രമം നിലവിലില്ലെങ്കിൽ, IF EXISTS പ്രസ്താവനയിൽ ഒരു പിശക് സംഭവിക്കുന്നു.

ഓപ്ഷനുകൾ

നടപടിക്രമം സൃഷ്ടിക്കുക proc1(): ശൂന്യമായ പാരാമീറ്റർ ലിസ്റ്റ്

പ്രൊസീഡർ പ്രോസി1 സൃഷ്ടിക്കുക (ഡാറ്റ-ടൈപ്പ് വർണ്ണത്തിൽ): ഒരു ഇൻപുട്ട് പാരാമീറ്റർ. ഡിഫോൾട്ട് പാരാമീറ്ററുകൾ IN (in) ആയതിനാൽ IN എന്ന വാക്ക് ഓപ്ഷണൽ ആണ്.

പ്രൊസീഡർ പ്രോസി1 സൃഷ്‌ടിക്കുക (ഡാറ്റ-ടൈപ്പ് വർണ്ണം): ഒരു പാരാമീറ്റർ തിരികെ നൽകി.

പ്രൊസീഡർ പ്രോസി1 സൃഷ്‌ടിക്കുക (ഇനൗട്ട് വർണ്ണം ഡാറ്റ-ടൈപ്പ്): ഇൻപുട്ടും റിട്ടേണും ഒരു പരാമീറ്റർ.

വേരിയബിൾ ഡിക്ലറേഷൻ വാക്യഘടന ഇതുപോലെ കാണപ്പെടുന്നു:

varname DATA-TYPE ഡിഫോൾട്ട് ഡിഫോൾട്ട് മൂല്യം പ്രഖ്യാപിക്കുക;

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

ആമുഖം

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

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

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

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

ഉത്പാദനക്ഷമത

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

സുരക്ഷ

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

ഡാറ്റ കൈമാറ്റം

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

ഒരു ഔട്ട്പുട്ട് തരം പാരാമീറ്റർ ഉപയോഗിച്ച് ഡാറ്റ കൈമാറുന്നു;

റിട്ടേൺ ഓപ്പറേറ്റർ ഉപയോഗിച്ച് ഡാറ്റ കൈമാറുന്നു;

തിരഞ്ഞെടുത്ത ഓപ്പറേറ്റർ ഉപയോഗിച്ച് ഡാറ്റ കൈമാറുന്നു.

ഈ പ്രക്രിയ ഉള്ളിൽ നിന്ന് എങ്ങനെയുണ്ടെന്ന് ഇപ്പോൾ നമുക്ക് കണ്ടെത്താം.

1. SQL-ൽ ഒരു EXEC സംഭരിച്ച നടപടിക്രമം സൃഷ്ടിക്കുക

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

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

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

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

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

ശരീരം മറ്റേതെങ്കിലും സംഭരിച്ച നടപടിക്രമങ്ങൾ ഉണ്ടാക്കരുത്;

ശരീരം വസ്തുവിന്റെ തെറ്റായ ധാരണ സൃഷ്ടിക്കരുത്;

ശരീരം ട്രിഗറുകൾ സൃഷ്ടിക്കാൻ പാടില്ല.

2. നടപടിക്രമത്തിന്റെ ശരീരത്തിൽ ഒരു വേരിയബിൾ സജ്ജീകരിക്കുന്നു

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

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

ഉപയോക്താക്കൾ പലപ്പോഴും ചോദ്യം ചോദിക്കുന്നു: "ഒരു നടപടിക്രമത്തിന്റെ ബോഡിയിൽ ഒരു പ്രസ്താവനയിൽ ഒന്നിലധികം മൂല്യങ്ങൾ എങ്ങനെ നൽകാം?" നന്നായി. ഇതൊരു രസകരമായ ചോദ്യമാണ്, എന്നാൽ നിങ്ങൾ വിചാരിക്കുന്നതിലും വളരെ എളുപ്പമാണ് ഇത് ചെയ്യാൻ. ഉത്തരം: "Select Var = value" പോലുള്ള ജോഡികൾ ഉപയോഗിക്കുന്നു. ഈ ജോഡികളെ കോമ ഉപയോഗിച്ച് വേർപെടുത്തി നിങ്ങൾക്ക് ഉപയോഗിക്കാം.

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

മുമ്പത്തെ ഉദാഹരണത്തിൽ, നടപടിക്രമം രണ്ട് പാരാമീറ്ററുകൾ എടുക്കുന്നു, അതിനെ ഇംഗ്ലീഷിൽ പരമ്പരാഗതമായി @State എന്നും @City എന്നും വിളിക്കും. ഡാറ്റ തരം ആപ്ലിക്കേഷനിൽ നിർവചിച്ചിരിക്കുന്ന തരവുമായി പൊരുത്തപ്പെടുന്നു. നടപടിക്രമത്തിന്റെ ബോഡിയിൽ @TotalAuthors ആന്തരിക വേരിയബിളുകൾ ഉണ്ട്, രചയിതാക്കളുടെ എണ്ണം പ്രദർശിപ്പിക്കാൻ ഈ വേരിയബിൾ ഉപയോഗിക്കുന്നു. അടുത്തതായി എല്ലാം കണക്കാക്കുന്ന അന്വേഷണ സെലക്ഷൻ വിഭാഗം വരുന്നു. അവസാനമായി, കണക്കുകൂട്ടിയ മൂല്യം പ്രിന്റ് സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിച്ച് ഔട്ട്പുട്ട് വിൻഡോയിൽ പ്രിന്റ് ചെയ്യുന്നു.

SQL-ൽ സംഭരിച്ച നടപടിക്രമം എങ്ങനെ നിർവഹിക്കാം

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

നടപടിക്രമം സാധാരണയിൽ നിന്ന് അല്പം വ്യതിചലിച്ചേക്കാം. എല്ലാം മുമ്പത്തെ ഉദാഹരണത്തിൽ സമാനമാണ്, എന്നാൽ ഇവിടെ മാത്രം പരാമീറ്ററുകൾ മാറ്റുന്നു. അതായത്, @City ആദ്യം സംഭരിക്കുകയും @State സ്ഥിര മൂല്യത്തിന് അടുത്തായി സംഭരിക്കുകയും ചെയ്യുന്നു. സ്ഥിരസ്ഥിതി പരാമീറ്റർ സാധാരണയായി പ്രത്യേകം ഹൈലൈറ്റ് ചെയ്യുന്നു. SQL സംഭരിച്ച നടപടിക്രമങ്ങൾ പാരാമീറ്ററുകൾ മാത്രമായി കൈമാറുന്നു. ഈ സാഹചര്യത്തിൽ, നൽകിയിരിക്കുന്നത്, "UT" എന്ന പരാമീറ്റർ സ്ഥിരസ്ഥിതി മൂല്യമായ "CA" മാറ്റിസ്ഥാപിക്കുന്നു. രണ്ടാമത്തെ നിർവ്വഹണത്തിൽ, @City പാരാമീറ്ററിനായി ഒരു ആർഗ്യുമെന്റ് മൂല്യം മാത്രമേ നൽകൂ, @State പാരാമീറ്റർ "CA" യുടെ സ്ഥിര മൂല്യം എടുക്കുന്നു. എല്ലാ വേരിയബിളുകളും സ്ഥിരസ്ഥിതിയായി പാരാമീറ്റർ ലിസ്റ്റിന്റെ അവസാനത്തിൽ സ്ഥിതിചെയ്യണമെന്ന് പരിചയസമ്പന്നരായ പ്രോഗ്രാമർമാർ ഉപദേശിക്കുന്നു. അല്ലാത്തപക്ഷം നിർവ്വഹണം സാധ്യമല്ല, തുടർന്ന് നിങ്ങൾ പേരുള്ള ആർഗ്യുമെന്റുകൾ പാസാക്കിക്കൊണ്ട് പ്രവർത്തിക്കണം, അത് ദൈർഘ്യമേറിയതും കൂടുതൽ സങ്കീർണ്ണവുമാണ്.

4. SQL സെർവർ സംഭരിച്ച നടപടിക്രമങ്ങൾ: റിട്ടേൺ രീതികൾ

സംഭരിച്ച നടപടിക്രമത്തിൽ ഡാറ്റ അയയ്‌ക്കാൻ മൂന്ന് പ്രധാന വഴികളുണ്ട്. അവ ചുവടെ പട്ടികപ്പെടുത്തിയിരിക്കുന്നു:

സംഭരിച്ച നടപടിക്രമത്തിന്റെ മൂല്യം തിരികെ നൽകുക;

സംഭരിച്ച നടപടിക്രമ പാരാമീറ്റർ ഔട്ട്പുട്ട്;

സംഭരിച്ച നടപടിക്രമങ്ങളിലൊന്ന് തിരഞ്ഞെടുക്കുന്നു.

4.1 SQL സംഭരിച്ച നടപടിക്രമങ്ങളിൽ നിന്ന് മൂല്യങ്ങൾ തിരികെ നൽകുന്നു

ഈ സാങ്കേതികതയിൽ, ഒരു നടപടിക്രമം ഒരു ലോക്കൽ വേരിയബിളിന് ഒരു മൂല്യം നൽകുകയും അത് തിരികെ നൽകുകയും ചെയ്യുന്നു. ഒരു നടപടിക്രമത്തിന് സ്ഥിരമായ മൂല്യം നേരിട്ട് നൽകാനും കഴിയും. ഇനിപ്പറയുന്ന ഉദാഹരണത്തിൽ, മൊത്തം രചയിതാക്കളുടെ എണ്ണം നൽകുന്ന ഒരു നടപടിക്രമം ഞങ്ങൾ സൃഷ്ടിച്ചു. നിങ്ങൾ ഈ നടപടിക്രമം മുമ്പത്തെവയുമായി താരതമ്യം ചെയ്താൽ, പ്രിന്റ് മൂല്യം വിപരീതമാണെന്ന് നിങ്ങൾക്ക് കാണാൻ കഴിയും.

ഇനി ഒരു പ്രൊസീജർ എക്സിക്യൂട്ട് ചെയ്ത് അതിന്റെ റിട്ടേൺ വാല്യു പ്രിന്റ് ചെയ്യുന്നത് എങ്ങനെയെന്ന് നോക്കാം. നടപടിക്രമം നിർവ്വഹിക്കുന്നതിന് ഒരു വേരിയബിളും പ്രിന്റിംഗും സജ്ജീകരിക്കേണ്ടതുണ്ട്, ഇത് ഈ മുഴുവൻ പ്രക്രിയയ്ക്കും ശേഷം നടപ്പിലാക്കുന്നു. ഒരു പ്രിന്റ് സ്റ്റേറ്റ്‌മെന്റിന് പകരം, Select @RetValue, OutputValue എന്നിവ പോലുള്ള ഒരു സെലക്ട് സ്റ്റേറ്റ്‌മെന്റ് നിങ്ങൾക്ക് ഉപയോഗിക്കാമെന്നത് ശ്രദ്ധിക്കുക.

4.2 SQL സംഭരിച്ച നടപടിക്രമം പാരാമീറ്റർ ഔട്ട്പുട്ട്

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

ഞങ്ങളുടെ ഉദാഹരണത്തിൽ രണ്ട് ഔട്ട്‌പുട്ട് പേരുകൾ ഉണ്ടാകും: @TotalAuthors, @TotalNoContract. അവ പാരാമീറ്ററുകളുടെ പട്ടികയിൽ സൂചിപ്പിച്ചിരിക്കുന്നു. ഈ വേരിയബിളുകൾ നടപടിക്രമത്തിന്റെ ബോഡിക്കുള്ളിൽ മൂല്യങ്ങൾ നൽകുന്നു. ഞങ്ങൾ ഔട്ട്‌പുട്ട് പാരാമീറ്ററുകൾ ഉപയോഗിക്കുമ്പോൾ, നടപടിക്രമത്തിന്റെ ബോഡിക്കുള്ളിൽ സജ്ജീകരിച്ച മൂല്യം വിളിക്കുന്നയാൾക്ക് കാണാൻ കഴിയും.

കൂടാതെ, മുമ്പത്തെ സാഹചര്യത്തിൽ, MS SQL സെർവർ ഔട്ട്പുട്ട് പാരാമീറ്ററിൽ സജ്ജീകരിച്ച നടപടിക്രമങ്ങൾ സംഭരിച്ച മൂല്യങ്ങൾ കാണുന്നതിന് രണ്ട് വേരിയബിളുകൾ പ്രഖ്യാപിച്ചു. "CA" പാരാമീറ്ററിന്റെ സാധാരണ മൂല്യം നൽകിക്കൊണ്ട് നടപടിക്രമം നടത്തുന്നു. ഇനിപ്പറയുന്ന പാരാമീറ്ററുകൾ ഔട്ട്പുട്ട് പാരാമീറ്ററുകളാണ്, അതിനാൽ പ്രഖ്യാപിത വേരിയബിളുകൾ നിർദ്ദിഷ്ട ക്രമത്തിൽ കടന്നുപോകുന്നു. വേരിയബിളുകൾ കടന്നുപോകുമ്പോൾ, ഔട്ട്പുട്ട് കീവേഡും ഇവിടെ സജ്ജീകരിച്ചിരിക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക. നടപടിക്രമം വിജയകരമായി പൂർത്തിയാക്കിയ ശേഷം, ഔട്ട്പുട്ട് പാരാമീറ്ററുകൾ നൽകുന്ന മൂല്യങ്ങൾ സന്ദേശ ബോക്സിൽ പ്രദർശിപ്പിക്കും.

4.3 SQL സംഭരിച്ച നടപടിക്രമങ്ങളിലൊന്ന് തിരഞ്ഞെടുക്കുന്നു

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

ഒടുവിൽ

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

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

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

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

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

സംഭരിച്ച നടപടിക്രമങ്ങൾ ഇനിപ്പറയുന്ന ആവശ്യങ്ങൾക്കും ഉപയോഗിക്കാം:

ഡാറ്റാബേസ് പട്ടികകൾ ഉപയോഗിച്ച് പ്രവർത്തനങ്ങളുടെ ഒരു ലോഗ് സൃഷ്ടിക്കാൻ.

സംഭരിച്ച നടപടിക്രമങ്ങൾ ഉപയോഗിക്കുന്നത്, GRANT, REVOKE സ്റ്റേറ്റ്‌മെന്റുകൾ ഉപയോഗിച്ച് നൽകുന്ന സുരക്ഷയ്‌ക്കപ്പുറമുള്ള സുരക്ഷാ നിയന്ത്രണത്തിന്റെ ഒരു തലം നൽകുന്നു, ഇത് ഉപയോക്താക്കൾക്ക് വ്യത്യസ്ത ആക്‌സസ് പ്രത്യേകാവകാശങ്ങൾ നൽകുന്നു. സംഭരിച്ച നടപടിക്രമം നടപ്പിലാക്കുന്നതിനുള്ള അംഗീകാരം, അടുത്ത വിഭാഗത്തിൽ വിവരിച്ചിരിക്കുന്നതുപോലെ, സംഭരിച്ച നടപടിക്രമത്തിൽ അടങ്ങിയിരിക്കുന്ന ഒബ്‌ജക്‌റ്റുകൾ പരിഷ്‌ക്കരിക്കുന്നതിനുള്ള അംഗീകാരത്തിൽ നിന്ന് സ്വതന്ത്രമായതിനാൽ ഇത് സാധ്യമാണ്.

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

സംഭരിച്ച നടപടിക്രമങ്ങൾ സൃഷ്ടിക്കുകയും നടപ്പിലാക്കുകയും ചെയ്യുന്നു

ഒരു പ്രസ്താവന ഉപയോഗിച്ച് സംഭരിച്ച നടപടിക്രമങ്ങൾ സൃഷ്ടിക്കപ്പെടുന്നു നടപടിക്രമം സൃഷ്ടിക്കുക, ഇനിപ്പറയുന്ന വാക്യഘടനയുണ്ട്:

PROC proc_name സൃഷ്ടിക്കുക [((@param1) type1 [ VARYING] [= default1] )] (, ...) ബാച്ച് ആയി | ബാഹ്യ NAME method_name വാക്യഘടന കൺവെൻഷനുകൾ

സൃഷ്‌ടിച്ച സംഭരിച്ച നടപടിക്രമത്തിന്റെ ഉടമ അസൈൻ ചെയ്‌ത സ്കീമയുടെ പേര് schema_name പാരാമീറ്റർ വ്യക്തമാക്കുന്നു. സംഭരിച്ച നടപടിക്രമത്തിന്റെ പേര് proc_name പാരാമീറ്റർ വ്യക്തമാക്കുന്നു. @param1 പാരാമീറ്റർ ഒരു നടപടിക്രമ പാരാമീറ്ററാണ് (ഔപചാരിക ആർഗ്യുമെന്റ്), അതിന്റെ ഡാറ്റ തരം നിർണ്ണയിക്കുന്നത് type1 പാരാമീറ്റർ ആണ്. പാക്കേജിനുള്ളിൽ ലോക്കൽ വേരിയബിളുകൾ ലോക്കൽ ആയതുപോലെ, പ്രൊസീജർ പരാമീറ്ററുകൾ നടപടിക്രമത്തിനുള്ളിൽ ലോക്കൽ ആണ്. നടപടിക്രമ പാരാമീറ്ററുകൾ, അതിൽ ഉപയോഗിക്കുന്നതിനുള്ള നടപടിക്രമത്തിലേക്ക് കോളർ കൈമാറുന്ന മൂല്യങ്ങളാണ്. ഡിഫോൾട്ട്1 പരാമീറ്റർ, അനുബന്ധ നടപടിക്രമ പാരാമീറ്ററിനുള്ള ഡിഫോൾട്ട് മൂല്യം വ്യക്തമാക്കുന്നു. (സ്ഥിര മൂല്യവും NULL ആകാം.)

ഔട്ട്പുട്ട് ഓപ്ഷൻഒരു പ്രൊസീജർ പാരാമീറ്റർ ഒരു റിട്ടേൺ പാരാമീറ്ററാണെന്നും അത് സംഭരിച്ചിരിക്കുന്ന നടപടിക്രമത്തിൽ നിന്ന് കോളിംഗ് നടപടിക്രമത്തിലേക്കോ സിസ്റ്റത്തിലേക്കോ ഒരു മൂല്യം തിരികെ നൽകാൻ ഉപയോഗിക്കാമെന്നും സൂചിപ്പിക്കുന്നു.

നേരത്തെ സൂചിപ്പിച്ചതുപോലെ, ഒരു നടപടിക്രമത്തിന്റെ മുൻകൂട്ടി തയ്യാറാക്കിയ രൂപം ഡാറ്റാബേസിൽ സംഭരിക്കുകയും അത് വിളിക്കുമ്പോഴെല്ലാം ഉപയോഗിക്കുകയും ചെയ്യുന്നു. ചില കാരണങ്ങളാൽ സംഭരിച്ച നടപടിക്രമം ഓരോ തവണ വിളിക്കുമ്പോഴും കംപൈൽ ചെയ്യേണ്ടതുണ്ടെങ്കിൽ, നടപടിക്രമം പ്രഖ്യാപിക്കുമ്പോൾ, ഉപയോഗിക്കുക RECOMPILE ഓപ്ഷൻ ഉപയോഗിച്ച്. വിത്ത് റീകംപൈൽ ഓപ്‌ഷൻ ഉപയോഗിക്കുന്നത് സംഭരിച്ച നടപടിക്രമങ്ങളുടെ ഏറ്റവും പ്രധാനപ്പെട്ട നേട്ടങ്ങളിലൊന്ന് നിരാകരിക്കുന്നു: ഒരൊറ്റ കംപൈലേഷൻ കാരണം പ്രകടന മെച്ചപ്പെടുത്തൽ. അതിനാൽ, സംഭരിച്ച നടപടിക്രമം ഉപയോഗിക്കുന്ന ഡാറ്റാബേസ് ഒബ്‌ജക്‌റ്റുകൾ പതിവായി പരിഷ്‌ക്കരിക്കുമ്പോൾ മാത്രമേ വിത്ത് റീകംപൈൽ ഓപ്ഷൻ ഉപയോഗിക്കാവൂ.

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

ഡിഫോൾട്ടായി, sysadmin ഫിക്സഡ് സെർവർ റോളിലെ അംഗങ്ങൾക്കും db_owner അല്ലെങ്കിൽ db_ddladmin ഫിക്സഡ് ഡാറ്റാബേസ് റോളുകൾക്കും മാത്രമേ ക്രിയേറ്റ് പ്രൊസീഡർ സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിക്കാൻ കഴിയൂ. എന്നാൽ ഈ റോളുകളിലെ അംഗങ്ങൾക്ക് പ്രസ്താവന ഉപയോഗിച്ച് മറ്റ് ഉപയോക്താക്കൾക്ക് ഈ അവകാശം നൽകാനാകും ഗ്രാന്റ് ക്രിയേറ്റ് പ്രൊസീജർ.

പ്രോജക്റ്റ് ടേബിളിനൊപ്പം പ്രവർത്തിക്കാൻ ലളിതമായ ഒരു സംഭരിച്ച നടപടിക്രമം എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് ചുവടെയുള്ള ഉദാഹരണം കാണിക്കുന്നു:

സാമ്പിൾ ഡിബി ഉപയോഗിക്കുക; പ്രൊജക്‌റ്റ് സെറ്റ് ബജറ്റ് അപ്‌ഡേറ്റ് ചെയ്യുന്നതിനനുസരിച്ച് പ്രൊസീജർ വർദ്ധിപ്പിക്കുക (@ശതമാനം INT=5) പ്രൊസീഡർ സൃഷ്‌ടിക്കുക.

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

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

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

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

സംഭരിച്ച നടപടിക്രമത്തിന്റെ ജീവിത ചക്രം രണ്ട് ഘട്ടങ്ങൾ ഉൾക്കൊള്ളുന്നു: അതിന്റെ സൃഷ്ടിയും നിർവ്വഹണവും. ഓരോ നടപടിക്രമവും ഒരിക്കൽ സൃഷ്ടിക്കുകയും നിരവധി തവണ നടപ്പിലാക്കുകയും ചെയ്യുന്നു. സംഭരിച്ച നടപടിക്രമം ഉപയോഗിച്ച് നടപ്പിലാക്കുന്നു നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കുകഒരു നടപടിക്രമത്തിന്റെ ഉടമയോ ആ നടപടിക്രമം ആക്‌സസ് ചെയ്യാനുള്ള എക്‌സിക്യുട്ട് പ്രത്യേകാവകാശമോ ഉള്ള ഒരു ഉപയോക്താവ്. EXECUTE പ്രസ്താവനയ്ക്ക് ഇനിപ്പറയുന്ന വാക്യഘടനയുണ്ട്:

[] [@return_status =] (proc_name | @proc_name_var) ([[@parameter1 =] മൂല്യം | [@parameter1=] @variable ] | DEFAULT).. വാക്യഘടന കൺവെൻഷനുകൾ

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

ഡിഫോൾട്ട് ക്ലോസ്നടപടിക്രമ നിർവചനത്തിൽ വ്യക്തമാക്കിയ ഒരു നടപടിക്രമ പാരാമീറ്ററിനുള്ള സ്ഥിര മൂല്യം നൽകുന്നു. സ്ഥിര മൂല്യങ്ങളൊന്നും നിർവചിക്കാത്തതും പാരാമീറ്റർ നഷ്‌ടപ്പെടാത്തതോ DEFAULT കീവേഡ് വ്യക്തമാക്കുന്നതോ ആയ ഒരു പാരാമീറ്ററിനായി ഒരു നടപടിക്രമം ഒരു മൂല്യം പ്രതീക്ഷിക്കുമ്പോൾ, ഒരു പിശക് സംഭവിക്കുന്നു.

EXECUTE സ്റ്റേറ്റ്‌മെന്റ് ഒരു ബാച്ചിന്റെ ആദ്യ പ്രസ്താവനയാകുമ്പോൾ, EXECUTE കീവേഡ് ഒഴിവാക്കാവുന്നതാണ്. എന്നിരുന്നാലും, എല്ലാ പാക്കറ്റുകളിലും ഈ വാക്ക് ഉൾപ്പെടുത്തുന്നത് സുരക്ഷിതമാണ്. EXECUTE പ്രസ്താവനയുടെ ഉപയോഗം ചുവടെയുള്ള ഉദാഹരണത്തിൽ കാണിച്ചിരിക്കുന്നു:

സാമ്പിൾ ഡിബി ഉപയോഗിക്കുക; വർദ്ധന ബജറ്റ് 10 നടപ്പിലാക്കുക;

ഈ ഉദാഹരണത്തിലെ EXECUTE പ്രസ്താവന IncreaseBudget സംഭരിച്ച നടപടിക്രമം നടപ്പിലാക്കുന്നു, ഇത് എല്ലാ പ്രോജക്റ്റുകളുടെയും ബജറ്റ് 10% വർദ്ധിപ്പിക്കുന്നു.

Employee, Works_on ടേബിളുകളിൽ ഡാറ്റ പ്രോസസ്സ് ചെയ്യുന്നതിന് ഒരു സംഭരിച്ച നടപടിക്രമം എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് ചുവടെയുള്ള ഉദാഹരണം കാണിക്കുന്നു:

ModifyEmpId ഉദാഹരണ നടപടിക്രമം റഫറൻഷ്യൽ സമഗ്രത നിലനിർത്തുന്നതിനുള്ള പ്രക്രിയയുടെ ഭാഗമായി സംഭരിച്ച നടപടിക്രമങ്ങളുടെ ഉപയോഗം വ്യക്തമാക്കുന്നു (ഈ സാഹചര്യത്തിൽ Employee, Works_on പട്ടികകൾക്കിടയിൽ). ഒരു ട്രിഗർ നിർവചനത്തിനുള്ളിൽ സമാനമായ സംഭരിച്ച നടപടിക്രമം ഉപയോഗിക്കാൻ കഴിയും, ഇത് യഥാർത്ഥത്തിൽ റഫറൻഷ്യൽ സമഗ്രത നൽകുന്നു.

ഒരു സംഭരിച്ച നടപടിക്രമത്തിൽ ഒരു OUTPUT ക്ലോസിന്റെ ഉപയോഗം ഇനിപ്പറയുന്ന ഉദാഹരണം കാണിക്കുന്നു:

ഇനിപ്പറയുന്ന നിർദ്ദേശങ്ങൾ ഉപയോഗിച്ച് ഈ സംഭരിച്ച നടപടിക്രമം നടപ്പിലാക്കാൻ കഴിയും:

@quantityDeleteEmployee INT പ്രഖ്യാപിക്കുക; എക്സിക്യൂട്ട് ഡിലീറ്റ് എംപ്ലോയി @empId=18316, @counter=@quantityDeleteEmployee OUTPUT; PRINT N"ഇല്ലാതാക്കിയ ജീവനക്കാർ: " + പരിവർത്തനം (nvarchar(30), @quantityDelete Employee);

ഈ നടപടിക്രമം പേഴ്സണൽ നമ്പർ @empId ഉള്ള ജീവനക്കാരൻ പ്രവർത്തിക്കുന്ന പ്രോജക്റ്റുകളുടെ എണ്ണം കണക്കാക്കുകയും തത്ഫലമായുണ്ടാകുന്ന മൂല്യം ©counter പാരാമീറ്ററിന് നൽകുകയും ചെയ്യുന്നു. എംപ്ലോയീ, വർക്ക്സ്_ഓൺ ടേബിളുകളിൽ നിന്ന് തന്നിരിക്കുന്ന പേഴ്‌സണൽ നമ്പറിനായുള്ള എല്ലാ വരികളും ഇല്ലാതാക്കിയ ശേഷം, കണക്കാക്കിയ മൂല്യം @quantityDeleteEmployee വേരിയബിളിലേക്ക് അസൈൻ ചെയ്യപ്പെടും.

OUTPUT ഓപ്‌ഷൻ വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ മാത്രമേ പാരാമീറ്റർ മൂല്യം കോളിംഗ് നടപടിക്രമത്തിലേക്ക് മടങ്ങുകയുള്ളൂ. മുകളിലെ ഉദാഹരണത്തിൽ, DeleteEmployee നടപടിക്രമം @counter പാരാമീറ്ററിനെ കോളിംഗ് നടപടിക്രമത്തിലേക്ക് കടത്തിവിടുന്നു, അതിനാൽ സംഭരിച്ച നടപടിക്രമം സിസ്റ്റത്തിലേക്ക് ഒരു മൂല്യം നൽകുന്നു. അതിനാൽ, ഒരു നടപടിക്രമം പ്രഖ്യാപിക്കുമ്പോൾ OUTPUT ഓപ്ഷനിലും അത് വിളിക്കുമ്പോൾ EXECUTE പ്രസ്താവനയിലും @counter പാരാമീറ്റർ വ്യക്തമാക്കിയിരിക്കണം.

ഫലങ്ങളോടൊപ്പം എക്‌സിക്യുട്ട് സ്റ്റേറ്റ്‌മെന്റിന്റെ സെറ്റ് ക്ലോസ്

SQL സെർവർ 2012-ൽ, EXECUTE പ്രസ്താവനയ്ക്കായി, നിങ്ങൾ നൽകുക ഫലങ്ങൾ സെറ്റ് ക്ലോസ് സഹിതം, അതിലൂടെ, ചില വ്യവസ്ഥകൾ പാലിക്കുമ്പോൾ, നിങ്ങൾക്ക് സംഭരിച്ച നടപടിക്രമത്തിന്റെ ഫല സെറ്റിന്റെ രൂപം മാറ്റാൻ കഴിയും.

ഇനിപ്പറയുന്ന രണ്ട് ഉദാഹരണങ്ങൾ ഈ വാചകം വിശദീകരിക്കാൻ സഹായിക്കും. ആദ്യ ഉദാഹരണം, റിസൾട്ട് സെറ്റ് ക്ലോസ് ഒഴിവാക്കിയാൽ ഫലം എങ്ങനെയായിരിക്കുമെന്ന് കാണിക്കുന്ന ഒരു ആമുഖ ഉദാഹരണമാണ്:

EmployeesInDept നടപടിക്രമം എന്നത് ഒരു പ്രത്യേക ഡിപ്പാർട്ട്‌മെന്റിൽ ജോലി ചെയ്യുന്ന എല്ലാ ജീവനക്കാരുടെയും പേഴ്‌സണൽ നമ്പറുകളും അവസാന പേരുകളും പ്രദർശിപ്പിക്കുന്ന ഒരു ലളിതമായ നടപടിക്രമമാണ്. ഡിപ്പാർട്ട്‌മെന്റ് നമ്പർ ഒരു നടപടിക്രമ പാരാമീറ്ററാണ്, അത് വിളിക്കുമ്പോൾ അത് വ്യക്തമാക്കണം. ഈ നടപടിക്രമം നടപ്പിലാക്കുന്നത് രണ്ട് നിരകളുള്ള ഒരു പട്ടിക നിർമ്മിക്കുന്നു, അതിന്റെ തലക്കെട്ടുകൾ ഡാറ്റാബേസ് പട്ടികയിലെ അനുബന്ധ കോളങ്ങളുടെ പേരുകളുമായി പൊരുത്തപ്പെടുന്നു, അതായത്. ഐഡിയും അവസാന നാമവും. ഫല കോളങ്ങളുടെ തലക്കെട്ടുകൾ മാറ്റാൻ (അതുപോലെ തന്നെ അവയുടെ ഡാറ്റാ തരവും), SQL സെർവർ 2012 പുതിയ റിസൾട്ട് സെറ്റ് ക്ലോസ് ഉപയോഗിക്കുന്നു. ഈ വാക്യത്തിന്റെ പ്രയോഗം ചുവടെയുള്ള ഉദാഹരണത്തിൽ കാണിച്ചിരിക്കുന്നു:

സാമ്പിൾ ഡിബി ഉപയോഗിക്കുക; EXEC EmployeesInDept "d1" ഫല സെറ്റുകളോടെ (( INT NULL അല്ല, [അവസാന നാമം] CHAR(20) NULL അല്ല));

ഈ രീതിയിൽ വിളിക്കപ്പെടുന്ന ഒരു സംഭരിച്ച നടപടിക്രമം നടപ്പിലാക്കുന്നതിന്റെ ഫലം ഇനിപ്പറയുന്നതായിരിക്കും:

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

സംഭരിച്ച നടപടിക്രമങ്ങളുടെ ഘടന മാറ്റുന്നു

ഡാറ്റാബേസ് എഞ്ചിനും നിർദ്ദേശത്തെ പിന്തുണയ്ക്കുന്നു നടപടിക്രമം മാറ്റുകസംഭരിച്ച നടപടിക്രമങ്ങളുടെ ഘടന പരിഷ്കരിക്കുന്നതിന്. ഒരു നടപടിക്രമത്തിനുള്ളിൽ ട്രാൻസാക്റ്റ്-എസ്‌ക്യുഎൽ സ്റ്റേറ്റ്‌മെന്റുകൾ മാറ്റാൻ ALTER PROCEDURE സ്റ്റേറ്റ്‌മെന്റ് സാധാരണയായി ഉപയോഗിക്കുന്നു. ALTER PROCEDURE സ്റ്റേറ്റ്‌മെന്റിന്റെ എല്ലാ പാരാമീറ്ററുകൾക്കും ക്രിയേറ്റ് പ്രൊസീഡർ സ്റ്റേറ്റ്‌മെന്റിന്റെ അതേ പാരാമീറ്ററുകളുടെ അതേ അർത്ഥമുണ്ട്. ഈ പ്രസ്താവന ഉപയോഗിക്കുന്നതിന്റെ പ്രധാന ലക്ഷ്യം നിലവിലുള്ള സംഭരിച്ച നടപടിക്രമ അവകാശങ്ങളെ മറികടക്കുന്നത് ഒഴിവാക്കുക എന്നതാണ്.

ഡാറ്റാബേസ് എഞ്ചിൻ പിന്തുണയ്ക്കുന്നു CURSOR ഡാറ്റ തരം. സംഭരിച്ച നടപടിക്രമങ്ങളിൽ കഴ്‌സറുകൾ പ്രഖ്യാപിക്കാൻ ഈ ഡാറ്റ തരം ഉപയോഗിക്കുന്നു. കഴ്സർഒരു ചോദ്യത്തിന്റെ ഫലങ്ങൾ (സാധാരണയായി ഒരു കൂട്ടം വരികൾ) സംഭരിക്കാനും ആ ഫലം ​​വരി വരിയായി പ്രദർശിപ്പിക്കാൻ ഉപയോക്താക്കളെ അനുവദിക്കാനും ഉപയോഗിക്കുന്ന ഒരു പ്രോഗ്രാമിംഗ് നിർമ്മാണമാണ്.

സംഭരിച്ച ഒന്നോ കൂട്ടമോ നടപടിക്രമങ്ങൾ ഇല്ലാതാക്കാൻ, ഉപയോഗിക്കുക ഡ്രോപ്പ് പ്രൊസീജർ നിർദ്ദേശം. db_owner, sysadmin ഫിക്സഡ് റോളുകളുടെ ഉടമയ്‌ക്കോ അംഗങ്ങൾക്കോ ​​മാത്രമേ സംഭരിച്ച നടപടിക്രമം ഇല്ലാതാക്കാൻ കഴിയൂ.

സംഭരിച്ച നടപടിക്രമങ്ങളും പൊതു ഭാഷാ പ്രവർത്തന സമയവും

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

ഓപ്‌ഷൻ ഉപയോഗിച്ച് പൊതു ഭാഷ റൺടൈം പ്രവർത്തനക്ഷമമാക്കുകയും പ്രവർത്തനരഹിതമാക്കുകയും ചെയ്യുന്നു clr_enabledസിസ്റ്റം നടപടിക്രമം sp_configure, നിർദ്ദേശപ്രകാരം നിർവ്വഹിക്കുന്നതിനായി സമാരംഭിച്ചിരിക്കുന്നു പുനഃക്രമീകരിക്കുക. CLR പ്രവർത്തനക്ഷമമാക്കുന്നതിന് നിങ്ങൾക്ക് sp_configure സിസ്റ്റം നടപടിക്രമം എങ്ങനെ ഉപയോഗിക്കാമെന്ന് ഇനിപ്പറയുന്ന ഉദാഹരണം കാണിക്കുന്നു:

സാമ്പിൾ ഡിബി ഉപയോഗിക്കുക; EXEC sp_configure "clr_enabled",1 RECONFIGURE

CLR ഉപയോഗിച്ച് ഒരു നടപടിക്രമം സൃഷ്ടിക്കാനും കംപൈൽ ചെയ്യാനും സംരക്ഷിക്കാനും, കാണിച്ചിരിക്കുന്ന ക്രമത്തിൽ നിങ്ങൾ ഇനിപ്പറയുന്ന ഘട്ടങ്ങളുടെ ക്രമം പൂർത്തിയാക്കണം:

C# അല്ലെങ്കിൽ വിഷ്വൽ ബേസിക്കിൽ ഒരു സംഭരിച്ച നടപടിക്രമം സൃഷ്ടിക്കുക, തുടർന്ന് ഉചിതമായ കമ്പൈലർ ഉപയോഗിച്ച് കംപൈൽ ചെയ്യുക.

നിർദ്ദേശങ്ങൾ ഉപയോഗിച്ച് അസംബ്ലി സൃഷ്ടിക്കുക, അനുബന്ധ എക്സിക്യൂട്ടബിൾ ഫയൽ സൃഷ്ടിക്കുക.

EXECUTE പ്രസ്താവന ഉപയോഗിച്ച് നടപടിക്രമം നടപ്പിലാക്കുക.

ചുവടെയുള്ള ചിത്രം മുമ്പ് വിവരിച്ച ഘട്ടങ്ങളുടെ ഒരു ഗ്രാഫിക്കൽ ഡയഗ്രം കാണിക്കുന്നു. ഈ പ്രക്രിയയുടെ കൂടുതൽ വിശദമായ വിവരണമാണ് ഇനിപ്പറയുന്നത്.

ആദ്യം, വിഷ്വൽ സ്റ്റുഡിയോ പോലുള്ള വികസന പരിതസ്ഥിതിയിൽ ആവശ്യമായ പ്രോഗ്രാം സൃഷ്ടിക്കുക. ഒരു C# അല്ലെങ്കിൽ വിഷ്വൽ ബേസിക് കമ്പൈലർ ഉപയോഗിച്ച് പൂർത്തിയാക്കിയ പ്രോഗ്രാം ഒബ്ജക്റ്റ് കോഡിലേക്ക് കംപൈൽ ചെയ്യുക. ഈ കോഡ് ഒരു ഡൈനാമിക്-ലിങ്ക് ലൈബ്രറി (.dll) ഫയലിൽ സംഭരിച്ചിരിക്കുന്നു, ഇത് ഇന്റർമീഡിയറ്റ് എക്സിക്യൂട്ടബിൾ കോഡ് സൃഷ്ടിക്കുന്ന ക്രിയേറ്റ് അസംബ്ലി സ്റ്റേറ്റ്മെന്റിന്റെ ഉറവിടമായി വർത്തിക്കുന്നു. അടുത്തതായി, എക്സിക്യൂട്ടിംഗ് കോഡ് ഒരു ഡാറ്റാബേസ് ഒബ്ജക്റ്റായി സംരക്ഷിക്കുന്നതിന് ഒരു ക്രിയേറ്റ് പ്രൊസീഡർ സ്റ്റേറ്റ്മെന്റ് നൽകുക. അവസാനമായി, പരിചിതമായ EXECUTE സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിച്ച് നടപടിക്രമം പ്രവർത്തിപ്പിക്കുക.

ചുവടെയുള്ള ഉദാഹരണം C#-ൽ സംഭരിച്ച നടപടിക്രമത്തിനുള്ള സോഴ്സ് കോഡ് കാണിക്കുന്നു:

System.Data.SqlClient ഉപയോഗിക്കുന്നു; Microsoft.SqlServer.Server ഉപയോഗിക്കുന്നു; പൊതു ഭാഗിക ക്ലാസ് സംഭരിച്ച നടപടിക്രമങ്ങൾ (പബ്ലിക് സ്റ്റാറ്റിക് ഇൻറ്റ് കൗണ്ട് എംപ്ലോയീസ്() (ഇന്റ് വരികൾ; Sqlകണക്ഷൻ കണക്ഷൻ = പുതിയ Sqlകണക്ഷൻ("സന്ദർഭ കണക്ഷൻ=ട്രൂ"); connection.Open(); SqlCommand cmd = connection.CreateCommand(); cmd.CommandText എണ്ണുക(*) "ജീവനക്കാരുടെ എണ്ണം" " + "ജീവനക്കാരിൽ നിന്ന്"; വരികൾ = (int)cmd.ExecuteScalar(); connection.Close();വരികൾ തിരികെ നൽകുക; ) )

ജീവനക്കാരുടെ പട്ടികയിലെ വരികളുടെ എണ്ണം കണക്കാക്കുന്നതിനുള്ള ഒരു ചോദ്യം ഈ നടപടിക്രമം നടപ്പിലാക്കുന്നു. ഒരു പ്രോഗ്രാമിന്റെ തുടക്കത്തിൽ നിർദ്ദേശങ്ങൾ ഉപയോഗിച്ച് പ്രോഗ്രാം എക്സിക്യൂട്ട് ചെയ്യുന്നതിന് ആവശ്യമായ നെയിംസ്പേസുകൾ വ്യക്തമാക്കുന്നു. ഈ നിർദ്ദേശങ്ങൾ ഉപയോഗിക്കുന്നത്, അനുബന്ധ നെയിംസ്‌പെയ്‌സുകൾ വ്യക്തമായി വ്യക്തമാക്കാതെ സോഴ്‌സ് കോഡിൽ ക്ലാസ് പേരുകൾ വ്യക്തമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. അടുത്തതായി, StoredProcedures ക്ലാസ് നിർവചിച്ചിരിക്കുന്നു, അതിനായി SqlProcedure ആട്രിബ്യൂട്ട്, ഈ ക്ലാസ് ഒരു സംഭരിച്ച നടപടിക്രമമാണെന്ന് കംപൈലറെ അറിയിക്കുന്നു. CountEmployees() രീതി ക്ലാസ് കോഡിനുള്ളിൽ നിർവചിച്ചിരിക്കുന്നു. ക്ലാസിന്റെ ഒരു ഉദാഹരണത്തിലൂടെ ഡാറ്റാബേസ് സിസ്റ്റത്തിലേക്കുള്ള ഒരു കണക്ഷൻ സ്ഥാപിക്കപ്പെടുന്നു Sql കണക്ഷൻ. ഒരു കണക്ഷൻ തുറക്കാൻ, ഈ സംഭവത്തിന്റെ Open() രീതി ഉപയോഗിക്കുന്നു. എ CreateCommand() രീതിഒരു ക്ലാസ്സിന്റെ ഒരു ഉദാഹരണം ആക്സസ് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു SqlCommnd, അതിലേക്ക് ആവശ്യമായ SQL കമാൻഡ് കൈമാറുന്നു.

ഇനിപ്പറയുന്ന കോഡ് സ്‌നിപ്പറ്റിൽ:

Cmd.CommandText = "എണ്ണം(*) "ജീവനക്കാരുടെ എണ്ണം" " + "ജീവനക്കാരിൽ നിന്ന്" തിരഞ്ഞെടുക്കുക;

ജീവനക്കാരുടെ പട്ടികയിലെ വരികളുടെ എണ്ണം എണ്ണുന്നതിനും ഫലം പ്രദർശിപ്പിക്കുന്നതിനും ഒരു SELECT പ്രസ്താവന ഉപയോഗിക്കുന്നു. CMD വേരിയബിളിന്റെ CommandText പ്രോപ്പർട്ടി CreateCommand() രീതി നൽകുന്ന ഉദാഹരണത്തിലേക്ക് സജ്ജീകരിച്ചാണ് കമാൻഡ് ടെക്സ്റ്റ് വ്യക്തമാക്കുന്നത്. അടുത്തതായി വിളിക്കുന്നു ExecuteScalar() രീതി SqlCommand ഉദാഹരണം. ഈ രീതി ഒരു സ്കെയിലർ മൂല്യം നൽകുന്നു, അത് ഒരു പൂർണ്ണസംഖ്യ ഡാറ്റ തരത്തിലേക്ക് പരിവർത്തനം ചെയ്യുകയും വരികളുടെ വേരിയബിളിലേക്ക് അസൈൻ ചെയ്യുകയും ചെയ്യുന്നു.

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

സാമ്പിൾ ഡിബി ഉപയോഗിക്കുക; "D:\Projects\CLRStoredProcedures\bin\Debug\CLRStoredProcedures.dll" എന്നതിൽ നിന്ന് അസംബ്ലി CLRStored Procedures സൃഷ്ടിക്കുക അനുമതി_സെറ്റ് = സുരക്ഷിതം

ക്രിയേറ്റ് അസംബ്ലി സ്റ്റേറ്റ്‌മെന്റ് നിയന്ത്രിത കോഡ് ഇൻപുട്ടായി എടുക്കുകയും നിങ്ങൾക്ക് CLR സംഭരിച്ച നടപടിക്രമങ്ങൾ, ഉപയോക്തൃ-നിർവചിച്ച ഫംഗ്‌ഷനുകൾ, ട്രിഗറുകൾ എന്നിവ സൃഷ്ടിക്കാൻ കഴിയുന്ന ഒരു അനുബന്ധ ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കുകയും ചെയ്യുന്നു. ഈ നിർദ്ദേശത്തിന് ഇനിപ്പറയുന്ന വാക്യഘടനയുണ്ട്:

(dll_file) വാക്യഘടന കൺവെൻഷനുകളിൽ നിന്ന് അസംബ്ലി അസംബ്ലി_നാമം [ അധികാരപ്പെടുത്തൽ ഉടമയുടെ_നാമം ] സൃഷ്ടിക്കുക

അസംബ്ലി_നെയിം പാരാമീറ്റർ അസംബ്ലിയുടെ പേര് വ്യക്തമാക്കുന്നു. ഓപ്ഷണൽ ഓതറൈസേഷൻ ക്ലോസ് ഈ അസംബ്ലിയുടെ ഉടമ എന്ന റോളിന്റെ പേര് വ്യക്തമാക്കുന്നു. ലോഡ് ചെയ്യാനുള്ള അസംബ്ലി സ്ഥിതി ചെയ്യുന്ന പാത FROM ക്ലോസ് വ്യക്തമാക്കുന്നു.

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

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

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

നിങ്ങൾ മുമ്പ് നടപ്പിലാക്കിയ നിയന്ത്രിത കോഡിനെ അടിസ്ഥാനമാക്കി ഒരു സംഭരിച്ച നടപടിക്രമം എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് ചുവടെയുള്ള ഉദാഹരണം കാണിക്കുന്നു:

സാമ്പിൾ ഡിബി ഉപയോഗിക്കുക; CLRSStoredProcedures.StoredProcedures.CountEmployees എന്ന പേരിൽ ജീവനക്കാരെ എക്‌സ്റ്റേണൽ നാമമായി ക്രിയേറ്റ് ചെയ്യൂ

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

Assembly_name.class_name.method_name

അസംബ്ലി_നാമം - അസംബ്ലിയുടെ പേര് സൂചിപ്പിക്കുന്നു;

class_name - പൊതു ക്ലാസ്സിന്റെ പേര് സൂചിപ്പിക്കുന്നു;

method_name - ഓപ്ഷണൽ ഭാഗം, ക്ലാസ്സിനുള്ളിൽ നിർവചിച്ചിരിക്കുന്ന രീതിയുടെ പേര് വ്യക്തമാക്കുന്നു.

CountEmployees നടപടിക്രമത്തിന്റെ നിർവ്വഹണം ചുവടെയുള്ള ഉദാഹരണത്തിൽ കാണിച്ചിരിക്കുന്നു:

സാമ്പിൾ ഡിബി ഉപയോഗിക്കുക; @count INT എക്സിക്യൂട്ട് ചെയ്യുക @count = CountEmployees പ്രിന്റ് @count -- റിട്ടേൺ 7

എംപ്ലോയി ടേബിളിലെ നിലവിലെ വരികളുടെ എണ്ണം പ്രിന്റ് സ്റ്റേറ്റ്മെന്റ് നൽകുന്നു.

സംഭരിച്ച നടപടിക്രമംസംഭരിച്ച നടപടിക്രമം) എന്ന് പേരിട്ടിരിക്കുന്ന ഒരു ഡാറ്റാബേസ് പ്രോഗ്രാം ഒബ്ജക്റ്റ്. 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" എന്ന അക്ഷരം, നടപടിക്രമം അനുസരിച്ച് ഇത് ഒരു യൂണികോഡ് അക്ഷരീയ സ്ഥിരാങ്കമാണെന്ന് സൂചിപ്പിക്കുന്നു. ഒരു പരാമീറ്റർ ഒരു സ്ഥിരമായ മൂല്യം മാത്രമല്ല, മറ്റൊരു വേരിയബിളിന്റെ മൂല്യവും നൽകാം.

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

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= ] (മൂല്യം | @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- July- 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. നിർദ്ദിഷ്ട സ്ഥാനത്തേക്ക് നിയോഗിച്ചിട്ടുള്ള ജീവനക്കാരുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക.

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

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

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

ഓപ്ഷൻ 12

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

ഓപ്ഷൻ 13

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

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

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

ഓപ്ഷൻ 14

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

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

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

4. ഒരു നിശ്ചിത സംഖ്യയിൽ കൂടുതൽ ഉയരമുള്ളതോ പൂക്കുന്നതോ ആയ പൂക്കളുടെ ഒരു പട്ടികയും പൂക്കളുടെ വൈവിധ്യവും പ്രദർശിപ്പിക്കുക.

ഓപ്ഷൻ 15

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

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

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

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

ഓപ്ഷൻ 16

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

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

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

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

ഓപ്ഷൻ 17

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

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

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

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

ഓപ്ഷൻ 18

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

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

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

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

ഓപ്ഷൻ 19

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

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

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

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

ഓപ്ഷൻ 20

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

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

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

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