Դիտարկվում է մի իրավիճակ, որտեղ պահպանված ընթացակարգերը կարող են վատթարացնել հարցումների կատարումը:
MS SQL Server 2000-ում պահված ընթացակարգերը կազմելիս պահված ընթացակարգերը տեղադրվում են ընթացակարգային քեշում, որը կարող է բարելավել դրանց կատարման ընթացքում կատարողականությունը՝ վերացնելով վերլուծության, օպտիմիզացման և պահպանված պրոցեդուրաների կոդի կազմման անհրաժեշտությունը:
Մյուս կողմից, պահպանված պրոցեդուրաների կազմված ծածկագիրը պահելու մեջ կան որոգայթներ, որոնք կարող են հակառակ ազդեցություն ունենալ:
Փաստն այն է, որ պահված ընթացակարգը կազմելիս կազմվում է այն օպերատորների կատարման պլանը, որոնք կազմում են ընթացակարգի կոդը, համապատասխանաբար, եթե կազմված պահպանված ընթացակարգը պահվում է, ապա դրա կատարման պլանը պահվում է, և, հետևաբար, պահպանված ընթացակարգը չի լինի: օպտիմիզացված լինի կոնկրետ իրավիճակի և հարցման պարամետրերի համար:
Սա ցույց տալու համար մի փոքր փորձ կանեմ:
ՔԱՅԼ 1... Տվյալների բազայի ստեղծում.
Փորձի համար ստեղծենք առանձին տվյալների բազա։
ՍՏԵՂԾԵԼ ՏՎՅԱԼՆԵՐԻ ԲԱԶԱՆ test_sp_perf
ON (NAME = «test_data», FILENAME = «c: \ temp \ test_data», SIZE = 1, MAXSIZE = 10, FILEGROWTH = 1Mb)
LOG ON (NAME = «test_log», FILENAME = «c: \ temp \ test_log», SIZE = 1, MAXSIZE = 10, FILEGROWTH = 1Mb)
ՔԱՅԼ 2.Սեղանի ստեղծում.
CREATE TABLE sp_perf_test (սյունակ 1 ինտ, սյունակ 2 նիշ (5000))
ՔԱՅԼ 3.Աղյուսակը լրացնելով թեստային տողերով: Կրկնվող տողերը միտումնավոր ավելացվում են աղյուսակում: 10,000 տող համարակալված է 1-ից մինչև 10,000, իսկ 10,000 տողը՝ 50,000:
ՀԱՅՏԱՐԱՐԵԼ @i int
SET @ i = 1
Մինչդեռ (@i<10000)
ՍԿՍԵԼ
INSERT INTO sp_perf_test (սյունակ 1, սյունակ 2) VALUES (@i, «Թեստային տող #» + CAST (@i որպես նիշ (8)))
INSERT INTO sp_perf_test (սյունակ 1, սյունակ 2) VALUES (50000, «Թեստային տող #» + CAST (@i որպես նիշ (8)))
SET @ i = @ i + 1
ՎԵՐՋ
SELECT COUNT (*) FROM sp_perf_test-ից
Գնա
ՔԱՅԼ 4.Ստեղծեք ոչ կլաստերային ինդեքս: Քանի որ կատարման պլանը քեշավորված է ընթացակարգով, ինդեքսը կօգտագործվի նույնը բոլոր զանգերի համար:
ՍՏԵՂԾԵԼ ՈՉ ԿԼՅՈՒՍՏԵՐ ԻՆԴԵՔՍ CL_perf_test ON sp_perf_test (սյունակ 1)
Գնա
ՔԱՅԼ 5.Պահված ընթացակարգի ստեղծում: Ընթացակարգը պարզապես կատարում է SELECT հայտարարությունը պայմանով:
ՍՏԵՂԾԵԼ PROC proc1 (@param int)
ԱՍ
SELECT սյունակ 1, սյունակ 2 FROM sp_perf_test WHERE [էլփոստը պաշտպանված է]
Գնա
ՔԱՅԼ 6.Պահված ընթացակարգի իրականացում: Խոցելի ընթացակարգ սկսելիս հատուկ օգտագործվում է ընտրովի պարամետր: Պրոցեդուրայի արդյունքում ստանում ենք 1 տող. Կատարման պլանը ցույց է տալիս ոչ կլաստերային ինդեքսի օգտագործումը, քանի որ հարցումը ընտրովի է և տող առբերելու լավագույն միջոցն է: Մեկ տող բեռնելու համար օպտիմիզացված ընթացակարգը պահվում է ընթացակարգային քեշում:
EXEC proc1 1234
Գնա
ՔԱՅԼ 7.Պահված ընթացակարգի իրականացում ոչ ընտրովի պարամետրով: 50,000 արժեքը օգտագործվում է որպես պարամետր: Առաջին սյունակի նման արժեքով տողերը, համապատասխանաբար, մոտ 10,000, օգտագործելով ոչ կլաստերային ինդեքսը և էջանիշների որոնման գործողությունը, անարդյունավետ են, բայց քանի որ կատարման պլանի հետ կազմված կոդը պահվում է ընթացակարգային քեշը, այն կօգտագործվի: Կատարման պլանը ցույց է տալիս դա, ինչպես նաև այն փաստը, որ էջանիշների որոնման գործողությունը կատարվել է 9999 տողերի համար:
EXEC proc1 50,000
Գնա
ՔԱՅԼ 8.Առաջին դաշտով տողերի բեռնում, որը հավասար է 50,000-ի: Առանձին հարցման կատարումը կօպտիմալացնի և կկազմի հարցումը առաջին սյունակի հատուկ արժեքով: Արդյունքում, հարցումների օպտիմիզատորը հայտնաբերում է, որ դաշտը բազմիցս կրկնօրինակվում է և որոշում է օգտագործել աղյուսակի սկանավորման գործողությունը, որն այս դեպքում շատ ավելի արդյունավետ է, քան ոչ կլաստերային ինդեքս օգտագործելը։
SELECT սյունակ 1, սյունակ 2 FROM sp_perf_test WHERE սյունակ 1 = 50000
Գնա
Այսպիսով, մենք կարող ենք եզրակացնել, որ պահված ընթացակարգերի օգտագործումը միշտ չէ, որ կարող է բարելավել հարցումների կատարողականը: Դուք պետք է շատ զգույշ լինեք պահպանված ընթացակարգերի նկատմամբ, որոնք գործում են փոփոխական թվով տողերով արդյունքների վրա և օգտագործում են տարբեր կատարման պլաններ:
Դուք կարող եք օգտագործել սկրիպտը՝ փորձը կրկնելու համար թարմ MS SQL սերվերի վրա:
Պահպանված ընթացակարգերի տեսակները
SQL Server-ում կան մի քանի տեսակներ պահված ընթացակարգեր.
- Համակարգային պահված ընթացակարգերնախատեսված են տարբեր վարչական գործողություններ կատարելու համար: Սերվերի կառավարման գրեթե բոլոր գործողությունները կատարվում են նրանց օգնությամբ։ Կարելի է ասել, որ համակարգը պահված ընթացակարգերհամակարգային աղյուսակների հետ աշխատանք տրամադրող ինտերֆեյս է, որն ի վերջո հանգում է տվյալների փոփոխմանը, ավելացմանը, ջնջմանը և առբերմանը ինչպես օգտագործողների, այնպես էլ համակարգի տվյալների բազաների համակարգի աղյուսակներից: Համակարգային պահված ընթացակարգերնախածանցով sp_ են, պահվում են համակարգի տվյալների բազայում և կարող են կանչվել ցանկացած այլ տվյալների բազայի համատեքստում:
- Պատվերով պահված ընթացակարգերիրականացնել որոշակի գործողություններ. Պահպանված ընթացակարգեր- ամբողջական տվյալների բազայի օբյեկտ: Արդյունքում յուրաքանչյուր պահված կարգըգտնվում է կոնկրետ տվյալների բազայում, որտեղ այն իրականացվում է:
- Ժամանակավոր պահված ընթացակարգերգոյություն ունեն միայն որոշ ժամանակով, որից հետո դրանք ավտոմատ կերպով ոչնչացվում են սերվերի կողմից: Դրանք բաժանվում են տեղական և գլոբալ: Տեղական ժամանակավոր պահված ընթացակարգերկարելի է կանչել միայն այն կապից, որով դրանք ստեղծվել են: Երբ դուք ստեղծում եք նման ընթացակարգ, դուք պետք է անվանեք այն, որը սկսվում է մեկ # նիշով: Ինչպես բոլոր ժամանակավոր օբյեկտները, պահված ընթացակարգերայս տեսակի ավտոմատ կերպով ջնջվում են, երբ օգտատերը անջատում է, վերագործարկում կամ դադարեցնում է սերվերը: Համաշխարհային ժամանակավոր պահված ընթացակարգերհասանելի ցանկացած սերվերի միացումների համար, որոնք ունեն նույն ընթացակարգը: Այն սահմանելու համար պարզապես անհրաժեշտ է անվանել՝ սկսած ## նշաններից: Այս ընթացակարգերը ջնջվում են, երբ սերվերը վերագործարկվում կամ դադարեցվում է, կամ երբ կապը, որի համատեքստում դրանք ստեղծվել են, փակվում է:
Պահպանված ընթացակարգերի ստեղծում, փոփոխում և ջնջում
Ստեղծագործություն պահված կարգըներառում է հետևյալ խնդիրների լուծումը.
- սահմանելով ստեղծված տիպը պահված կարգըժամանակավոր կամ սովորական: Բացի այդ, դուք կարող եք ստեղծել ձեր սեփական համակարգը պահված կարգըանվանելով sp_ նախածանցով և տեղադրելով համակարգի տվյալների բազայում։ Այս ընթացակարգը հասանելի կլինի տեղական սերվերի ցանկացած տվյալների բազայի համատեքստում.
- մուտքի իրավունքների պլանավորում։ Ստեղծելիս պահված կարգըպետք է հաշվի առնել, որ այն կունենա տվյալների բազայի օբյեկտների մուտքի նույն իրավունքները, ինչ այն ստեղծած օգտվողը.
- սահմանում պահպանված ընթացակարգի պարամետրերը... Ինչպես ծրագրավորման լեզուների մեծ մասում հայտնաբերված ընթացակարգերը, պահված ընթացակարգերկարող է ունենալ մուտքային և ելքային պարամետրեր;
- կոդի մշակում պահված կարգը... Ընթացակարգի կոդը կարող է պարունակել ցանկացած SQL հրամանների հաջորդականություն, ներառյալ զանգեր ուրիշներին: պահված ընթացակարգեր.
Ստեղծել նորը և փոփոխել գոյություն ունեցողը պահված կարգըկատարվում է հետևյալ հրամանով.
<определение_процедуры>:: = (ՍՏԵՂԾԵԼ | ՓՈՓՈԽԵԼ) ընթացակարգ_անուն [; համար] [(@ պարամետր_անուն տվյալների տեսակ) [= լռելյայն]] [, ... n] AS sql_operator [... n]
Դիտարկենք այս հրամանի պարամետրերը:
Օգտագործելով sp_, #, ## նախածանցները, ստեղծված ընթացակարգը կարող է սահմանվել որպես համակարգային կամ ժամանակավոր: Ինչպես երևում է հրամանի շարահյուսությունից, չի թույլատրվում նշել այն սեփականատիրոջ անունը, ում պատկանում է ստեղծված պրոցեդուրան, ինչպես նաև տվյալների բազայի անվանումը, որտեղ այն պետք է գտնվի: Այսպիսով, որպեսզի տեղադրվի ստեղծված պահված կարգըկոնկրետ տվյալների բազայի վրա դուք պետք է գործարկեք CREATE PROCEDURE հրամանը տվյալ տվյալների բազայի համատեքստում: Մարմնից դուրս վարվելիս պահված կարգըդուք կարող եք օգտագործել կրճատված անուններ նույն տվյալների բազայի օբյեկտների համար, այսինքն՝ առանց տվյալների բազայի անունը նշելու: Երբ դուք պետք է հղում կատարեք այլ տվյալների բազաներում տեղակայված օբյեկտներին, անհրաժեշտ է նշել տվյալների բազայի անվանումը:
Անվան մեջ նշված համարը նույնականացման համարն է պահված կարգը, որը եզակիորեն նույնացնում է այն ընթացակարգերի խմբում: Կառավարման ընթացակարգերի հարմարության համար, տրամաբանորեն նույն տիպի պահված ընթացակարգերկարելի է խմբավորել՝ տալով նրանց նույն անունը, բայց տարբեր նույնականացման համարներ:
Ստեղծված մուտքային և ելքային տվյալները փոխանցելու համար պահված կարգըկարող են օգտագործվել այնպիսի պարամետրեր, որոնց անունները, ինչպես տեղական փոփոխականների անունները, պետք է սկսվեն @ նշանով: Մեկը պահված կարգըշատ պարամետրեր կարելի է նշել՝ բաժանված ստորակետերով: Ընթացակարգի մարմինը չպետք է օգտագործի տեղական փոփոխականներ, որոնց անունները նույնն են, ինչ այս ընթացակարգի պարամետրերի անունները:
Տվյալների տեսակը որոշելու համար, որոնք կունենան համապատասխան պահպանված ընթացակարգի պարամետր, SQL տվյալների ցանկացած տեսակներ, ներառյալ օգտագործողի կողմից սահմանվածները, կաշխատեն: Այնուամենայնիվ, CURSOR տվյալների տեսակը կարող է օգտագործվել միայն որպես ելքային պարամետր պահված կարգը, այսինքն. նշելով OUTPUT հիմնաբառը:
OUTPUT հիմնաբառի առկայությունը նշանակում է, որ համապատասխան պարամետրը նախատեսված է տվյալների վերադարձման համար պահված կարգը... Այնուամենայնիվ, դա ամենևին չի նշանակում, որ պարամետրը հարմար չէ արժեքներ փոխանցելու համար պահված կարգը... Նշելով OUTPUT հիմնաբառը սերվերին հրահանգում է դուրս գալ պահված կարգըվերագրեք պարամետրի ընթացիկ արժեքը տեղական փոփոխականին, որը նշված էր որպես պարամետրի արժեք ընթացակարգը կանչելիս: Նկատի ունեցեք, որ երբ նշված է OUTPUT հիմնաբառը, ընթացակարգ կանչելիս համապատասխան պարամետրի արժեքը կարող է սահմանվել միայն տեղական փոփոխականի միջոցով: Ձեզ չի թույլատրվում օգտագործել որևէ արտահայտություն կամ հաստատուն, որը վավեր է նորմալ պարամետրերի համար:
VARYING հիմնաբառը օգտագործվում է հետ միասին
Պահպանված ընթացակարգը (eng.պահեստավորված ընթացակարգ) տվյալների բազայի անվանված ծրագրի օբյեկտ է: SQL Server-ում պահպանված ընթացակարգերի մի քանի տեսակներ կան:
Համակարգի պահպանման ընթացակարգերը (eng.համակարգի պահպանման ընթացակարգը) տրամադրվում են DBMS մշակողների կողմից և օգտագործվում են համակարգի կատալոգում գործողություններ կատարելու կամ համակարգի տեղեկատվություն ստանալու համար: Նրանց անունները սովորաբար սկսվում են «sp_» նախածանցով։ Բոլոր տեսակի պահված ընթացակարգերը կանչվում են EXECUTE հրամանով, որը կարող է կրճատվել որպես EXEC: Օրինակ, sp_hellogins պահպանված ընթացակարգը, որն աշխատում է առանց պարամետրերի, ստեղծում է երկու հաշվետվություն հաշիվների անունների վերաբերյալ: (անգլ.մուտքեր) և դրանց համապատասխան օգտվողները յուրաքանչյուր տվյալների բազայում (անգլ.օգտվողներ):
EXEC sp_hellogins;
Համակարգում պահվող ընթացակարգերի օգտագործմամբ կատարված գործողությունների մասին պատկերացում կազմելու համար՝ աղյուսակում. 10.6-ը տալիս է մի քանի օրինակ: SQL Server-ում կան ավելի քան հազար համակարգային պահված ընթացակարգեր:
Աղյուսակ 10.6
SQL Server համակարգի Պահպանված ընթացակարգի օրինակներ
Օգտագործողը կարող է ստեղծել պահված ընթացակարգեր օգտվողների տվյալների բազաներում և տվյալների բազաներում ժամանակավոր օբյեկտների համար: Վերջին դեպքում պահպանված ընթացակարգը կլինի ժամանակավոր.Ինչպես ժամանակավոր աղյուսակների դեպքում, ժամանակավոր պահպանված ընթացակարգի անվանումը պետք է սկսվի «#» նախածանցով, եթե դա տեղական ժամանակավոր պահպանված պրոցեդուրա է, կամ «##»-ով, եթե այն գլոբալ է: Տեղական ժամանակավոր ընթացակարգը կարող է օգտագործվել միայն այն կապի շրջանակներում, որում այն ստեղծվել է, գլոբալը և այլ կապեր:
SQL Server ծրագրավորվող օբյեկտները կարող են ստեղծվել Transact-SQL գործիքների կամ հավաքների միջոցով (անգլ. assembly) Microsoft .Net Framework-ի Common Language Runtime-ում (CRL): Այս ձեռնարկում կքննարկվի միայն առաջին մեթոդը:
Պահված ընթացակարգերը ստեղծվում են CREATE PROCEDURE հայտարարության միջոցով (կարելի է կրճատվել PROC-ով), որի ձևաչափը ներկայացված է ստորև.
CREATE (PROC I PROCEDURE) proc_name [; թիվ]
[(gparameter data_type)
[«Լռելյայն] |
[ՀԵՏ
[ՊԱՏՐՈՆՄԱՆ ՀԱՄԱՐ]
AS ([BEGIN] sql_statement [;] [... n] [END])
Եթե պահպանված պրոցեդուրան (կամ ձգան, ֆունկցիա, դիտում) ստեղծվում է ENCRYPTION տարբերակով, դրա կոդը փոխակերպվում է այնպես, որ տեքստը դառնում է անընթեռնելի: Միևնույն ժամանակ, ինչպես նշվեց, օգտագործված ալգորիթմը փոխանցվել է SQL Server-ի ավելի վաղ տարբերակներից և չի կարող համարվել որպես հուսալի պաշտպանության ալգորիթմ. կան կոմունալ ծառայություններ, որոնք թույլ են տալիս արագ կատարել հակադարձ փոխարկումը:
RECOMPILE տարբերակը համակարգին հրահանգում է վերակազմավորել տեքստը ամեն անգամ, երբ ընթացակարգը կանչվում է: Սովորաբար, առաջին մեկնարկից կազմված ընթացակարգը պահվում է քեշում, ինչը կարող է բարելավել կատարումը:
EXECUTE AS-ը սահմանում է անվտանգության համատեքստը, որում պետք է իրականացվի ընթացակարգը: Այնուհետև F CALLER |. արժեքներից մեկը ԻՆՔԸ | ՍԵՓԱԿԱՆԱՏԵՐ | "օգտագործողի անունը"). CALLER-ը լռելյայն է և նշանակում է, որ կոդը կկատարվի այս մոդուլը զանգահարող օգտատիրոջ անվտանգության համատեքստում: Համապատասխանաբար, օգտատերը պետք է թույլտվություններ ունենա ոչ միայն բուն ծրագրավորված օբյեկտի, այլև դրա ազդեցության տակ գտնվող տվյալների բազայի այլ օբյեկտների համար: ԿԱՏԱՐԵԼ ՈՐՊԵՍ ԻՆՔՆԵՍ նշանակում է օգտագործողի համատեքստի օգտագործում՝ ստեղծելով կամ փոփոխելով ծրագրավորվող օբյեկտ: OWNER-ը նշում է, որ կոդը կկատարվի ընթացակարգի ներկայիս սեփականատիրոջ համատեքստում: Եթե դրա համար ոչ մի սեփականատեր սահմանված չէ, ապա նկատի ունի այն սխեմայի սեփականատերը, որին այն պատկանում է: EXECUTE AS «user_name»-ը թույլ է տալիս հստակորեն նշել օգտվողի անունը (միայն չակերտներով):
Պարամետրերը կարող են սահմանվել ընթացակարգի համար: Սրանք տեղական փոփոխականներ են, որոնք օգտագործվում են արժեքները ընթացակարգին փոխանցելու համար: Եթե պարամետրը հայտարարված է OUTPUT բանալի բառով (կամ կարճ՝ OUT), դա ելքային պարամետր է. դրա ավարտից հետո ընթացակարգում նշված արժեքը կարող է օգտագործվել այն ծրագրի կողմից, որն անվանել է ընթացակարգ: READONLY հիմնաբառը նշանակում է, որ պարամետրի արժեքը չի կարող փոխվել պահպանված ընթացակարգի ներսում:
Պարամետրերին կարող են նշանակվել արժեքներ, բայց լռելյայն, որոնք կօգտագործվեն, եթե ընթացակարգը կանչելիս պարամետրի արժեքը բացահայտորեն նշված չէ: Դիտարկենք մի օրինակ.
ՍՏԵՂԾԵԼ PROC surma (@ a int, @b int = 0,
© արդյունք int ԱՐԴՅՈՒՆՔ) AS
SET @ արդյունք = 0a + 0b
Մենք ստեղծել ենք պրոցեդուրա երեք պարամետրով, և @b պարամետրն ունի 0 լռելյայն արժեք, իսկ @result պարամետրը ելքային պարամետր է՝ դրա միջոցով արժեքը վերադարձվում է կանչող ծրագրին։ Կատարված գործողությունները բավականին պարզ են. ելքային պարամետրը ստանում է երկու մուտքերի գումարի արժեքը:
SQL Server Management Studio-ում աշխատելիս ստեղծված պահպանված ընթացակարգը կարելի է գտնել Ծրագրավորվող DB Objects բաժնում։ (անգլ.Ծրագրավորելիություն) պահեստավորված ընթացակարգերի ենթաբաժնում (Նկար 10.2):
Ընթացակարգ կանչելիս կարող եք օգտագործել և՛ փոփոխականները, և՛ հաստատունները որպես մուտքային պարամետրեր: Դիտարկենք երկու օրինակ։ Առաջինում ընթացակարգի մուտքային պարամետրերը հստակորեն սահմանված են հաստատուններով, զանգի ելքային պարամետրի համար նշվում է OUTPUT հիմնաբառը: Երկրորդ տարբերակում փոփոխականի արժեքը օգտագործվում է որպես առաջին մուտքային պարամետր, իսկ երկրորդ պարամետրի համար, օգտագործելով DEFAULT հիմնաբառը, նշվում է, որ պետք է օգտագործվի լռելյայն արժեքը.
Բրինձ. 10.2.
ՀԱՅՏԱՐԱՐԵԼ @ int-ով;
EXEC ամփոփում 10.5, @ c OUTPUT;
PRINT 0c; - կցուցադրվի 15
ՀԱՅՏԱՐԱՐԵԼ Gi int = 5;
- զանգելիս օգտագործեք լռելյայն արժեքը
EXEC ամփոփում Gi, DEFAULT, 0с OUTPUT;
PRINT 0c; - 5-ը կցուցադրվի
Այժմ դիտարկենք վերադարձի կոդի վերլուծության օրինակ, որով ավարտվում է ընթացակարգը: Թող անհրաժեշտ լինի հաշվարկել, թե քանի գիրք է հրատարակվել Bookl աղյուսակում տարիների տվյալ միջակայքում: Ավելին, եթե սկզբնական տարին ավելի շատ է ստացվել, քան վերջինը, ապա ընթացակարգը վերադարձնում է «1» և չի հաշվում, հակառակ դեպքում մենք հաշվում ենք գրքերի քանակը և վերադարձնում 0.
ՍՏԵՂԾԵԼ PROC dbo.rownum (0FirsYear int, GLastYear int, 0result int OUTPUT) ՈՐՊԵՍ
ԵԹԵ 0 FirstYear> 0 LastYear RETURN 1
SET @ result = (SELECT COUNT (*) FROM dbo.Bookl
ՈՐՏԵՂ 0ԱՌԱՋԻՆ ԵՎ 0ԱՌԱՋԻՆՏԱՐԻ ՄԻՋԵՎ);
Դիտարկենք այս պրոցեդուրա անվանման տարբերակը, որի դեպքում վերադարձի կոդը պահվում է 0ret ամբողջ թվով փոփոխականում, որից հետո վերլուծվում է դրա արժեքը (այս դեպքում այն կլինի 1): PRINT օպերատորում օգտագործվող CAST ֆունկցիան օգտագործվում է Gres ամբողջ թվային փոփոխականի արժեքը տողի տիպի փոխարկելու համար.
ՀԱՅՏԱՐԱՐԵԼ 0ret int, Gres int
EXEC Gret = rownum 2004, 2002, Gres OUT;
IF 0ret = l PRINT «Մեկնարկային տարին ավելի մեծ է, քան ավարտվողը»
PRINT «Գրքերի թիվը» + CAST (Gres as varchar (20))
Պահված պրոցեդուրաները կարող են ոչ միայն կարդալ տվյալները աղյուսակից, այլև փոփոխել տվյալները և նույնիսկ ստեղծել աղյուսակներ և տվյալների բազայի մի շարք այլ օբյեկտներ:
Այնուամենայնիվ, դուք չեք կարող ստեղծել սխեմաներ, գործառույթներ, գործարկիչներ, ընթացակարգեր և դիտումներ պահված ընթացակարգից:
Հետևյալ օրինակը ցույց է տալիս և՛ այս հնարավորությունները, և՛ ժամանակավոր օբյեկտների շրջանակը: Ստորև բերված պահպանված ընթացակարգը ստուգում է # thab2 ժամանակավոր աղյուսակի առկայությունը. եթե այս աղյուսակը գոյություն չունի, ապա ստեղծում է այն: Դրանից հետո երկու սյունակների արժեքները մուտքագրվում են # Tab2 աղյուսակում, իսկ աղյուսակի բովանդակությունը ցուցադրվում է SELECT հայտարարությամբ.
ՍՏԵՂԾԵԼ PROC My_Procl (@id int, @name varchar (30))
ԵԹԵ OBJECT_ID («tempdb.dbo. # Tab21) զրոյական է
INSERT INTO dbo. # Tab2 (id, name) VALUES (0id, 0name)
SELECT * FROM dbo-ից: # Tab2 –№1
Նախքան պահված ընթացակարգի առաջին կանչը, մենք կստեղծենք դրանում օգտագործվող # Thab2 ժամանակավոր աղյուսակը: Ուշադրություն դարձրեք EXEC օպերատորին: Նախորդ օրինակներում պարամետրերը փոխանցվել են ընթացակարգին «ըստ դիրքի», և այս դեպքում օգտագործվում է պարամետրերի փոխանցման մեկ այլ ձևաչափ՝ «անվանմամբ», պարամետրի անվանումը և դրա արժեքը հստակորեն նշվում են.
ՍՏԵՂԾԵԼ ԱՂՅՈՒՍԱԿ dbo.# Tab2 (id int, անունը varchar (30));
EXEC My_Procl 0name = «lvan», 0id = 2;
SELECT * FROM dbo.# Tab2; –№2
Վերոնշյալ օրինակում SELECT հայտարարությունը կկատարվի երկու անգամ՝ առաջին անգամ՝ ընթացակարգի ներսում, երկրորդ անգամ՝ կանչող կոդի հատվածից (նշված «# 2» մեկնաբանությամբ):
Մինչև ընթացակարգի երկրորդ զանգը մենք կջնջենք # Tab2 ժամանակավոր աղյուսակը։ Այնուհետև պահպանված ընթացակարգից կստեղծվի համանուն ժամանակավոր աղյուսակը.
ԳՈՐԾԵԼ ՍԵՂԱՆԻ dbo.# Tab2;
EXEC My_Procl 0name = «Իվան», 0id = 2;
SELECT * FROM dbo.# Tab2; –№2
Այս դեպքում միայն ընթացակարգի ներսում SELECT հայտարարությունը («Xa 1» մեկնաբանությամբ) կցուցադրի տվյալները: SELECT «# 2»-ը կհանգեցնի սխալի, քանի որ պահպանված ընթացակարգում ստեղծված ժամանակավոր աղյուսակն արդեն ջնջվել է tempdb-ից ընթացակարգի վերադարձի պահին:
Դուք կարող եք թողնել պահպանված ընթացակարգը՝ օգտագործելով DROP PROCEDURE հայտարարությունը: Դրա ձևաչափը ներկայացված է ստորև: Մեկ օպերատորը կարող է ջնջել մի քանի պահպանված ընթացակարգեր՝ թվարկելով դրանք բաժանված ստորակետերով.
DOP (PROC I PROCEDURE) (ընթացակարգ) [
Օրինակ, եկեք հեռացնենք նախկինում ստեղծված ընթացակարգի ամփոփումը.
DROP PROC ամփոփում;
Դուք կարող եք փոփոխություններ կատարել գոյություն ունեցող ընթացակարգում (և ըստ էության, անտեսել այն) օգտագործելով ALTER PROCEDURE հայտարարությունը (թույլատրելի է):
PROC հապավումը): Բացառությամբ ALTER հիմնաբառի, հայտարարության ձևաչափը նման է CREATE PROCEDURE-ի ձևաչափին: Օրինակ՝ փոխենք dbo պրոցեդուրան։ rownum՝ սահմանելով այն կատարման տարբերակ սեփականատիրոջ անվտանգության համատեքստում.
ALTER PROC dbo.rownum (SFirsYear int,
SLastYear int, Sresult int OUTPUT)
WITH EXECUTE AS Owner-ը տեղադրվող տարբերակ է
ԵԹԵ 0Առաջին Տարի> 0Անցյալ Տարի ՎԵՐԱԴԱՐՁՆԵՔ 1 ՈՒԼՍ ՍԿՍԵԼ
SET 0result = (SELECT COUNT (*) FROM dbo.Bookl
ՈՐՏԵՂ SFirsYear-ի և SLastYear-ի միջև);
Որոշ դեպքերում կարող է անհրաժեշտ լինել դինամիկ ձևավորել հրաման և կատարել այն տվյալների բազայի սերվերում: Այս խնդիրը կարող է լուծվել նաև EXEC օպերատորի միջոցով: Ստորև բերված օրինակը գրառումներ է բերում Bookl աղյուսակից այն պայմանով, որ Year հատկանիշը հավասար է փոփոխականի օգտագործմամբ սահմանված արժեքին.
ՀԱՅՏԱՐԱՐԵԼ 0y int = 2000;
EXEC («SELECT * FROM dbo.Bookl WHERE =" [էլփոստը պաշտպանված է]) ;
Դինամիկ գեներացվող հրահանգների կատարումը նախադրյալներ է ստեղծում համակարգչային գրոհների իրականացման համար, ինչպիսին է «SQL ներարկումը»: (անգլ. SQL ներարկում): Հարձակման էությունն այն է, որ հարձակվողը ներարկում է իր սեփական SQL կոդը դինամիկ ձևավորված հարցման մեջ: Սա սովորաբար տեղի է ունենում, երբ փոխարինված պարամետրերը վերցվում են օգտվողի մուտքագրման արդյունքներից:
Մի փոքր փոխենք նախորդ օրինակը.
ՀԱՅՏԱՐԱՐԵԼ 0y varchar (100);
SET 0y = «2OOO»; - մենք դա ստացել ենք օգտվողից
Եթե ենթադրենք, որ օգտվողից ստացել ենք SET հայտարարության մեջ նշանակված տողի արժեքը (անկախ նրանից, թե ինչպես, օրինակ, վեբ հավելվածի միջոցով), ապա օրինակը ցույց է տալիս մեր կոդի «կանոնավոր» վարքը։
ՀԱՅՏԱՐԱՐԵԼ 0y varchar (100);
SET 0y = "2000; Ջնջել dbo.Book2-ից"; - ներարկում
EXEC («SELECT * FROM dbo.Book2 WHERE =" + 0y);
Նման դեպքերում խորհուրդ է տրվում հնարավորության դեպքում օգտագործել sp_executcsql համակարգի պահպանման պրոցեդուրան, որը թույլ է տալիս վերահսկել պարամետրերի տեսակը, որը հանդիսանում է SQL ներարկման խոչընդոտներից մեկը։ Առանց դրա ձևաչափը մանրամասն դիտարկելու, եկեք վերլուծենք ավելի վաղ ներկայացվածի նման օրինակ.
ԿԱՏԱՐԵԼ sp_executesql
N «SELECT * FROM dbo.Bookl WHERE = 0y»,
Սա հստակորեն սահմանում է հարցման մեջ օգտագործվող պարամետրի տեսակը և կվերահսկվի SQL Server-ի կողմից կատարման ընթացքում: Չակերտների դիմաց «N» տառը ցույց է տալիս, որ սա Unicode բառացի հաստատուն է, ինչպես պահանջվում է ընթացակարգով: Պարամետրին կարող է վերագրվել ոչ միայն հաստատուն արժեք, այլև մեկ այլ փոփոխականի արժեք:
Պահպանված ընթացակարգ Transact-SQL հայտարարությունների հատուկ տեսակ է, որը ստեղծվել է SQL լեզվի և ընթացակարգային ընդլայնումների միջոցով: Փաթեթի և պահեստավորված ընթացակարգի միջև հիմնական տարբերությունն այն է, որ վերջինս պահվում է որպես տվյալների բազայի օբյեկտ: Այլ կերպ ասած, պահպանված ընթացակարգերը պահպանվում են սերվերի կողմից՝ կատարելագործման և կրկնելիության բարելավման համար:
Տվյալների բազայի շարժիչը աջակցում է պահպանված ընթացակարգերին և համակարգի ընթացակարգերին: Պահված ընթացակարգերը ստեղծվում են այնպես, ինչպես տվյալների բազայի բոլոր օբյեկտները, այսինքն. օգտագործելով DDL լեզուն: Համակարգային ընթացակարգերտրամադրվում են Database Engine-ի կողմից և կարող են օգտագործվել համակարգի կատալոգում տեղեկատվությունը մուտք գործելու և փոփոխելու համար:
Երբ դուք ստեղծում եք պահված ընթացակարգ, կարող եք սահմանել կամընտիր պարամետրերի ցանկ: Այսպիսով, ընթացակարգը կընդունի համապատասխան փաստարկները ամեն անգամ, երբ այն կանչվի: Պահված ընթացակարգերը կարող են վերադարձնել արժեք, որը պարունակում է օգտագործողի կողմից սահմանված տեղեկատվություն կամ սխալի դեպքում՝ կապված սխալի հաղորդագրություն:
Պահված պրոցեդուրան նախօրոք հավաքվում է տվյալների բազայում որպես օբյեկտ պահվելուց առաջ: Պրոցեդուրայի նախապես կազմված ձևը պահվում է տվյալների բազայում և օգտագործվում է ամեն անգամ, երբ այն կանչվում է: Պահպանված ընթացակարգերի այս հատկությունը կարևոր օգուտ է տալիս նրանով, որ վերացնում է (գրեթե բոլոր դեպքերում) ընթացակարգի վերակազմավորումը և ապահովում է համապատասխան կատարողական բարելավում: Պահված ընթացակարգերի այս հատկությունը նույնպես դրական է ազդում տվյալների բազայի համակարգի և հավելվածների միջև փոխանակվող տվյալների քանակի վրա: Մասնավորապես, մի քանի հազար բայթ ծավալով պահպանված պրոցեդուրա կանչելը կարող է պահանջել 50 բայթից պակաս: Երբ մի քանի օգտվողներ կատարում են կրկնվող առաջադրանքներ՝ օգտագործելով պահպանված ընթացակարգերը, այդ խնայողությունների կուտակային ազդեցությունը կարող է նշանակալի լինել:
Պահպանված ընթացակարգերը կարող են օգտագործվել նաև հետևյալ նպատակների համար.
տվյալների բազայի աղյուսակներով գործողությունների մատյան ստեղծելու համար:
Պահված ընթացակարգերի օգտագործումը ապահովում է անվտանգության վերահսկման մակարդակ, որը զգալիորեն գերազանցում է GRANT և REVOKE հայտարարությունների օգտագործմամբ ապահովված անվտանգության մակարդակը, որոնք օգտվողներին տրամադրում են մուտքի տարբեր արտոնություններ: Դա հնարավոր է, քանի որ պահպանված ընթացակարգի կատարման թույլտվությունը անկախ է տվյալ պահպանված ընթացակարգում պարունակվող օբյեկտները փոփոխելու թույլտվությունից, ինչպես նկարագրված է հաջորդ բաժնում:
Պահված ընթացակարգերը, որոնք ստեղծում են տեղեկամատյաններ աղյուսակների վրա գրելու և/կամ կարդալու համար, լրացուցիչ անվտանգություն են ապահովում տվյալների բազայի համար: Օգտագործելով այս ընթացակարգերը՝ տվյալների բազայի ադմինիստրատորը կարող է հետևել օգտատերերի կամ հավելվածների կողմից տվյալների բազայում կատարված փոփոխություններին:
Պահպանված ընթացակարգերի ստեղծում և իրականացում
Պահպանված ընթացակարգերը ստեղծվում են հայտարարության միջոցով ՍՏԵՂԾԵԼ ԿԱՐԳԸորն ունի հետևյալ շարահյուսությունը.
CREATE PROC proc_name [((@ param1) type1 [ՏԱՐԲԵՐԱԿԱՆ] [= լռելյայն1])] (,…) AS խմբաքանակ | EXTERNAL NAME method_name Շարահյուսական կոնվենցիաներ
schema_name պարամետրը սահմանում է սխեմայի անունը, որը նշանակված է որպես գեներացված պահպանված ընթացակարգի սեփականատեր: Proc_name պարամետրը նշում է պահպանված ընթացակարգի անվանումը: @ param1 պարամետրը ընթացակարգի պարամետր է (ֆորմալ արգումենտ), որի տվյալների տեսակը նշված է type1 պարամետրով։ Ընթացակարգի պարամետրերը լոկալ են ընթացակարգի մեջ, ինչպես տեղական փոփոխականները՝ փաթեթի ներսում: Ընթացակարգի պարամետրերը արժեքներ են, որոնք զանգահարողի կողմից փոխանցվում են դրանում օգտագործման ընթացակարգին: Default1 պարամետրը սահմանում է լռելյայն արժեքը համապատասխան ընթացակարգի պարամետրի համար: (Լռելյայն կարող է լինել նաև NULL):
OUTPUT տարբերակցույց է տալիս, որ պրոցեդուրաների պարամետրը վերադարձելի պարամետր է, որը կարող է օգտագործվել պահված պրոցեդուրայից արժեք վերադարձնելու համար կանչող ընթացակարգ կամ համակարգ:
Ինչպես նշվեց ավելի վաղ, պրոցեդուրի նախապես կազմված ձևը պահվում է տվյալների բազայում և օգտագործվում է ամեն անգամ, երբ այն կանչվում է: Եթե ինչ-ինչ պատճառներով պահվող ընթացակարգը պետք է կազմվի ամեն անգամ, երբ այն կանչվում է, ապա ընթացակարգը հայտարարելիս օգտագործեք տարբերակ ՎԵՐԱԿՈՄՊԻԼՈՎ... ՎԵՐԱԿՈՄՊԻԼՈՎ տարբերակի օգտագործումը ժխտում է պահված ընթացակարգերի ամենակարևոր առավելություններից մեկը՝ մեկ հավաքածուից կատարողականի բարելավումը: Հետևաբար, WITH RECOMPILE տարբերակը պետք է օգտագործվի միայն տվյալների բազայի օբյեկտներում հաճախակի փոփոխություններ կատարելու դեպքում, որոնք օգտագործվում են պահված ընթացակարգով:
ԿԱՏԱՐԵԼ ՈՐՊԵՍ դրույթսահմանում է անվտանգության համատեքստը, որում պահպանված ընթացակարգը պետք է գործարկվի այն կանչելուց հետո: Սահմանելով այս համատեքստը՝ դուք կարող եք օգտագործել տվյալների բազայի շարժիչը՝ վերահսկելու օգտատերերի հաշիվների ընտրությունը՝ ստուգելու համար մուտքի թույլտվությունները այս պահպանված ընթացակարգով նշված օբյեկտների վրա:
Լռելյայնորեն, միայն sysadmin ֆիքսված սերվերի դերի անդամները և db_owner կամ db_ddladmin ֆիքսված տվյալների բազայի դերը կարող են օգտագործել CREATE PROCEDURE հայտարարությունը: Բայց այս դերերի անդամները կարող են այս իրավունքը վերագրել այլ օգտվողներին՝ օգտագործելով հրահանգը ԳՐԱՆՑԻ ՍՏԵՂԾՄԱՆ ԿԱՐԳԸ.
Ստորև բերված օրինակը ցույց է տալիս, թե ինչպես կարելի է ստեղծել մի պարզ պահված ընթացակարգ՝ Ծրագրի աղյուսակի հետ աշխատելու համար.
ՕԳՏԱԳՈՐԾԵԼ SampleDb; ԳՆԱԼ ՍՏԵՂԾԵԼ ԸՆԹԱՑՔԸ IncreaseBudget (@percent INT = 5) ՈՐՊԵՍ ԹԱՐՄԱՑՆԵԼ Ծրագրի SET Բյուջե = Բյուջե + Բյուջե * @ տոկոս / 100;
Ինչպես նշվեց ավելի վաղ, երկու փաթեթ առանձնացնելու համար օգտագործեք GO հրահանգ... CREATE PROCEDURE հայտարարությունը չի կարող համակցվել նույն փաթեթի այլ Transact-SQL հայտարարությունների հետ: IncreaseBudget պահպանված ընթացակարգը մեծացնում է բոլոր նախագծերի բյուջեները որոշակի տոկոսով, որը նշված է @percent պարամետրով: Ընթացակարգը նաև սահմանում է լռելյայն տոկոսային արժեք (5), որն օգտագործվում է, եթե ընթացակարգի ընթացքում այս արգումենտը չկա:
Պահված ընթացակարգերը կարող են մուտք գործել աղյուսակներ, որոնք գոյություն չունեն: Այս հատկությունը թույլ է տալիս վրիպազերծել ընթացակարգի կոդը՝ նախապես չստեղծելով համապատասխան աղյուսակներ կամ նույնիսկ միանալու նպատակակետ սերվերին:
Ի տարբերություն հիմնական պահպանված պրոցեդուրաների, որոնք միշտ պահվում են ընթացիկ տվյալների բազայում, հնարավոր է ստեղծել ժամանակավոր պահպանված ընթացակարգեր, որոնք միշտ տեղադրվում են ժամանակավոր համակարգի տվյալների բազայում tempdb: Ժամանակավոր պահվող ընթացակարգեր ստեղծելու պատճառներից մեկը կարող է լինել տվյալների բազայի հետ միանալու ժամանակ հայտարարությունների որոշակի խմբի կրկնվող կատարումից խուսափելը: Դուք կարող եք ստեղծել տեղական կամ գլոբալ ժամանակավոր ընթացակարգեր: Դրա համար տեղական պրոցեդուրի անունը նշվում է մեկ # նշանով (#proc_name), իսկ գլոբալ պրոցեդուրի անունը նշվում է կրկնակի (## proc_name):
Տեղական ժամանակավոր պահպանված ընթացակարգը կարող է իրականացվել միայն այն ստեղծած օգտագործողի կողմից և միայն այն տվյալների բազայի հետ միացման ժամանակ, որտեղ այն ստեղծվել է: Համաշխարհային ժամանակավոր ընթացակարգը կարող է իրականացվել բոլոր օգտագործողների կողմից, բայց միայն մինչև ավարտվի վերջին կապը, որով այն իրականացվում է (սովորաբար պրոցեդուրա ստեղծողի կապը):
Պահեստավորված ընթացակարգի կյանքի ցիկլը բաղկացած է երկու փուլից՝ դրա ստեղծում և կատարում: Յուրաքանչյուր պրոցեդուրա ստեղծվում է մեկ անգամ և կատարվում է մի քանի անգամ: Պահպանված ընթացակարգն իրականացվում է ԿԱՏԱՐԵԼ հայտարարություններօգտատեր, ով տիրապետում է ընթացակարգին կամ ունի EXECUTE թույլտվություն՝ մուտք գործելու այդ ընթացակարգը: EXECUTE հայտարարությունը ունի հետևյալ շարահյուսությունը.
[] [@return_status =] (proc_name | @proc_name_var) ([[@ պարամետր1 =] արժեք | [@ պարամետր1 =] @փոփոխական] | ԼՐԱԴՐՎԱԾ) .. Շարահյուսական կոնվենցիաներ
Բացառությամբ return_status պարամետրի, EXECUTE դրույթի բոլոր պարամետրերն ունեն նույն տրամաբանական նշանակությունը, ինչ CREATE PROCEDURE դրույթի համանուն պարամետրերը: return_status պարամետրը սահմանում է ամբողջ թվով փոփոխական, որը պահպանում է ընթացակարգի վերադարձի վիճակը: Արժեքը կարող է վերագրվել պարամետրին՝ օգտագործելով կա՛մ հաստատուն (արժեք) կա՛մ տեղական փոփոխական (@variable): Անվանված պարամետրերի արժեքների հերթականությունը կարևոր չէ, բայց անանուն պարամետրերի արժեքները պետք է տրամադրվեն այն հաջորդականությամբ, որով դրանք սահմանված են «ՍՏԵՂԾԵԼ ԿԱՐԳԸ» հայտարարության մեջ:
DEFAULT կետապահովում է լռելյայն արժեքներ ընթացակարգի պարամետրի համար, որը նշված է ընթացակարգի սահմանման մեջ: Սխալ է առաջանում, երբ ընթացակարգն ակնկալում է արժեք այն պարամետրի համար, որի համար լռելյայն արժեք չի սահմանվել և որևէ պարամետր նշված չէ, կամ նշվում է DEFAULT հիմնաբառը:
Երբ EXECUTE հայտարարությունը խմբաքանակի առաջին հայտարարությունն է, EXECUTE հիմնաբառը կարող է բաց թողնել: Այնուամենայնիվ, ավելի անվտանգ է այս բառը ներառել յուրաքանչյուր փաթեթում: EXECUTE հայտարարության օգտագործումը ցույց է տրված ստորև բերված օրինակում.
ՕԳՏԱԳՈՐԾԵԼ SampleDb; ԿԱՏԱՐԵԼ Բարձրացնել բյուջեն 10;
Այս օրինակի EXECUTE հայտարարությունը կատարում է IncreaseBudget պահպանված ընթացակարգը, որը բոլոր նախագծերի բյուջեն ավելացնում է 10%-ով:
Ստորև բերված օրինակը ցույց է տալիս, թե ինչպես ստեղծել պահված ընթացակարգ՝ Employee և Works_on աղյուսակներում տվյալները մշակելու համար.
Օրինակում ModifyEmpId ընթացակարգը ցույց է տալիս պահված ընթացակարգերի օգտագործումը որպես ուղղորդման ամբողջականության գործընթացի մաս (այս դեպքում՝ Employee և Works_on աղյուսակների միջև): Նմանատիպ պահպանված ընթացակարգը կարող է օգտագործվել ձգանման սահմանման մեջ, որն իրականում ապահովում է հղումների ամբողջականությունը:
Ստորև բերված օրինակը ցույց է տալիս OUTPUT դրույթի օգտագործումը պահպանված ընթացակարգում.
Այս պահված ընթացակարգը կարող է իրականացվել հետևյալ հրահանգների միջոցով.
ՀԱՅՏԱՐԱՐԵԼ @quantityDeleteEmployee INT; ԿԱՏԱՐԵՔ DeleteEmployee @ empId = 18316, @ [էլփոստը պաշտպանված է]ԱՐԴՅՈՒՆՔ; PRINT N «Ջնջված աշխատակիցներ.» + փոխակերպում (nvarchar (30), @quantityDeleteEmployee);
Այս ընթացակարգը հաշվում է նախագծերի քանակը, որոնցում զբաղված է @empId համարով աշխատողը, և ստացված արժեքը վերագրում է պարամետրին © հաշվիչը: Employee և Works_on աղյուսակներից տվյալ անձնակազմի համարի բոլոր տողերը ջնջելուց հետո հաշվարկված արժեքը վերագրվում է @quantityDeleteEmployee փոփոխականին:
Պարամետրի արժեքը վերադարձվում է կանչի ընթացակարգին միայն այն դեպքում, եթե նշված է OUTPUT տարբերակը: Վերոնշյալ օրինակում DeleteEmployee պրոցեդուրան փոխանցում է @counter պարամետրը կանչող ընթացակարգին, ուստի պահպանված ընթացակարգը արժեք է վերադարձնում համակարգին: Հետևաբար, @counter պարամետրը պետք է նշվի և՛ OUTPUT տարբերակում՝ ընթացակարգ հայտարարելիս, և՛ EXECUTE ցուցումում՝ այն կանչելիս:
ԱՐԴՅՈՒՆՔՆԵՐՈՎ սահմանում է EXECUTE քաղվածքի դրույթը
SQL Server 2012-ում մուտքագրվում է EXECUTE հայտարարությունը ԱՐԴՅՈՒՆՔՆԵՐՈՎ ԿԱԶՄՎՈՒՄ Է դրույթ, որի միջոցով, երբ որոշակի պայմաններ բավարարվեն, կարող եք փոխել պահպանված ընթացակարգի արդյունքների հավաքածուի ձևը:
Հետևյալ երկու օրինակները կօգնեն բացատրել այս նախադասությունը: Առաջին օրինակը ներածական օրինակ է, որը ցույց է տալիս, թե ինչպիսին կարող է լինել արդյունքը, երբ ԱՐԴՅՈՒՆՔՆԵՐՈՎ ԿԱԶՄՎՈՒՄ Է դրույթը բաց թողնված.
EmployeesInDept ընթացակարգը պարզ ընթացակարգ է, որը ցույց է տալիս կոնկրետ բաժնում աշխատող բոլոր աշխատակիցների անձնակազմի համարներն ու ազգանունները: Բաժանմունքի համարը ընթացակարգի պարամետր է և պետք է նշվի այն զանգահարելիս: Այս ընթացակարգը կատարելիս ցուցադրվում է երկու սյունակով աղյուսակ, որոնց վերնագրերը համընկնում են տվյալների բազայի աղյուսակի համապատասխան սյունակների անունների հետ, այսինքն. ID և ազգանուն: SQL Server 2012-ը օգտագործում է նոր WITH RESULTS SETS դրույթը՝ փոխելու արդյունքների սյունակների վերնագրերը (ինչպես նաև դրանց տվյալների տեսակը): Այս առաջարկի կիրառումը ներկայացված է ստորև բերված օրինակում.
ՕԳՏԱԳՈՐԾԵԼ SampleDb; EXEC EmployeesInDept «d1» ԱՐԴՅՈՒՆՔՆԵՐԻ ԿԱԶՄԱՎՈՐՈՒՄՆԵՐՈՎ ((INT NOT NULL, [Ազգանուն] CHAR (20) NOT NULL));
Այս կերպ կոչված պահված ընթացակարգի կատարման արդյունքը կլինի հետևյալը.
Ինչպես տեսնում եք, պահպանված պրոցեդուրան գործարկելը, օգտագործելով WITH RESULT SETS կետը EXECUTE հայտարարության մեջ, թույլ է տալիս փոխել սյունակների անվանումները և տվյալների տեսակը ընթացակարգով վերադարձված արդյունքների հավաքածուում: Այսպիսով, այս նոր ֆունկցիոնալությունը ավելի մեծ ճկունություն է ապահովում պահված ընթացակարգերի կատարման և դրանց արդյունքները նոր աղյուսակում տեղադրելու հարցում:
Պահպանված ընթացակարգերի կառուցվածքի փոփոխություն
Տվյալների բազայի շարժիչը նույնպես աջակցում է հայտարարությանը ՓՈՓՈԽԱԿԱՆ ԿԱՐԳԸփոփոխել պահպանված ընթացակարգերի կառուցվածքը: ALTER PROCEDURE-ը սովորաբար օգտագործվում է ընթացակարգի շրջանակներում Transact-SQL հայտարարությունները փոփոխելու համար: ALTER PROCEDURE հայտարարության բոլոր պարամետրերն ունեն նույն նշանակությունը, ինչ նույն անվանման պարամետրերը CREATE PROCEDURE հայտարարության համար: Այս հայտարարության օգտագործման հիմնական նպատակն է խուսափել գոյություն ունեցող պահպանված ընթացակարգի իրավունքների գերակայությունից:
Տվյալների բազայի շարժիչը աջակցում է տվյալների տեսակը CURSOR... Տվյալների այս տեսակն օգտագործվում է պահված ընթացակարգերում կուրսորները հայտարարելու համար: Կուրսորըծրագրավորման կառուցվածք է, որն օգտագործվում է հարցման արդյունքները պահելու համար (սովորաբար տողերի մի շարք) և օգտատերերին այդ արդյունքը տող առ տող ցուցադրելու հնարավորություն տալու համար։
Պահված ընթացակարգերից մեկը կամ մի խումբ ջնջելու համար օգտագործեք ՆԿԱՏԵԼՈՒ ԿԱՐԳԸ հայտարարություն... Միայն db_owner և sysadmin ֆիքսված դերերի սեփականատերը կամ անդամները կարող են ջնջել պահպանված ընթացակարգը:
Պահպանված ընթացակարգերը և CLR-ը
SQL Server-ն աջակցում է Common Language Runtime-ին (CLR), որը թույլ է տալիս մշակել տվյալների բազայի տարբեր օբյեկտներ (պահված ընթացակարգեր, UDF, գործարկիչներ, UDF-ներ և UDD-ներ)՝ օգտագործելով C # և Visual Basic: CLR-ը նաև թույլ է տալիս գործարկել այս օբյեկտները՝ օգտագործելով ընդհանուր գործարկման համակարգը:
CLR-ն թույլատրվում և մերժվում է տարբերակով clr_enabledհամակարգի ընթացակարգը sp_configure, որը սկսվում է կատարման հրահանգով ՎԵՐԱԿԱՐԳԱՎՈՐՈՒՄ... Ստորև բերված օրինակը ցույց է տալիս, թե ինչպես կարելի է միացնել CLR-ն՝ օգտագործելով sp_configure համակարգի ընթացակարգը.
ՕԳՏԱԳՈՐԾԵԼ SampleDb; EXEC sp_configure «clr_enabled», 1 ՎԵՐԱԿԱՐԳԱՎՈՐՈՒՄ
CLR-ի միջոցով ընթացակարգ ստեղծելու, կազմելու և պահպանելու համար դուք պետք է կատարեք քայլերի հետևյալ հաջորդականությունը՝ հերթականությամբ.
Ստեղծեք պահպանված պրոցեդուրա C #-ում կամ Visual Basic-ում, այնուհետև այն կազմեք՝ օգտագործելով համապատասխան կոմպիլյատորը:
Օգտագործելով հրահանգը ՍՏԵՂԾԵԼ ՀԱՎԱՔ, ստեղծել համապատասխան գործարկվող ֆայլը։
Կատարեք ընթացակարգը՝ օգտագործելով EXECUTE հայտարարությունը:
Ստորև բերված նկարը ցույց է տալիս նախկինում ուրվագծված քայլերի սխեմա: Ստորև ներկայացված է այս գործընթացի ավելի մանրամասն նկարագրությունը:
Նախ, ստեղծեք անհրաժեշտ ծրագիրը զարգացման միջավայրում, ինչպիսին է Visual Studio-ն: Կազմեք պատրաստի ծրագիրը օբյեկտի կոդը՝ օգտագործելով C # կամ Visual Basic կոմպիլյատորը: Այս կոդը պահվում է դինամիկ հղումների գրադարանի (.dll) ֆայլում, որը հանդիսանում է CREATE ASSEMBLY հայտարարության աղբյուրը, որը ստեղծում է գործարկվող միջանկյալ կոդ: Հաջորդը, գործարկեք CREATE PROCEDURE հայտարարությունը, որպեսզի պահպանեք գործարկվող կոդը որպես տվյալների բազայի օբյեկտ: Ի վերջո, գործարկեք ընթացակարգը, օգտագործելով ծանոթ EXECUTE հայտարարությունը:
Ստորև բերված օրինակը ցույց է տալիս C #-ում պահվող ընթացակարգի սկզբնական կոդը.
Օգտագործելով System.Data.SqlClient; օգտագործելով Microsoft.SqlServer.Server; Public մասնակի դաս StoredProcedures (public static int CountEmployees () (int տողեր; SqlConnection կապ = նոր SqlConnection («Համատեքստային կապ = ճշմարիտ»); կապ. Բաց (); SqlCommand cmd = կապ. CreateCommand (); cmd.CommandText = «ընտրել» հաշվել (*) որպես «Աշխատակիցների թիվը» «+» Employee-ից «; տողեր = (int) cmd.ExecuteScalar (); կապ. Փակել (); վերադարձ տողեր;))
Այս ընթացակարգը իրականացնում է հարցում՝ աշխատողների աղյուսակում տողերի քանակը հաշվելու համար: Ծրագրի սկզբում օգտագործող դիրեկտիվները նշում են ծրագրի իրականացման համար անհրաժեշտ անվանատարածքները: Այս դիրեկտիվների օգտագործումը թույլ է տալիս սկզբնական կոդում նշել դասերի անունները՝ առանց հստակորեն նշելու համապատասխան անունների տարածքները: Այնուհետև սահմանվում է StoredProcedures դասը, որի համար SqlProcedure հատկանիշորը տեղեկացնում է կոմպիլյատորին, որ այս դասը պահված պրոցեդուրա է։ CountEmployees () մեթոդը սահմանվում է դասի կոդի ներսում: Տվյալների բազայի համակարգի հետ կապը հաստատվում է դասի օրինակի միջոցով SqlConnection... Կապ բացելու համար օգտագործվում է այդ օրինակի Open () մեթոդը։ Ա CreateCommand () մեթոդըթույլ է տալիս մուտք գործել դասի օրինակ SqlCommndորին փոխանցվում է պահանջվող SQL հրամանը:
Հետևյալ կոդի հատվածում.
Cmd.CommandText = "ընտրել համարը (*) որպես" Աշխատակիցների թիվը "" + "Աշխատակիցից";
օգտագործում է SELECT դրույթ՝ Աշխատակիցների աղյուսակում տողերի քանակը հաշվելու և արդյունքը ցուցադրելու համար: Հրամանի տեքստը սահմանվում է` սահմանելով cmd փոփոխականի CommandText հատկությունը CreateCommand () մեթոդով վերադարձված օրինակին: Հաջորդը կոչվում է ExecuteScalar () մեթոդը SqlCommand օրինակ: Այս մեթոդը վերադարձնում է սկալային արժեք, որը փոխակերպվում է int տվյալների տեսակին և վերագրվում է տողերին:
Այժմ կարող եք այս կոդը կազմել Visual Studio-ի միջոցով: Ես այս դասը ավելացրի CLRStoredProcedures անունով նախագծին, ուստի Visual Studio-ն կկազմի համանուն ժողովը * .dll ընդլայնմամբ: Ստորև բերված օրինակը ցույց է տալիս պահված ընթացակարգի ստեղծման հաջորդ քայլը՝ գործարկվող կոդի ստեղծում: Նախքան այս օրինակի կոդը գործարկելը, դուք պետք է իմանաք կազմված dll ֆայլի գտնվելու վայրը (սովորաբար գտնվում է նախագծի Debug պանակում):
ՕԳՏԱԳՈՐԾԵԼ SampleDb; GO CREATE ASSEMBLY CLRStoredProcedures FROM «D: \ Projects \ CLRSstoredProcedures \ bin \ Debug \ CLRStoredProcedures.dll»-ից PERMISSION_SET = ԱՆՎՏԱՆԳ
CREATE ASSEMBLY հայտարարությունն ընդունում է կառավարվող կոդը որպես մուտքագրում և ստեղծում է համապատասխան օբյեկտ, որի համար կարող եք ստեղծել CLR պահպանված ընթացակարգեր, UDF-ներ և գործարկիչներ: Այս հայտարարությունը ունի հետևյալ շարահյուսությունը.
ՍՏԵՂԾԵԼ ASSEMBLY assembly_name [AUTHORIZATION owner_name] FROM (dll_file) շարահյուսական կոնվենցիաներից
Assembly_name-ը նշում է ժողովի անվանումը: Լիցենզավորման կամընտիր դրույթը նշում է դերի անունը՝ որպես այս հավաքի սեփականատեր: FROM կետը սահմանում է այն ուղին, որտեղ գտնվում է բեռնման հավաքը:
PERMISSION_SET կետով CREATE ASSEMBLY հայտարարության շատ կարևոր կետ է և պետք է միշտ ներառվի: Այն սահմանում է հավաքման ծածկագրին տրված մուտքի իրավունքի ամբողջությունը: Իրավունքների ԱՆՎՏԱՆԳ հավաքածուն ամենասահմանափակողն է: Ասամբլեայի կոդը, որն ունի այս իրավունքները, չի կարող մուտք գործել համակարգի արտաքին ռեսուրսներ, ինչպիսիք են ֆայլերը: EXTERNAL_ACCESS արտոնությունների հավաքածուն թույլ է տալիս հավաքման կոդը մուտք գործել որոշակի արտաքին համակարգի ռեսուրսներ, մինչդեռ UNSAFE արտոնությունների հավաքածուն տրամադրում է անսահմանափակ մուտք դեպի ռեսուրսներ, ինչպես տվյալների բազայի համակարգի ներսում, այնպես էլ դրսում:
Օգտագործողը պետք է կարողանա կատարել CREATE ASSEMBLY հայտարարությունը հավաքման կոդի մասին տեղեկատվությունը պահպանելու համար: Ժողովը պատկանում է օգտագործողին (կամ դերին), ով կատարում է այս հայտարարությունը: Դուք կարող եք հավաքի սեփականատեր դարձնել մեկ այլ օգտվող՝ օգտագործելով CREATE SCHEMA հայտարարության AUTHORIZATION կետը:
Տվյալների բազայի շարժիչը նաև աջակցում է ALTER ASSEMBLY և DROP ASSEMBLY հայտարարությունները: ALTER ASSEMBLY հայտարարությունըօգտագործվում է ժողովը վերջին տարբերակին թարմացնելու համար: Այս հայտարարությունը նաև ավելացնում կամ հեռացնում է համապատասխան հավաքի հետ կապված ֆայլերը: ԿԱՌՆԵԼ ՀԱՎԱՔՈՒՄԸ Հայտարարությունհեռացնում է նշված ժողովը և բոլոր հարակից ֆայլերը ընթացիկ տվյալների բազայից:
Ստորև բերված օրինակը ցույց է տալիս, թե ինչպես կարելի է ստեղծել պահպանված ընթացակարգ՝ հիմնվելով կառավարվող կոդի վրա, որն ավելի վաղ ներդրել եք.
ՕԳՏԱԳՈՐԾԵԼ SampleDb; GO CREATE PROCEDURE CountEmployees AS EXTERNAL անուն CLRSstoredProcedures.StoredProcedures.CountEmployees
Օրինակում CREATE PROCEDURE հայտարարությունը տարբերվում է նախորդ օրինակների նույն հայտարարությունից նրանով, որ այն պարունակում է. EXTERNAL NAME պարամետր... Այս պարամետրը ցույց է տալիս, որ կոդը ստեղծվում է CLR-ի կողմից: Այս նախադասության անունը բաղկացած է երեք մասից.
assembly_name.class_name.method_name
assembly_name Նշում է ժողովի անվանումը:
class_name - ցույց է տալիս ընդհանուր դասի անվանումը;
մեթոդ_անուն - ընտրովի, նշում է մեթոդի անվանումը, որը նշված է դասի ներսում:
CountEmployees ընթացակարգի կատարումը ներկայացված է ստորև բերված օրինակում.
ՕԳՏԱԳՈՐԾԵԼ SampleDb; ՀԱՅՏԱՐԱՐԵԼ @count INT EXECUTE @count = CountEmployees PRINT @count - Վերադարձնում է 7
PRINT հայտարարությունը վերադարձնում է աշխատողների աղյուսակի տողերի ընթացիկ թիվը:
Microsoft SQL Server-ում իր սեփական ալգորիթմներն իրականացնելու և ավտոմատացնելու համար ( հաշվարկներ), կարող եք օգտագործել պահված ընթացակարգերը, ուստի այսօր մենք կխոսենք, թե ինչպես են դրանք ստեղծվում, փոփոխվում և ջնջվում:
Բայց նախ մի փոքր տեսություն, որպեսզի հասկանաք, թե ինչ են պահված ընթացակարգերը և ինչի համար են դրանք T-SQL-ում:
Նշում! Սկսնակ ծրագրավորողների համար խորհուրդ եմ տալիս հետևյալ օգտակար նյութերը T-SQL թեմայի վերաբերյալ.
- T-SQL լեզվի ավելի մանրամասն ուսումնասիրության համար խորհուրդ եմ տալիս կարդալ նաև գիրքը՝ The T-SQL Programmer's Way: Ձեռնարկ Transact-SQL լեզվի համար:
Որոնք են պահված ընթացակարգերը T-SQL-ում:
Պահպանված ընթացակարգերՏվյալների բազայի օբյեկտներ են, որոնք պարունակում են ալգորիթմ SQL հայտարարությունների մի շարքի տեսքով: Այլ կերպ ասած, մենք կարող ենք ասել, որ պահպանված ընթացակարգերը ծրագրեր են տվյալների բազայում: Պահպանված ընթացակարգերն օգտագործվում են սերվերում բազմակի օգտագործման ծածկագիրը պահպանելու համար, օրինակ՝ դուք գրել եք ալգորիթմ, հաջորդական հաշվարկ կամ բազմաքայլ SQL հայտարարություն, և որպեսզի ամեն անգամ չկատարեք այս ալգորիթմում ներառված բոլոր հրահանգները, կարող եք այն նախագծել։ որպես պահպանված ընթացակարգ: Միևնույն ժամանակ, երբ դուք ստեղծում եք SQL պրոցեդուրա, սերվերը հավաքում է կոդը, և այնուհետև, ամեն անգամ, երբ դուք գործարկում եք այս SQL պրոցեդուրան, սերվերն այլևս այն նորից չի կոմպիլի։
SQL Server-ում պահպանված պրոցեդուրան գործարկելու համար անհրաժեշտ է դրա անունից առաջ գրել EXECUTE հրամանը, կամ հնարավոր է նաև կրճատված EXEC հրամանը։ Պահված ընթացակարգը SELECT հայտարարության մեջ կանչելը, օրինակ, որպես ֆունկցիա այլևս չի աշխատի, այսինքն. ընթացակարգերը կատարվում են առանձին:
Պահված ընթացակարգերում, ի տարբերություն գործառույթների, դուք արդեն կարող եք կատարել տվյալների փոփոխման գործողություններ, ինչպիսիք են՝ UNSERT, UPDATE, DELETE: Նաև ընթացակարգերում կարող եք օգտագործել գրեթե ցանկացած տեսակի SQL հայտարարություններ, օրինակ՝ CREATE TABLE աղյուսակներ ստեղծելու կամ EXECUTE, այսինքն. կանչելով այլ ընթացակարգեր: Բացառություն են կազմում հրահանգների մի քանի տեսակներ, ինչպիսիք են՝ ֆունկցիաների, դիտումների, գործարկիչների ստեղծումը կամ փոփոխումը, սխեմաների ստեղծումը և մի քանի այլ նմանատիպ հրահանգներ, օրինակ, տվյալների բազայի միացման համատեքստը (USE) նույնպես հնարավոր չէ փոխել պահված ընթացակարգում:
Պահված ընթացակարգը կարող է ունենալ մուտքային և ելքային պարամետրեր, այն կարող է վերադարձնել աղյուսակային տվյալներ, այն չի կարող վերադարձնել ոչինչ, միայն կատարել հրահանգները, որոնք պարունակվում են դրանում:
Պահպանված ընթացակարգերը շատ օգտակար են, նրանք օգնում են մեզ ավտոմատացնել կամ պարզեցնել բազմաթիվ գործողություններ, օրինակ՝ դուք անընդհատ պետք է գեներացնեք տարբեր բարդ վերլուծական հաշվետվություններ՝ օգտագործելով առանցքային աղյուսակներ, այսինքն. PIVOT օպերատորը: Այս օպերատորի հետ հարցումներ կազմելն ավելի հեշտ դարձնելու համար ( ինչպես գիտեք, PIVOT-ի շարահյուսությունը բավականին բարդ է), Դուք կարող եք գրել ընթացակարգ, որը դինամիկ կերպով կստեղծի ամփոփ հաշվետվություններ ձեզ համար, օրինակ՝ «Dynamic PIVOT in T-SQL» նյութում ներկայացված է օրինակ, թե ինչպես կարելի է այս հատկանիշը իրականացնել պահված ընթացակարգի տեսքով։
Microsoft SQL Server-ում պահված ընթացակարգերի հետ աշխատելու օրինակներ
Նախնական տվյալներ օրինակների համար
Ստորև բերված բոլոր օրինակները կկատարվեն Microsoft SQL Server 2016 Express-ում: Որպեսզի ցույց տանք, թե ինչպես են պահպանված ընթացակարգերը աշխատում իրական տվյալների հետ, մեզ անհրաժեշտ են այս տվյալները, եկեք ստեղծենք դրանք: Օրինակ, ստեղծենք թեստային աղյուսակ և դրան ավելացնենք մի քանի գրառում, ասենք, որ այն ապրանքների ցանկն է՝ իրենց գներով։
Աղյուսակ ստեղծելու հայտարարություն CREATE TABLE TestTable (INT IDENTITY (1,1) NOT NULL, INT NOT NULL, VARCHAR (100) NOT NULL, MONEY NULL) GO - Տվյալներ ավելացնելու հրահանգ INSERT INTO TestTable (CategoryId, ProductName, Price) (1 , «Մկնիկ», 100), (1, «Ստեղնաշար», 200), (2, «Հեռախոս», 400) GO --Ընտրել հարցումը SELECT * FROM TestTable
Տվյալները կան, այժմ եկեք անցնենք պահպանված ընթացակարգերի ստեղծմանը:
T-SQL պահված ընթացակարգի ստեղծում - CREATE PROCEDURE հայտարարություն
Պահպանված ընթացակարգերը ստեղծվում են հայտարարության միջոցով ՍՏԵՂԾԵԼ ԿԱՐԳԸ, այս հրահանգից հետո դուք պետք է գրեք ձեր պրոցեդուրի անվանումը, ապա անհրաժեշտության դեպքում փակագծերում սահմանեք մուտքային և ելքային պարամետրերը։ Դրանից հետո գրում եք AS հիմնաբառը և բացում եք հրահանգների բլոկը BEGIN բանալի բառով, փակում եք այս բլոկը ՎԵՐՋ բառով։ Այս բլոկի ներսում դուք գրում եք բոլոր հրահանգները, որոնք իրականացնում են ձեր ալգորիթմը կամ ինչ-որ հաջորդական հաշվարկ, այլ կերպ ասած՝ ծրագրավորում եք T-SQL-ով։
Օրինակ, եկեք գրենք պահպանված ընթացակարգ, որը կավելացնի նոր գրառում, այսինքն. նոր արտադրանք մեր փորձարկման աղյուսակում: Դա անելու համար մենք կսահմանենք մուտքային երեք պարամետր՝ @CategoryId - ապրանքի կատեգորիայի նույնացուցիչ, @ProductName - ապրանքի անվանումը և @Price - ապրանքի գին, այս պարամետրը կլինի ընտրովի, այսինքն. այն հնարավոր չի լինի փոխանցել ընթացակարգին ( օրինակ՝ գինը դեռ չգիտենք), դրա համար իր սահմանման մեջ մենք կսահմանենք լռելյայն արժեքը: Այս պարամետրերը գտնվում են ընթացակարգի մարմնում, այսինքն. BEGIN ... END բլոկում դուք կարող եք օգտագործել նույն կերպ, ինչպես սովորական փոփոխականները ( Ինչպես գիտեք, փոփոխականները նշվում են @-ով). Եթե Ձեզ անհրաժեշտ է նշել ելքային պարամետրերը, ապա պարամետրի անվանումից հետո նշեք OUTPUT հիմնաբառը ( կամ կրճատ՝ OUT).
BEGIN… END բլոկում մենք կգրենք հայտարարություն տվյալների ավելացման համար, ինչպես նաև ընթացակարգի վերջում SELECT հայտարարություն, որպեսզի պահպանված ընթացակարգը վերադարձնի աղյուսակային տվյալներ նշված կատեգորիայի ապրանքների մասին՝ հաշվի առնելով նորը։ , պարզապես ավելացված ապրանք: Նաև այս պահպանված ընթացակարգում ես ավելացրեցի մուտքագրման պարամետրի մշակումը, մասնավորապես՝ տեքստի տողի սկզբում և վերջում ավելորդ բացատների հեռացումը՝ խուսափելու իրավիճակներից, երբ մի քանի բացատներ պատահաբար տեղադրվել են:
Ահա այս ընթացակարգի կոդը ( Ես էլ եմ դա մեկնաբանել).
Ստեղծեք ընթացակարգ CREATE PROCEDURE TestProcedure (-- Մուտքագրեք պարամետրեր @CategoryId INT, @ProductName VARCHAR (100), @Price MONEY = 0) ԻՆՉՊԵՍ ՍԿԶԲՈՒՄ -- Հրահանգներ, որոնք իրականացնում են ձեր ալգորիթմը -- Կառավարել մուտքային պարամետրերը -- Ջնջել լրացուցիչ բացերը սկզբում և տեքստային տողի վերջում SET @ProductName = LTRIM (RTRIM (@ProductName)); --Ավելացրեք նոր INSERT INTO TestTable (CategoryId, ProductName, Price) VALUES (@CategoryId, @ProductName, @Price) գրառում - Վերադարձեք տվյալները SELECT * FROM TestTable WHERE CategoryId = @CategoryId END GO
T-SQL պահված ընթացակարգի գործարկում - EXECUTE հրաման
Դուք կարող եք սկսել պահված ընթացակարգը, ինչպես ես արդեն նշել եմ, օգտագործելով EXECUTE կամ EXEC հրամանը: Մուտքային պարամետրերը փոխանցվում են ընթացակարգերին՝ դրանք պարզապես թվարկելով և ընթացակարգի անվանումից հետո նշելով համապատասխան արժեքները ( ելքային պարամետրերի համար անհրաժեշտ է նաև նշել OUTPUT հրամանը). Այնուամենայնիվ, պարամետրերի անվանումը կարող է բաց թողնել, բայց այս դեպքում անհրաժեշտ է հետևել արժեքները նշելու հաջորդականությանը, այսինքն. նշեք արժեքները այն հերթականությամբ, որով սահմանվում են մուտքային պարամետրերը ( սա վերաբերում է նաև ելքային պարամետրերին).
Լռելյայն արժեքներ ունեցող պարամետրերը պետք չէ նշել, դրանք այսպես կոչված կամընտիր պարամետրեր են:
Ահա պահպանված ընթացակարգերը գործարկելու մի քանի տարբեր, բայց համարժեք եղանակներ, մասնավորապես մեր փորձարկման ընթացակարգը:
1. Զանգահարեք ընթացակարգը՝ առանց գինը նշելու EXECUTE TestProcedure @CategoryId = 1, @ProductName = «Թեստային արտադրանք 1» --2: Մենք պրոցեդուրան անվանում ենք գնի ցուցումով EXEC TestProcedure @CategoryId = 1, @ProductName = «Թեստային արտադրանք 2», @Price = 300 --3: Մենք կոչում ենք ընթացակարգը՝ առանց պարամետրերի անվանումը նշելու EXEC TestProcedure 1, «Test Product 3», 400
Պահված ընթացակարգի փոփոխություն T-SQL - ALTER PROCEDURE քաղվածքի
Դուք կարող եք փոփոխություններ կատարել ընթացակարգի ալգորիթմում՝ օգտագործելով հրահանգները ՓՈՓՈԽԱԿԱՆ ԿԱՐԳԸ... Այսինքն՝ գոյություն ունեցող պրոցեդուրան փոխելու համար պարզապես պետք է CREATE PROCEDURE-ի փոխարեն գրել ALTER PROCEDURE, իսկ մնացած ամեն ինչ ըստ անհրաժեշտության փոխել։
Ենթադրենք, որ մենք պետք է փոփոխություններ կատարենք մեր փորձարկման ընթացակարգում, ասենք @Price պարամետրը, այսինքն. գինը, մենք դա պարտադիր կդարձնենք, դրա համար մենք կհեռացնենք լռելյայն արժեքը, ինչպես նաև պատկերացնենք, որ մեզ այլևս պետք չէ ստանալ ստացված տվյալների բազան, դրա համար մենք պարզապես կհեռացնենք SELECT հայտարարությունը պահպանված ընթացակարգից:
Մենք փոխում ենք ALTER PROCEDURE TestProcedure-ը (--մուտքային պարամետրերը @CategoryId INT, @ProductName VARCHAR (100), @Price MONEY) ԻՆՉՊԵՍ ՍԿԶԲՈՒՄ - Հրահանգներ, որոնք իրականացնում են ձեր ալգորիթմը. տեքստային տողերի վերջը SET @ProductName = LTRIM (RTRIM (@ProductName)); -- Ավելացնել նոր INSERT INTO TestTable (CategoryId, ProductName, Price) VALUES (@CategoryId, @ProductName, @Price) END GO գրառում
T-SQL պահված ընթացակարգի բացթողում - DROP PROCEDURE հայտարարությունը
Անհրաժեշտության դեպքում կարող եք ջնջել պահված ընթացակարգը, դա արվում է հրահանգի միջոցով ԸՆԹԱՑԵԼՈՒ ԿԱՐԳԸ.
Օրինակ՝ ջնջենք մեր ստեղծած փորձարկման ընթացակարգը։
ԸՆԹԱՑԵԼ ԿԱՐԳԸ TestProcedure
Պահված ընթացակարգերը ջնջելիս հիշեք, որ եթե պրոցեդուրան հղում է արվում այլ պրոցեդուրաներով կամ SQL հայտարարություններով, այն ջնջելուց հետո դրանք կձախողվեն, քանի որ այն ընթացակարգը, որին նրանք ակնարկում են, այլևս գոյություն չունի:
Ես ամեն ինչ ունեմ, հուսով եմ, որ նյութը մինչ այժմ հետաքրքիր և օգտակար էր ձեզ համար:
