Պահպանված ընթացակարգերն են. Պահված ընթացակարգերի ստեղծում microsoft sql սերվերում: Ավտոմատ վերակազմավորում
Պահպանված ընթացակարգեր
Այս գլխի թեման ամենահզոր գործիքներից մեկն է, որն առաջարկվում է InterBase տվյալների բազայի հավելվածների մշակողներին բիզնես տրամաբանության իրականացման համար: Պահպանված ընթացակարգերը (անգլերեն, stoied procedures) թույլ են տալիս իրականացնել կիրառական տրամաբանության զգալի մասը տվյալների բազայի մակարդակում և այդպիսով մեծացնել ամբողջ հավելվածի կատարումը, կենտրոնացնել տվյալների մշակումը և նվազեցնել առաջադրանքները կատարելու համար անհրաժեշտ կոդի քանակը բարդ կիրառությունտվյալների բազաները ամբողջական չեն առանց պահպանված ընթացակարգերի օգտագործման:
Ի հավելումն պահեստավորված ընթացակարգերի օգտագործման այս հայտնի առավելությունների, որոնք սովորական են հարաբերական տվյալների բազայի համակարգերի համար, InterBase պահպանված ընթացակարգերը կարող են խաղալ գրեթե ամբողջական տվյալների հավաքածուների դեր, ինչը թույլ է տալիս օգտագործել իրենց վերադարձած արդյունքները սովորական SQL հարցումներում:
Հաճախ սկսնակ ծրագրավորողները պահված ընթացակարգերը համարում են ընդամենը հատուկ SQL հարցումների մի շարք, որոնք ինչ-որ բան են անում տվյալների բազայի ներսում, և կարծիք կա, որ պահպանված ընթացակարգերի հետ աշխատելը շատ ավելի դժվար է, քան նույն ֆունկցիոնալությունը հաճախորդի հավելվածում, լեզվով: բարձր մակարդակ
Այսպիսով, կոնկրետ որո՞նք են պահպանված ընթացակարգերը InterBase-ում:
Պահպանված ընթացակարգը (SP) տվյալների բազայի մետատվյալների մի մասն է, որը հատուկ լեզվով գրված InterBase-ի ներքին ներկայացման մեջ կազմված ենթածրագր է, որի կոմպիլյատորը ներկառուցված է InteiBase սերվերի միջուկում:
Պահված ընթացակարգը կարող է կանչվել հաճախորդի հավելվածներից, գործարկիչներից և այլ պահպանված ընթացակարգերից: Պահպանված ընթացակարգը կատարվում է սերվերի գործընթացի ներսում և կարող է շահարկել տվյալների բազայի տվյալները, ինչպես նաև վերադարձնել դրա կատարման արդյունքները այն զանգահարած հաճախորդին (այսինքն՝ գործարկիչ, HP, հավելված)
HP-ին բնորոշ հզոր հնարավորությունների հիմքում ընկած է ընթացակարգային ծրագրավորման լեզուն, որը ներառում է և՛ փոփոխված սովորական SQL հայտարարություններ, ինչպիսիք են՝ INSERT, UPDATE և SELECT, ինչպես նաև ճյուղավորող և օղակաձև գործիքներ (IF, WHILE), ինչպես նաև սխալների հետ աշխատելու գործիքներ: և բացառիկ իրավիճակներ Պահված պրոցեդուրաների լեզուն թույլ է տալիս իրականացնել տվյալների հետ աշխատելու բարդ ալգորիթմներ, և հարաբերական տվյալների հետ աշխատելու վրա կենտրոնանալու պատճառով SP-ները շատ ավելի կոմպակտ են, քան ավանդական լեզուների նմանատիպ ընթացակարգերը:
Հարկ է նշել, որ նույն ծրագրավորման լեզուն օգտագործվում է գործարկիչների համար, բացառությամբ մի շարք առանձնահատկությունների և սահմանափակումների: Գործարկիչներում օգտագործվող լեզվի ենթաբազմության և HP-ի լեզվի միջև եղած տարբերությունները մանրամասնորեն քննարկվում են Triggers գլխում (մաս 1):
Պարզ պահվող ընթացակարգի օրինակ
Ժամանակն է ստեղծել առաջին պահպանված պրոցեդուրան և օգտագործել այն որպես օրինակ՝ ուսումնասիրելու պահված պրոցեդուրաների ստեղծման գործընթացը: Բայց նախ պետք է մի քանի խոսք ասել, թե ինչպես աշխատել պահված պրոցեդուրաների հետ: Փաստն այն է, որ HP-ն իր հայտնիությունը որպես անհասկանալի և անհարմար գործիք պարտական է պահեստավորված ընթացակարգերի մշակման և վրիպազերծման չափազանց վատ ստանդարտ գործիքներին: InterBase փաստաթղթերում խորհուրդ է տրվում ստեղծել պրոցեդուրաներ՝ օգտագործելով CP-ի տեքստը պարունակող SQL script ֆայլեր, որոնք սնվում են isql թարգմանիչին և այդպիսով ստեղծել և փոփոխել CP-ն: Եթե սխալ առաջանա, isql-ը կցուցադրի հաղորդագրություն, որի վրա SQL script ֆայլի տողում սխալ է տեղի ունեցել: Ուղղեք սխալը և նորից կրկնեք ամեն ինչ: Բառի ժամանակակից իմաստով վրիպազերծումը, այսինքն՝ կատարման հետագծումը, փոփոխականների միջանկյալ արժեքները դիտելու ունակությամբ, ընդհանրապես չի քննարկվում: Ակնհայտ է, որ այս մոտեցումը չի նպաստում մշակողի աչքում պահվող ընթացակարգերի գրավչության աճին:
Այնուամենայնիվ, ի լրումն HP-ի զարգացման ստանդարտ մինիմալիստական մոտեցման<_\ществ\ют также
инструменты сторонних разработчиков, которые делают работу с хранимыми
процедурами весьма удобной Большинство универсальных продуктов для работы с
InterBase, перечисленных в приложении "Инструменты администратора и разработчика
InterBase", предоставляют удобный инструментарий для работы с ХП. Мы рекомендуем
обязательно воспользоваться одним из этих инструментов для работы с хранимыми
процедурами и изложение материала будем вести в предположении, что у вас имеется
удобный GUI-инструмент, избавляющий от написания традиционных SQL-скриптов
Պահպանված ընթացակարգերի շարահյուսությունը նկարագրված է հետևյալ կերպ.
ՍՏԵՂԾԵԼ ԸՆԹԱՑՔԻ անվանումը
[ (param datatype [, param datatype ...]) ]
)]
ԱՍ
< procedure_body> =
[
<
block>
< vanable_declaration_list>
=
ՀԱՅՏԱՐԱՐԵԼ ՓՈՓՈԽԱԿԱՆ var տվյալների տեսակը;
ՍԿՍԵԼ
< compound_statement>
[< compound_statement> ...]
ՎԵՐՋ
< compound_statement> =
(
Այն բավականին ծավալուն է թվում և կարող է նույնիսկ ծանրաբեռնված լինել, բայց իրականում ամեն ինչ շատ պարզ է: Որպեսզի աստիճանաբար տիրապետենք շարահյուսությանը, եկեք նայենք աստիճանաբար դառնալով ավելի բարդ օրինակներ:
Այսպիսով, ահա մի շատ պարզ պահված ընթացակարգի օրինակ, որը վերցնում է երկու թվեր որպես մուտքագրում, գումարում դրանք և վերադարձնում արդյունքը.
ՍՏԵՂԾԵԼ ԿԱՐԳԸ SP_Add(first_arg ԿՐԿՆԱԿԻ ՃՇՇՏ,
second_arg ԿՐԿՆԱԿԻ ՃՇՇՏ)
ՎԵՐԱԴԱՐՁ (Արդյունքը ԿՐԿՆԱԿԻ ՃՇՇՏ)
ԱՍ
ՍԿՍԵԼ
Արդյունք= first_arg+second_arg;
ԿԱՍԵՑԵԼ;
ՎԵՐՋ
Ինչպես տեսնում եք, ամեն ինչ պարզ է. CREATE PROCEDURE հրամանից հետո նշվում է նոր ստեղծված ընթացակարգի անունը (որը պետք է եզակի լինի տվյալների բազայում)՝ այս դեպքում՝ SP_Add, ապա XP մուտքագրման պարամետրերը՝ first_arg և second_arg. նշված են փակագծերում՝ բաժանված ստորակետերով՝ նշելով դրանց տեսակները:
Մուտքային պարամետրերի ցանկը CREATE PROCEDURE հայտարարության կամընտիր մաս է. կան դեպքեր, երբ պրոցեդուրան իր աշխատանքի համար բոլոր տվյալները ստանում է ընթացակարգի մարմնի ներսում աղյուսակների հարցումների միջոցով:
Պահպանված ընթացակարգերը օգտագործում են ցանկացած սկալային տվյալների տեսակներ InteiBase Չի օգտագործվում զանգվածներ և օգտագործողի կողմից սահմանված տեսակներ՝ տիրույթներ
Հաջորդը գալիս է հիմնաբառՎԵՐԱԴԱՐՁ, որից հետո վերադարձի պարամետրերը թվարկվում են փակագծերում՝ նշելով դրանց տեսակները՝ այս դեպքում միայն մեկը՝ Արդյունք։
Եթե ընթացակարգը չպետք է վերադարձնի պարամետրերը, ապա RETURNS բառը և վերադարձված պարամետրերի ցանկը բացակայում են:
RETURNSQ-ին հաջորդում է AS հիմնաբառը: Մինչև AS հիմնաբառը գնում է կոչում,և դրանից հետո - տեխոընթացակարգերը.
Պահպանված ընթացակարգի բովանդակությունը նրա ներքին (տեղական) փոփոխականների հայտարարագրերի ցանկն է (եթե այդպիսիք կան, ավելի մանրամասն քննարկվում է ստորև), բաժանված կետ-ստորակետով (;) և ՍԿԻԶԲ ՎԵՐՋ հայտարարության փակագծերում կցված հայտարարությունների բլոկն: Այս դեպքում CP-ի մարմինը շատ պարզ է. մենք խնդրում ենք ավելացնել երկու մուտքային արգումենտ և դրանց արդյունքը վերագրել ելքին, այնուհետև կանչել SUSPEND հրամանը: Մի փոքր ուշ մենք կբացատրենք այս հրամանի գործողության էությունը, բայց առայժմ միայն կնշենք, որ անհրաժեշտ է վերադարձի պարամետրեր փոխանցել այնտեղ, որտեղից կանչվել է պահված ընթացակարգը:
Անջատիչներ պահեստավորված պրոցեդուրաներում
Նկատի ունեցեք, որ ընթացակարգի ներսում հայտարարությունն ավարտվում է ստորակետով (;): Ինչպես գիտեք, ստորակետը SQL-ի ստանդարտ հրամանների բաժանիչն է. դա ազդանշան է SQL թարգմանչին, որ հրամանի տեքստն ամբողջությամբ մուտքագրվել է, և այն պետք է մշակվի: Արդյո՞ք չի ստացվի, որ SP-ի մեջտեղում ստորակետ գտնելով, SQL թարգմանիչը կհամարի, որ հրամանն ամբողջությամբ մուտքագրված է և կփորձի կատարել պահված պրոցեդուրի մի մասը: Այս ենթադրությունն անիմաստ չէ։ Իրոք, եթե դուք ստեղծեք ֆայլ, որտեղ գրեք վերը նշված օրինակը, ավելացնեք տվյալների բազայի միացման հրամանը և փորձեք կատարել այս SQL սցենարը, օգտագործելով isql թարգմանիչը, ապա կվերադարձվի սխալ՝ կապված անսպասելի, ըստ թարգմանչի, ավարտի հետ։ պահված ընթացակարգ ստեղծելու հրամանը: Եթե դուք ստեղծում եք պահպանված պրոցեդուրաներ՝ օգտագործելով SQL script ֆայլեր, առանց օգտագործելու InterBase մշակողի մասնագիտացված գործիքներ, ապա դուք պետք է փոխեք script հրամանի բաժանարարը մեկ այլ նիշով, քան ստորակետը, տեքստից հետո, երբ HP-ն վերականգնում է այն: SQL նախադասությունների բաժանարարը փոխելու isql հրամանը հետևյալն է.
ՍԱՀՄԱՆԵԼ ԺԱՄԿԵՏ
Պահված ընթացակարգ ստեղծելու բնորոշ դեպքի համար այն ունի հետևյալ տեսքը.
Սահմանել ԺԱՄԿԵՏԸ ^;
ՍՏԵՂԾԵԼ ԿԱՐԳԸ some_procedure
... . .
ՎԵՐՋ
^
Սահմանել ԺԱՄԿԵՏԸ ;^
Պահված ընթացակարգի կանչում
Բայց վերադառնանք մեր պահպանված ընթացակարգին: Այժմ, երբ այն ստեղծվել է, մենք պետք է ինչ-որ կերպ կանչենք այն, փոխանցենք պարամետրերը և ստանանք վերադարձված արդյունքները: Սա շատ հեշտ է անել. պարզապես գրեք SQL հարցում հետևյալ ձևով.
ԸՆՏՐԵԼ*
FROM Sp_add (181.35, 23.09)
Այս հարցումը մեզ կվերադարձնի մեկ տող, որը պարունակում է միայն մեկ Արդյունք դաշտ, որը կպարունակի 181.35 և 23.09 թվերի գումարը, այսինքն՝ 204.44:
Այսպիսով, մեր ընթացակարգը կարող է օգտագործվել սովորական SQL հարցումներում, որոնք կատարվում են ինչպես հաճախորդի ծրագրերում, այնպես էլ այլ SP-ներում կամ գործարկիչներում: Մեր ընթացակարգի այս օգտագործումը հնարավոր է դարձել SUSPEND հրամանի օգտագործմամբ՝ պահպանված ընթացակարգի վերջում:
Փաստն այն է, որ InterBase-ում (և նրա բոլոր կլոններում) գոյություն ունեն երկու տեսակի պահվող պրոցեդուրաներ՝ ընտրելի և գործարկվող ընթացակարգեր: Այս երկու տեսակի CP-ների գործողության տարբերությունն այն է, որ ընտրության ընթացակարգերը սովորաբար վերադարձնում են ելքային պարամետրերի բազմաթիվ հավաքածուներ՝ խմբավորված տող առ տող, որոնք նման են տվյալների հավաքածուի, և գործարկվող ընթացակարգերը կարող են կամ ընդհանրապես չվերադարձնել պարամետրերը, կամ վերադարձնել միայն մեկը: Returns-ում թվարկված ելքային պարամետրերի մի շարք, որտեղ պարամետրերի մեկ տող: Ընտրել ընթացակարգերը կանչվում են SELECT հարցումներում, իսկ գործարկվող ընթացակարգերը՝ EXECUTE PROCEDURE հրամանով:
Պահված պրոցեդուրաների երկու տեսակներն էլ ունեն ստեղծման նույն շարահյուսությունը և պաշտոնապես նույնն են, ուստի ցանկացած գործարկվող ընթացակարգ կարելի է կանչել SELECT հարցումով և ցանկացած ընտրված ընթացակարգ կարելի է կանչել՝ օգտագործելով EXECUTE PROCEDURE: Հարցն այն է, թե երբ իրեն կպահի HP-ն տարբեր տեսակներզանգահարել. Այլ կերպ ասած, տարբերությունը կայանում է որոշակի տեսակի զանգի ընթացակարգի նախագծման մեջ: Այսինքն՝ SELECT պրոցեդուրան հատուկ ստեղծվում է SELECT հարցումից կանչվելու համար, իսկ գործարկվող պրոցեդուրան հատուկ ստեղծվում է EXECUTE PROCEDURE-ի միջոցով կանչվելու համար: Եկեք նայենք, թե ինչ տարբերություններ կան HP-ի այս երկու տեսակների նախագծման մեջ:
Որպեսզի հասկանաք, թե ինչպես է աշխատում ընտրության ընթացակարգը, պետք է մի փոքր խորանալ տեսության մեջ: Եկեք պատկերացնենք նորմալ SQL հարցում, ինչպիսին է SELECT ID, NAME FROM Table_example: Դրա կատարման արդյունքում մենք ելքում ստանում ենք աղյուսակ, որը բաղկացած է երկու սյունակից (ID և NAME) և որոշակի թվով տողեր (հավասար է Table_example աղյուսակի տողերի քանակին): Այս հարցման արդյունքում վերադարձված աղյուսակը կոչվում է նաև SQL տվյալների բազա: Եկեք մտածենք, թե ինչպես է ձևավորվում տվյալների բազան այս հարցման կատարման ժամանակ: Սերվերը, ստանալով հարցումը, որոշում է, թե որ աղյուսակներին է այն պատկանում, այնուհետև պարզում է, թե որ ենթաբազմությանը: Այս աղյուսակների գրառումները պետք է ներառվեն հարցման արդյունքում: Այնուհետև սերվերը կարդում է հարցման արդյունքները բավարարող յուրաքանչյուր գրառում, դրանից ընտրում է անհրաժեշտ դաշտերը (մեր դեպքում դրանք ID և NAME են) և ուղարկում հաճախորդին։ Այնուհետև գործընթացը կրկնվում է և այդպես շարունակ յուրաքանչյուր ընտրված ձայնագրության համար:
Այս ամբողջ շեղումը անհրաժեշտ է, որպեսզի հարգելի ընթերցողը հասկանա, որ SQL տվյալների բոլոր հավաքածուները ձևավորվում են տող առ տող, ներառյալ պահված ընթացակարգերում: Իսկ ընտրված պրոցեդուրաների և գործարկվող պրոցեդուրաների հիմնական տարբերությունն այն է, որ առաջինները նախատեսված են մի քանի տող վերադարձնելու համար, մինչդեռ երկրորդները նախատեսված են միայն մեկը վերադարձնելու համար: Հետևաբար, դրանք կիրառվում են այլ կերպ. ընտրության ընթացակարգը կանչվում է SELECT հրամանով, որը «պահանջում է» ընթացակարգից վերադարձնել բոլոր գրառումները, որոնք այն կարող է վերադարձնել: Գործարկվող պրոցեդուրան կոչվում է՝ օգտագործելով EXECUTE PROCEDURE, որը «հանում է» միայն մեկ տող CP-ից, իսկ մնացածն անտեսում է (նույնիսկ եթե դրանք կան):
Դիտարկենք ընտրված ընթացակարգի օրինակ՝ այն ավելի պարզ դարձնելու համար: Ներելու համար եկեք ստեղծենք պահպանված պրոցեդուրա, որն աշխատում է ճիշտ այնպես, ինչպես SELECT ID, NAME FROM Table_Example հարցումը, այսինքն՝ այն պարզապես ընտրում է ID և NAME դաշտերը ամբողջ աղյուսակից: Ահա այդ օրինակը.
ՍՏԵՂԾԵԼ ԸՆԹԱՑՔԸ Simple_Select_SP
ՎԵՐԱԴԱՐՁՈՒՄՆԵՐ (
procID ԱՄԲՈՂՋ,
procNAME VARCHAR(80))
ԱՍ
ՍԿՍԵԼ
ՀԱՄԱՐ
SELECT ID, NAME աղյուսակից_օրինակ
INTO:procID, :procNAME
ԱՐԵԼ
ՍԿՍԵԼ
ԿԱՍԵՑԵԼ;
ՎԵՐՋ
ՎԵՐՋ
Եկեք նայենք այս ընթացակարգի գործողություններին, որը կոչվում է Simple_Select_SP: Ինչպես տեսնում եք, այն չունի մուտքային պարամետրեր և ունի երկու ելքային պարամետր՝ ID և NAME: Ամենահետաքրքիրը, իհարկե, ընթացակարգի մարմնում է: FOR SELECT կոնստրուկցիան օգտագործվում է այստեղ.
ՀԱՄԱՐ
SELECT ID, NAME աղյուսակից_օրինակ
INTO:procID, :procNAME
ԱՐԵԼ
ՍԿՍԵԼ
/* անել ինչ-որ բան procID և procName փոփոխականներով*/
ՎԵՐՋ
Կոդի այս հատվածը նշանակում է հետևյալը. Table_example աղյուսակից ընտրված յուրաքանչյուր տողի համար ընտրված արժեքները դրեք procID և procName փոփոխականներում, այնուհետև կատարեք որոշակի գործողություններ այս փոփոխականների վրա:
Դուք կարող եք զարմացած դեմք դնել և հարցնել. «Փոփոխականներ, ի՞նչ այլ փոփոխականներ 9»: Այս գլխի մի տեսակ զարմանք է, որ մենք կարող ենք փոփոխականներ օգտագործել պահված ընթացակարգերում: XP-ում դուք կարող եք հայտարարել և՛ ձեր սեփական տեղական փոփոխականները, և՛ որպես փոփոխականներ օգտագործել մուտքային և ելքային պարամետրերը:
Պահված ընթացակարգում տեղական փոփոխական հայտարարելու համար դուք պետք է տեղադրեք դրա հայտարարությունը AS հիմնաբառից հետո և առաջին BEGIN բառից առաջ: Տեղական փոփոխականի հայտարարագիրը հետևյալ տեսքն ունի.
ՀԱՅՏԱՐԱՐԵԼ ՓՈՓՈԽԱԿԱՆ
Օրինակ, Mylnt ամբողջ տեղային փոփոխականը հայտարարելու համար դուք պետք է տեղադրեք հետևյալ հայտարարությունը AS-ի և BEGIN-ի միջև:
ՀԱՅՏԱՐԱՐԵԼ ՓՈՓՈԽԱԿԱՆ MyInt INTEGER;
Մեր օրինակի փոփոխականները սկսվում են երկու կետով: Դա արվում է, քանի որ դրանք հասանելի են FOR SELECT SQL հրամանի ներսում, ուստի SELECT-ում օգտագործվող աղյուսակների դաշտերը և փոփոխականները տարբերելու համար վերջինիս նախորդը պետք է նշեք երկու կետով: Ի վերջո, փոփոխականները կարող են ունենալ ճիշտ նույն անվանումը, ինչ դաշտերը աղյուսակներում:
Սակայն փոփոխականի անունից առաջ երկու կետը պետք է օգտագործվի միայն SQL հարցումների ներսում: Տեքստերից դուրս փոփոխականին հասանելի է դառնում առանց երկու կետի, օրինակ՝
procName="Որոշ անուն";
Բայց վերադառնանք մեր ընթացակարգի մարմնին: FOR SELECT դրույթը վերադարձնում է տվյալները ոչ թե աղյուսակի տեսքով՝ տվյալների հավաքածու, այլ մեկ տող: Յուրաքանչյուր վերադարձված դաշտ պետք է տեղադրվի իր սեփական փոփոխականում՝ ID => procID, NAME => procName: DO մասում այս փոփոխականներն ուղարկվում են հաճախորդին, որը կանչել է p>ընթացակարգը՝ օգտագործելով SUSPEND հրամանը:
Այսպիսով, FOR SELECT... DO հրամանը պտտվում է հրամանի SELECT մասում ընտրված գրառումների միջով: DO մասի կողմից ձևավորված օղակի մարմնում հաջորդ գեներացված գրառումը փոխանցվում է հաճախորդին՝ օգտագործելով SUSPEND հրամանը:
Այսպիսով, ընտրության ընթացակարգը նախատեսված է մեկ կամ մի քանի տող վերադարձնելու համար, որոնց համար CP-ի մարմնի ներսում օղակ է կազմակերպվում՝ լրացնելով ստացված փոփոխական պարամետրերը։ Եվ այս օղակի մարմնի վերջում կա SUSPEND հրաման, որը կվերադարձնի տվյալների հաջորդ շարքը հաճախորդին:
Օղակներ և մասնաճյուղերի օպերատորներ
Բացի FOR SELECT... DO հրամանից, որը կազմակերպում է ցիկլ որոշակի ընտրության գրառումների միջոցով, կա ցիկլի մեկ այլ տեսակ՝ WHILE...DO, որը թույլ է տալիս կազմակերպել ցիկլ՝ հիմնվելով ցանկացած պայմանների ստուգման վրա: Ահա HP-ի օրինակ, որն օգտագործում է WHILE..DO հանգույցը: Այս ընթացակարգը վերադարձնում է ամբողջ թվերի քառակուսիները 0-ից մինչև 99.
ՍՏԵՂԾԵԼ PROCEDJRE QUAD
ՎԵՐԱԴԱՐՁՆԵՐ (ՔՎԱԴՐԱՏ ԱՄԲՈՂՋ ԹՎԵՐ)
ԱՍ
ՀԱՅՏԱՐԱՐԵԼ ՓՈՓՈԽԱԿԱՆ I ՈՂՋ;
ՍԿՍԵԼ
i = 1;
Մինչդեռ (i<100) DO
ՍԿՍԵԼ
QUADRAT=I*I;
I=I+1;
ԿԱՍԵՑԵԼ;
ՎԵՐՋ
ՎԵՐՋ
SELECT FROM QUAD հարցումը կատարելու արդյունքում կստանանք մեկ QUADRAT սյունակ պարունակող աղյուսակ, որում կլինեն 1-ից 99-ի ամբողջ թվերի քառակուսիներ:
Ի լրումն SQL հարցման և դասական հանգույցի արդյունքների կրկնությունից, պահպանված ընթացակարգի լեզուն օգտագործում է IF...THEN..ELSE հայտարարությունը, որը թույլ է տալիս կազմակերպել ճյուղավորում՝ կախված ցանկացած \պայմանների կատարումից: Դրա շարահյուսությունը հետևյալն է. նման է բարձր մակարդակի ծրագրավորման լեզուների ճյուղային հայտարարությունների մեծամասնությանը, ինչպիսիք են Pascal-ը և C-ն:
Դիտարկենք պահված ընթացակարգի ավելի բարդ օրինակ, որն անում է հետևյալը.
- Հաշվում է միջին գինը Table_example աղյուսակում (տե՛ս «Աղյուսակներ Հիմնական բանալիներ և գեներատորներ» գլուխը)
- Այնուհետև, աղյուսակի յուրաքանչյուր մուտքի համար նա կատարում է հետևյալ ստուգումը, եթե առկա գինը (PRICE) ավելի մեծ է, քան միջին գինը, ապա սահմանում է գինը հավասար միջին գնին գումարած նշված ֆիքսված տոկոսը:
- Եթե ընթացիկ գինը փոքր է կամ հավասար է միջին գնին, ապա սահմանում է գինը, որը հավասար է նախորդ գնին, գումարած նախորդ և տարբերության կեսը: միջին գինը.
- Վերադարձնում է աղյուսակի բոլոր փոխված տողերը:
Նախ սահմանենք HP-ի անվանումը, ինչպես նաև մուտքային և ելքային պարամետրերը:Այս ամենը գրված է պահվող ընթացակարգի վերնագրում:
ՍՏԵՂԾԵԼ ԿԱՐԳԸ Բարձրացնել Գները (
Տոկոս 2 Բարձրացնել ԿՐԿՆԱԿԻ ՃՇՇՏ)
ՎԵՐԱԴԱՐՁՈՒՄ Է (ID INTEGER, NAME VARCHAR(SO), new_price DOUBLE
PRECISION AS
Պրոցեդուրան կոչվելու է IncreasePrices, այն ունի մեկ մուտքային պարամետր Peiceni21nciease, որը տիպի DOUBLE PRECISION է, և 3 ելքային պարամետր՝ ID, NAME և new_pnce: Նկատի ունեցեք, որ առաջին երկու ելքային պարամետրերն ունեն նույն անունները, ինչ դաշտերը Table_example աղյուսակում, որոնց հետ մենք պատրաստվում ենք աշխատել: Դա թույլատրվում է պահվող ընթացակարգի լեզվի կանոններով:
Այժմ մենք պետք է հայտարարենք տեղական փոփոխական, որը կօգտագործվի միջին արժեքը պահելու համար: Ego-ի հռչակագիրը կունենա հետևյալ տեսքը.
ՀԱՅՏԱՐԱՐԵԼ ՓՈՓՈԽԱԿԱՆ միջին_գին ԿՐԿՆԱԿԻ ՃՇՇՏ;
Այժմ անցնենք պահեստավորված պրոցեդուրաների մարմնին Բացենք ԿՊ-ի մարմինը
հիմնաբառ ՍԿՍԵԼ.
Նախ, մենք պետք է կատարենք մեր ալգորիթմի առաջին քայլը` հաշվարկել միջին գինը: Դա անելու համար մենք կօգտագործենք հետևյալ հարցումը.
SELECT AVG (գին_լ)
FROM Table_Example
INTO:avg_price,-
Այս հարցումն օգտագործում է AVG ագրեգատ ֆունկցիա, որը վերադարձնում է PRICE_1 դաշտի միջին արժեքը ընտրված հարցման տողերի մեջ. մեր դեպքում՝ PRICE_1 միջին արժեքը ամբողջ Table_example աղյուսակում: Հարցման կողմից վերադարձված արժեքը տեղադրվում է avg_price փոփոխականում: Նկատի ունեցեք, որ avg_pnce փոփոխականին նախորդում է երկու կետ՝ այն տարբերելու հարցումում օգտագործվող դաշտերից:
հատկանիշ տրված խնդրանքըայն է, որ այն միշտ վերադարձնում է ճիշտ մեկ մուտք: Նման հարցումները կոչվում են միանգամյա հարցումներ և միայն այդպիսի ընտրանքները կարող են օգտագործվել պահվող ընթացակարգերում: Եթե հարցումը վերադարձնում է մեկից ավելի տող, ապա այն պետք է ձևաչափվի որպես FOR SELECT...DO կառուցվածք, որը կազմակերպում է օղակ՝ յուրաքանչյուր վերադարձված տողը մշակելու համար:
Այսպիսով, մենք ստացանք գնի միջին արժեքը: Այժմ դուք պետք է անցնեք ամբողջ աղյուսակը, համեմատեք յուրաքանչյուր գրառման գնի արժեքը միջին գնի հետ և համապատասխան քայլեր ձեռնարկեք:
Սկզբից մենք կազմակերպում ենք յուրաքանչյուր գրառումի կրկնություն Table_example աղյուսակից
ՀԱՄԱՐ
SELECT ID, NAME, PRICE_1
FROM Table_Example
INTO:ID, :NAME, :new_price
ԱՐԵԼ
ՍԿՍԵԼ
/*_այստեղ oՊատվիրեք յուրաքանչյուր գրառում*/
ՎԵՐՋ
Երբ այս շինարարությունը կատարվի, տվյալները կվերցվեն տող առ տող Table_example աղյուսակից, և յուրաքանչյուր տողում դաշտի արժեքները վերագրվեն ID, NAME և new_pnce փոփոխականներին: Իհարկե, դուք հիշում եք, որ այս փոփոխականները հայտարարված են որպես ելքային պարամետրեր, բայց չպետք է անհանգստանաք, որ ընտրված տվյալները կվերադարձվեն որպես արդյունք. այն փաստը, որ ելքային պարամետրերին ինչ-որ բան է վերագրվում, չի նշանակում, որ HP զանգահարող հաճախորդը անմիջապես կստանա: այս արժեքները. Պարամետրերը փոխանցվում են միայն այն ժամանակ, երբ կատարվում է SUSPEND հրամանը, իսկ մինչ այդ մենք կարող ենք օգտագործել ելքային պարամետրերը որպես նորմալ փոփոխականներ. մեր օրինակում մենք հենց դա ենք անում new_price պարամետրով:
Այսպիսով, BEGIN... .END օղակի մարմնի ներսում մենք կարող ենք մշակել յուրաքանչյուր տողի արժեքները: Ինչպես հիշում եք, մենք պետք է պարզենք, թե ինչպես է առկա գինը համեմատվում միջինի հետ, և համապատասխան քայլեր ձեռնարկենք: Մենք իրականացնում ենք այս համեմատման ընթացակարգը՝ օգտագործելով IF հայտարարությունը.
ԵԹԵ (new_price > avg_price) ԱՊԱ /*եթե ընթացիկ գինը միջինից մեծ է*/
ՍԿՍԵԼ
/* ապա տեղադրել նոր գինհավասար է միջին գնին, գումարած ֆիքսված տոկոս */
նոր_գին = (միջին_գին + միջին_գին*(Տոկոս2 աճ/100));
ԹԱՐՄԱՑՆԵԼ Աղյուսակ_օրինակ
SET PRICE_1 = :new_price
ՈՐՏԵՂ ID = :ID;
ՎԵՐՋ
ԱՅԼՍ
ՍԿՍԵԼ
/* Եթե ընթացիկ գինը փոքր է կամ հավասար է միջին գնին, ապա սահմանեք գինը, որը հավասար է նախորդ գնին, գումարած հին և միջին գնի տարբերությունը */
new_price = (new_pnce + ((avg_pnce new_price)/2)) ;
ԹԱՐՄԱՑՆԵԼ Աղյուսակ_օրինակ
SET PRICE_1 = :new_price
ՈՐՏԵՂ ID = .ID;
ՎԵՐՋ
Ինչպես տեսնում եք, մենք ստացել ենք բավականին մեծ IF կոնստրուկցիա, որը դժվար կլիներ հասկանալ, եթե չլինեին /**/ նիշերով կցված մեկնաբանությունները։
Գինը ըստ հաշվարկված տարբերության փոխելու համար մենք կօգտագործենք UPDATE քաղվածքը, որը թույլ է տալիս փոփոխել. առկա գրառումները- մեկ կամ ավելի. Որպեսզի միանշանակ նշենք, թե որ գրառման մեջ պետք է փոխվի գինը, մենք օգտագործում ենք WHERE կետի առաջնային բանալին՝ այն համեմատելով այն փոփոխականի արժեքի հետ, որը պահում է ID արժեքը ընթացիկ գրառման համար՝ ID=:ID: Նշենք, որ ID փոփոխականին նախորդում է երկու կետ:
IF...THEN...ELSE կոնստրուկցիան կատարելուց հետո ID, NAME և new_price փոփոխականները պարունակում են այն տվյալները, որոնք մենք պետք է վերադարձնենք հաճախորդին, ով զանգահարել է ընթացակարգը: Դա անելու համար IF-ից հետո դուք պետք է տեղադրեք SUSPEND հրամանը, որը կուղարկի տվյալները այնտեղ, որտեղից կանչվել է HP-ն: Փոխանցման տևողության ընթացքում ընթացակարգը կկասեցվի, և երբ դա պահանջվի HP-ից: նոր մուտք, այնուհետև այն նորից կշարունակվի - և այդպես կշարունակվի մինչև FOR SELECT...DO-ն կանցնի իր հարցման բոլոր գրառումները:
Հարկ է նշել, որ բացի SUSPEND հրամանից, որը միայն կասեցում է պահված պրոցեդուրան, կա EXIT հրամանը, որը դադարեցնում է պահպանված պրոցեդուրան տողը անցնելուց հետո։ Այնուամենայնիվ, EXIT հրամանը հազվադեպ է օգտագործվում, քանի որ այն անհրաժեշտ է հիմնականում օղակը կոտրելու համար, երբ հասնում է որոշակի պայման:
Այս դեպքում, երբ ընթացակարգը կանչվել է SELECT հայտարարությամբ և ավարտվել EXIT-ով, վերջին վերցված տողը չի վերադարձվի: Այսինքն, եթե դուք պետք է ընդհատեք ընթացակարգը և դեռ> ստանաք այս տողը, ապա պետք է օգտագործեք հաջորդականությունը
ԿԱՍԵՑԵԼ;
ԵԼՔ;
EXIT-ի հիմնական նպատակն է ստանալ միայնակ տվյալների հավաքածուներ, վերադարձնել պարամետրերը՝ զանգահարելով EXECUTE PROCEDURE-ի միջոցով: Այս դեպքում ելքային պարամետրերի արժեքները սահմանվում են, բայց SQL տվյալների հավաքածուն չի ձևավորվում դրանցից, և ընթացակարգը ավարտվում է:
Եկեք ամբողջությամբ գրենք մեր պահպանված ընթացակարգի տեքստը, որպեսզի կարողանանք մի հայացքով ֆիքսել դրա տրամաբանությունը.
ՍՏԵՂԾԵԼ ԿԱՐԳԸ Բարձրացնել Գները (
Տոկոս 2 Բարձրացնել ԿՐԿՆԱԿԻ ՃՇՇՏ)
ՎԵՐԱԴԱՐՁՈՒՄ Է (ID ԱՄԲՈՂՋ ԹԻՎ, ԱՆՈՒՆ VARCHAR(80),
new_price ԿՐԿՆԱԿԻ ՃՇՇՏ) AS
ՀԱՅՏԱՐԱՐԵԼ ՓՈՓՈԽԱԿԱՆ միջին_գին ԿՐԿՆԱԿԻ ՃՇՇՏ;
ՍԿՍԵԼ
SELECT AVG (գին_լ)
FROM Table_Example
INTO:միջին_գին;
ՀԱՄԱՐ
SELECT ID, NAME, PRICE_1
FROM Table_Example
INTO:ID, :NAME, :new_price
ԱՐԵԼ
ՍԿՍԵԼ
/*մենք այստեղ մշակում ենք յուրաքանչյուր գրառում*/
ԵԹԵ (new_pnce > avg_price) ԱՊԱ /*եթե ընթացիկ գինը միջինից մեծ է*/
ՍԿՍԵԼ
/*սահմանեք նոր գին, որը հավասար է միջին գնին գումարած ֆիքսված տոկոս */
նոր_գին = (միջին_գին + միջին_գին*(Տոկոս2 աճ/100));
ԹԱՐՄԱՑՆԵԼ Աղյուսակ_օրինակ
SET PRICE_1 = :new_price
ՈՐՏԵՂ ID = :ID;
ՎԵՐՋ
ԱՅԼՍ
ՍԿՍԵԼ
/* Եթե ընթացիկ գինը փոքր է կամ հավասար է միջին գնին, ապա սահմանում է գինը, որը հավասար է նախորդ գնին, գումարած հին և միջին գնի տարբերությունը */
նոր_գին = (նոր_գին + ((միջին_գին - նոր_գին)/2));
ԹԱՐՄԱՑՆԵԼ Աղյուսակ_օրինակ
SET PRICE_1 = :new_price
ՈՐՏԵՂ ID = :ID;
ՎԵՐՋ
ԿԱՍԵՑԵԼ;
ՎԵՐՋ
ՎԵՐՋ
Պահպանված ընթացակարգի այս օրինակը ցույց է տալիս հիմնական պահպանված ընթացակարգի և գործարկիչ լեզվի կառուցվածքների օգտագործումը: Հաջորդը, մենք կքննարկենք պահպանված ընթացակարգերի օգտագործման ուղիները որոշ ընդհանուր խնդիրներ լուծելու համար:
Ռեկուրսիվ Պահված ընթացակարգեր
InterBase պահպանված ընթացակարգերը կարող են լինել ռեկուրսիվ: Սա նշանակում է, որ պահպանված պրոցեդուրան կարող է զանգահարել իրեն: Թույլատրվում է պահված ընթացակարգերի մինչև 1000 բնադրման մակարդակ, այնուամենայնիվ, պետք է հիշել, որ սերվերի անվճար ռեսուրսները կարող են սպառվել մինչև HP-ի առավելագույն բույնի հասնելը:
Պահված ընթացակարգերի ընդհանուր օգտագործումը տվյալների բազայում պահվող ծառի կառուցվածքների մշակումն է: Ծառերը հաճախ օգտագործվում են BOM-ում, պահեստում, HR-ում և այլ սովորական ծրագրերում:
Դիտարկենք պահեստավորված ընթացակարգի օրինակ, որն ընտրում է որոշակի տեսակի բոլոր ապրանքները՝ սկսած որոշակի բնադրման մակարդակից:
Ենթադրենք, մենք ունենք խնդրի հետևյալ դրույթը. մենք ունենք ապրանքների տեղեկատու հիերարխիկ կառուցվածքըայս տեսակի.
Ապրանքներ
- Կենցաղային տեխնիկա
- Սառնարաններ
- Եռախցիկ
-Երկսենյականոց
- Միայնակ պալատ
-
Լվացքի մեքենաներ
- Ուղղահայաց
- Ճակատային
- Դասական
- Նեղ
- Համակարգչային տեխնոլոգիա
....
Ապրանքների կատեգորիաների գրացուցակի այս կառուցվածքը կարող է ունենալ տարբեր խորության ճյուղեր: և նաև ժամանակի ընթացքում ավելանում է: Մեր խնդիրն է ապահովել գրացուցակից բոլոր վերջավոր տարրերի ընտրությունը «ամբողջական անունը բացելով»՝ սկսած ցանկացած հանգույցից: Օրինակ, եթե ընտրենք «Լվացքի մեքենաներ» հանգույցը, ապա պետք է ստանանք հետևյալ կատեգորիաները.
Լվացքի մեքենաներ - Ուղղահայաց
Լվացքի մեքենաներ - Frontal Classic
Լվացքի մեքենաներ - Ճակատային Նեղ
Եկեք սահմանենք աղյուսակների կառուցվածքը արտադրանքի գրացուցակում տեղեկատվության պահպանման համար: Ծառը մեկ աղյուսակում կազմակերպելու համար մենք օգտագործում ենք պարզեցված սխեմա.
ՍԵՂԱՆԻ ՍԵՂԱՆԻ ՍՏԵՂԾԵՔ ԱպրանքներԾառ
(ID_GOOD ԱՄԲՈՂՋ ԹԻՎԸ ՉԻ ՆՈՒԼԼ,
ID_PARENT_GOOD INTEGER,
GOOD_NAME VARCHAR(80),
սահմանափակում pkGooci հիմնական բանալին (ID_GOOD));
Մենք ստեղծում ենք մեկ GoodsTree աղյուսակ, որն ունի ընդամենը 3 դաշտ՝ ID_GOOD - խելացի կատեգորիայի նույնացուցիչ, ID_PARENT_GOOD - կատեգորիայի մայր ծառի նույնացուցիչ այս կատեգորիայի համար և GOOD_NAME - կատեգորիայի անվանումը: Այս աղյուսակի տվյալների ամբողջականությունն ապահովելու համար մենք այս աղյուսակի վրա կսահմանենք արտաքին բանալիների սահմանափակում.
ALTER TABLE GoodsTree
ԱՎԵԼԱՑՆԵԼ ՍԱՀՄԱՆԱՓԱԿՈՒՄ FK_goodstree
ՕՏԱՐ ԲԱՆԱԼԻ (ID_PARENT_GOOD)
Հղումներ GOODSTPEE (ID_GOOD)
Աղյուսակը վերաբերում է իրեն, և տվյալ օտարերկրյա բանալին հետևում է դրան: այնպես, որ աղյուսակը չունի հղումներ գոյություն չունեցող ծնողներին, ինչպես նաև կանխում է երեխաներ ունեցող ապրանքների կատեգորիաները ջնջելու փորձերը:
Եկեք մեր աղյուսակում տեղադրենք հետևյալ տվյալները.
| ID_GOOD 1
|
ID_PARENT_GOOD 0
|
GOOD_NAME ԻՐԵՐ |
Այժմ, երբ մենք ունենք տվյալների պահպանման տեղ, մենք կարող ենք սկսել ստեղծել պահպանված ընթացակարգ, որը ցուցադրում է ապրանքի բոլոր «վերջնական» կատեգորիաները «ընդլայնված» ձևով, օրինակ՝ «Երեք պալատ» կատեգորիայի համար լրիվ անվանումը: կատեգորիան նման կլինի «Կենցաղային տեխնիկայի սառնարաններ եռախցիկ»:
Պահպանված ընթացակարգերը, որոնք մշակում են ծառի կառուցվածքները, մշակել են իրենց տերմինաբանությունը: Ծառի յուրաքանչյուր տարր կոչվում է հանգույց; իսկ հանգույցների միջև փոխհարաբերությունները, որոնք վերաբերում են միմյանց, կոչվում է ծնող-երեխա հարաբերություն: Հանգույցները, որոնք գտնվում են ծառի ամենավերջում և երեխա չունեն, կոչվում են «տերևներ»:
Մեր պահպանված պրոցեդուրան որպես մուտքագրում կունենա կատեգորիայի ID, որից մենք պետք է սկսենք փորագրումը: Պահպանված ընթացակարգը կունենա հետևյալ տեսքը.
ՍՏԵՂԾԵԼ ԿԱՐԳԸ GETFULLNAME (ID_GOOD2SHOW INTEGER)
RETURNS (FULL_GOODS_NAME VARCHAR(1000),
ID_CHILD_GOOD INTEGER)
ԱՍ
ՀԱՅՏԱՐԱՐԵԼ ՓՈՓՈԽԱԿԱՆ CURR_CHILD_NAME VARCHAR(80);
ՍԿՍԵԼ
/*0կազմակերպել արտաքին ՀԱՄԱՐ հանգույց SELECT ID_GOOD=ID_GOOD2SHOW */ արտադրանքի անմիջական ժառանգների վրա
ԸՆՏՐԵԼ gtl.id_good, gtl.good_name
FROM GoodsTree gtl
WHERE gtl.id_parent_good=:ID_good2show
INTO:ID_CHILD_GOOD, :full_goods_name
ԱՐԵԼ
ՍԿՍԵԼ
/"Ստուգեք EXISTS ֆունկցիայի հետ, որը վերադարձնում է TRUE, եթե փակագծերի հարցումը վերադարձնում է առնվազն մեկ տող: Եթե ID_PARENT_GOOD = ID_CHILD_GOOD-ով գտնված հանգույցը երեխաներ չունի, ապա այն ծառի «տերևն» է և մտնում է արդյունքների մեջ * /
ԵԹԵ (ՉԻ ԳՈՅՈՒԹՅԱՆ)
SELECT * GoodsTree-ից
WHERE GoodsTree.id_parent_good=:id_child_good))
ՀԵՏՈ
ՍԿՍԵԼ
/* Ծառի «տերևը» փոխանցեք արդյունքներին */
ԿԱՍԵՑԵԼ;
ՎԵՐՋ
ԱՅԼՍ
/* Երեխաներ ունեցող հանգույցների համար */
ՍԿՍԵԼ
/*պահել մայր հանգույցի անունը ժամանակավոր փոփոխականում */
CURR_CHILD_NAME=լրիվ_ապրանքի_անուն;
/* գործարկել այս ընթացակարգը ռեկուրսիվորեն */
ՀԱՄԱՐ
Ընտրեք ID_CHILD_GOOD, full_goods_name
GETFULLNAME-ից (:ID_CHILD_GOOD)
INTO:ID_CHILD_GOOD, :full_goods_name
ՍԿՍԵԼ
/*գտնվածին ավելացրեք ծնող հանգույցի անունը, երեխայի անունը օգտագործելով տողերի միացման գործողությունը || */
full_goods_name=CURR_CHILD_NAME| «» | f ull_goods_name,-
ԿԱՍԵՑԵԼ; /* վերադարձրեք ապրանքի լրիվ անվանումը */
ՎԵՐՋ
ՎԵՐՋ
ՎԵՐՋ
ՎԵՐՋ
Եթե մենք անենք այս ընթացակարգը ID_GOOD2SHOW= 1 մուտքագրման պարամետրով մենք ստանում ենք հետևյալը.
Ինչպես տեսնում եք, ռեկուրսիվ պահպանված ընթացակարգի օգնությամբ մենք անցանք կատեգորիայի ամբողջ ծառի միջով և դուրս բերեցինք «տերևների» կատեգորիաների ամբողջական անվանումը, որոնք գտնվում են ճյուղերի ծայրերում:
Եզրակացություն
Սա ավարտում է պահված ընթացակարգի լեզվի հիմնական հատկանիշների մեր վերանայումը: Ակնհայտ է, որ անհնար է ամբողջությամբ տիրապետել պահեստավորված ընթացակարգերի մշակմանը մեկ գլխում, բայց այստեղ մենք փորձել ենք ներկայացնել և բացատրել պահեստավորված ընթացակարգերի հետ կապված հիմնական հասկացությունները: HP-ի նկարագրված նախագծերը և նախագծման տեխնիկան կարող են կիրառվել տվյալների բազայի հավելվածների մեծ մասում:
Պահված ընթացակարգերի մշակման հետ կապված որոշ կարևոր հարցեր կքննարկվեն հաջորդ գլխում՝ «InterBase պահպանվող ընթացակարգերի լեզվի ընդլայնված առանձնահատկությունները», որը նվիրված է բացառությունների մշակմանը, պահված ընթացակարգերում սխալների մշակմանը և զանգվածների հետ աշխատելուն:
- Ուսումնասիրել պահված ընթացակարգերը նկարագրող օպերատորները և դրանց մուտքային և ելքային պարամետրերը փոխանցելու սկզբունքները:
- Իմացեք, թե ինչպես ստեղծել և կարգաբերել պահված ընթացակարգերը MS SQL Server 2000-ում:
- Մշակել հինգ հիմնական պահվող ընթացակարգեր գրադարանի նմուշային տվյալների բազայի համար:
- Կատարված աշխատանքի վերաբերյալ հաշվետվություն պատրաստել էլեկտրոնային տարբերակով:
1. Ընդհանուր տեղեկություններ պահվող ընթացակարգերի մասին
Պահպանման կարգըսերվերում պահվող հրամանների մի շարք է և կատարվում է որպես մեկ միավոր: Պահված ընթացակարգերը մեխանիզմ են, որով դուք կարող եք ստեղծել ռեժիմներ, որոնք աշխատում են սերվերի վրա և կառավարվում են դրա գործընթացներով: Նման ռեժիմները կարող են կանչվել հավելվածի կողմից, որը կանչում է դրանք: Բացի այդ, դրանք կարող են առաջանալ տվյալների ամբողջականության կանոններով կամ գործարկիչներով:
Պահված ընթացակարգերը կարող են արժեքներ վերադարձնել: Ընթացակարգում դուք կարող եք համեմատել օգտվողի կողմից մուտքագրված արժեքները համակարգում նախապես տեղադրված տեղեկատվության հետ: Պահպանված ընթացակարգերն օգտվում են SQL Server ապարատային հզորությունից: Նրանք կենտրոնացած են տվյալների բազայի վրա և սերտորեն համագործակցում են SQL Server օպտիմիզատորի հետ: Սա թույլ է տալիս ստանալ բարձր կատարողականտվյալների մշակման ժամանակ.
Դուք կարող եք արժեքներ փոխանցել պահված ընթացակարգերին և դրանցից ստանալ աշխատանքի արդյունքներ, և պարտադիր չէ, որ կապված լինեն աշխատանքային սեղանի հետ: Պահված ընթացակարգը կարող է հաշվարկել արդյունքները, երբ այն աշխատում է:
Պահպանվող ընթացակարգերը երկու տեսակի են. սովորականև երկարացված. Կանոնավոր պահպանված ընթացակարգերը Transact-SQL հրամանների մի շարք են, մինչդեռ ընդլայնված պահպանված ընթացակարգերը ներկայացված են որպես դինամիկ գրադարաններ (DLL): Նման ընթացակարգերը, ի տարբերություն սովորական ընթացակարգերի, ունեն xp_ նախածանց: Սերվերն ունի ընդլայնված ընթացակարգերի ստանդարտ փաթեթ, սակայն օգտվողները կարող են գրել իրենց ընթացակարգերը ցանկացած ծրագրավորման լեզվով: Հիմնական բանը ծրագրավորման ինտերֆեյսի օգտագործումն է SQL Server Open Data Services API. Ընդլայնված պահպանված ընթացակարգերը կարող են լինել միայն Master տվյալների բազայում:
Սովորական պահվող ընթացակարգերը նույնպես կարելի է բաժանել երկու տեսակի. համակարգայինև սովորություն. Համակարգային ընթացակարգերը ստանդարտ ընթացակարգեր են, որոնք օգտագործվում են սերվերը գործարկելու համար. օգտագործողի կողմից սահմանված ցանկացած ընթացակարգ, որը ստեղծվել է օգտագործողի կողմից:
1.1. Պահպանված ընթացակարգերի առավելությունները
Ի շատ ընդհանուր դեպքՊահպանված ընթացակարգերն ունեն հետևյալ առավելությունները.
- Բարձր կատարողական.Արդյունքն է սերվերի վրա պահված ընթացակարգերի գտնվելու վայրի: Սերվերը, որպես կանոն, ավելի հզոր մեքենա է, ուստի սերվերի վրա ընթացակարգի կատարման ժամանակը շատ ավելի քիչ է, քան աշխատանքային կայանում: Բացի այդ, տվյալների բազայի տեղեկատվությունը և պահվող ընթացակարգը գտնվում են միևնույն համակարգում, այնպես որ քիչ ժամանակ է ծախսվում ցանցով գրառումները փոխանցելու համար: Պահպանված ընթացակարգերը ուղղակիորեն հասանելի են տվյալների բազաներին, ինչը շատ արագ է դարձնում տեղեկատվության հետ աշխատելը:
- Համակարգի զարգացման առավելությունը «հաճախորդ-սերվեր» ճարտարապետության մեջ.Այն բաղկացած է հաճախորդի և սերվերի ծրագրային ապահովման առանձին ստեղծման հնարավորությունից: Այս առավելությունն առանցքային է զարգացման մեջ և կարող է զգալիորեն նվազեցնել նախագիծն ավարտելու համար պահանջվող ժամանակը: Սերվերի վրա աշխատող կոդը կարող է մշակվել հաճախորդի կողմի կոդից առանձին: Այս դեպքում սերվերի կողմի բաղադրիչները կարող են կիսվել հաճախորդի կողմի բաղադրիչներով:
- Անվտանգության մակարդակ.Պահպանված ընթացակարգերը կարող են հանդես գալ որպես անվտանգության բարձրացման գործիք: Դուք կարող եք ստեղծել պահպանված պրոցեդուրաներ, որոնք կատարում են ցուցակների ավելացման, փոփոխման, ջնջման և ցուցադրման գործողությունները, և այդպիսով վերահսկողություն ձեռք բերել տեղեկատվության հասանելիության բոլոր ասպեկտների վրա:
- Սերվերի կանոնների ամրապնդում, որոնք աշխատում են տվյալների հետ:Սա ամենաշատերից մեկն է կարևոր պատճառներտվյալների բազայի խելացի շարժիչի կիրառում: Պահպանված ընթացակարգերը թույլ են տալիս կիրառել կանոններ և այլ տրամաբանություն՝ օգնելու վերահսկել, թե ինչ տեղեկատվություն է մուտքագրվում համակարգ:
Չնայած նրան SQL լեզուՍահմանված որպես ոչ ընթացակարգային՝ SQL Server-ը օգտագործում է հիմնաբառեր՝ կապված ընթացակարգերի հոսքի վերահսկման հետ: Այս հիմնաբառերն օգտագործվում են ընթացակարգեր ստեղծելու համար, որոնք կարող են պահպանվել հետագա կատարման համար: Պահված ընթացակարգերը կարող են օգտագործվել ստանդարտ ծրագրավորման լեզուներով գրված ծրագրերի փոխարեն (օրինակ՝ C կամ Visual Basic), որոնք գործողություններ են կատարում SQL Server տվյալների բազայում:
Պահված ընթացակարգերը կազմվում են առաջին անգամ գործարկվելիս և պահվում են ընթացիկ տվյալների բազայի համակարգի աղյուսակում: Կազմվելիս դրանք օպտիմիզացված են։ Այս դեպքում ամենաշատը Լավագույն միջոցըաղյուսակի տեղեկատվության հասանելիություն: Նման օպտիմալացումը հաշվի է առնում աղյուսակի տվյալների իրական դիրքը, առկա ինդեքսները, աղյուսակի բեռնումը և այլն:
Կազմված պահված ընթացակարգերը կարող են զգալիորեն բարելավել համակարգի աշխատանքը: Հարկ է նշել, սակայն, որ տվյալների վիճակագրությունը՝ ընթացակարգի ստեղծման պահից մինչև դրա կատարման պահը, կարող է հնացած դառնալ, իսկ ինդեքսները՝ անարդյունավետ: Թեև դուք կարող եք թարմացնել վիճակագրությունը և ավելացնել նոր, ավելի արդյունավետ ինդեքսներ, ընթացակարգի կատարման պլանն արդեն կազմված է, այսինքն՝ ընթացակարգը կազմված է, և արդյունքում տվյալների հասանելիության եղանակը կարող է այլևս արդյունավետ չլինել։ . Հետևաբար, յուրաքանչյուր զանգի հետ հնարավոր է վերակազմավորել ընթացակարգերը:
Մյուս կողմից, ամեն անգամ վերակազմավորելու համար ժամանակ կպահանջվի: Հետևաբար, ընթացակարգը վերակազմավորելու կամ դրա կատարման մեկանգամյա պլան կազմելու արդյունավետության հարցը բավականին նուրբ է և պետք է դիտարկել յուրաքանչյուր կոնկրետ դեպքի համար առանձին:
Պահպանված ընթացակարգերը կարող են իրականացվել կամ տեղական մեքենայի կամ հեռավոր SQL Server համակարգի վրա: Սա հնարավորություն է տալիս ակտիվացնել գործընթացները այլ մեքենաներում և աշխատել ոչ միայն տեղական տվյալների բազաների, այլև մի քանի սերվերների տեղեկատվության հետ:
Բարձր մակարդակի լեզուներից մեկով գրված կիրառական ծրագրերը, ինչպիսիք են C կամ Visual Basic .NET-ը, կարող են նաև զանգահարել պահված ընթացակարգեր, որոնք ապահովում են. օպտիմալ լուծումբեռը բաշխելու համար ծրագրային ապահովումհաճախորդի կողմը և SQL սերվերը:
1.2. Պահպանված ընթացակարգերի ստեղծում
Ստեղծել ընթացակարգի հայտարարությունն օգտագործվում է պահված ընթացակարգ ստեղծելու համար: Պահված ընթացակարգի անունը կարող է լինել մինչև 128 նիշ, ներառյալ # և ## նիշերը: Ընթացակարգի սահմանման շարահյուսություն.
CREATE PROC procedure_name [; թիվ]
[(@data_type պարամետր) [= default_value] ] [,...n]
ԱՍ
<Инструкции_SQL>
Դիտարկենք այս հրամանի պարամետրերը.
- Procedure_name ընթացակարգի անվանումը; պետք է համապատասխանի նույնացուցիչների կանոններին. դրա երկարությունը չի կարող գերազանցել 128 նիշը. Տեղական ժամանակավոր ընթացակարգերի համար # նշանն օգտագործվում է անվան դիմաց, իսկ գլոբալ ժամանակավոր ընթացակարգերի համար՝ ## նշանները.
- Համարակալել կամընտիր ամբողջ թիվ, որն օգտագործվում է մի քանի ընթացակարգեր նույն անունով խմբավորելու համար.
- @datatype պարամետրընթացակարգի պարամետրերի անունների ցանկ՝ յուրաքանչյուրի համար համապատասխան տվյալների տիպի նշումով. կարող է լինել մինչև 2100 նման պարամետր: Թույլատրվում է փոխանցել NULL որպես պարամետր արժեք: Բոլոր տվյալների տեսակները կարող են օգտագործվել բացառությամբ տեքստի, ntext և պատկերի: Կուրսորի տվյալների տեսակը կարող է օգտագործվել որպես ելքային պարամետր (հիմնաբառ OUTPUT կամ VARYING): Կուրսորը տվյալների տիպով պարամետրերը կարող են լինել միայն ելքային պարամետրեր.
- VARYING բանալի բառ, որը նշում է, որ արդյունքների հավաքածուն օգտագործվում է որպես ելքային պարամետր (օգտագործվում է միայն Կուրսոր տեսակի համար);
- OUTPUT-ը ցույց է տալիս, որ նշված պարամետրը կարող է օգտագործվել որպես ելք.
- default_valueօգտագործվում է, երբ ընթացակարգը կանչելիս պարամետրը բաց է թողնվում. պետք է լինի հաստատուն և կարող է ներառել սիմվոլային նշաններ (%, _, [,], ^) և NULL;
- RECOMPILE հիմնաբառերով, որոնք ցույց են տալիս, որ SQL Server-ը չի գրի ընթացակարգի պլանը քեշում, այլ կստեղծի այն ամեն անգամ, երբ այն կատարվի;
- WITH ENCRYPTION հիմնաբառերով, որոնք ցույց են տալիս, որ SQL Server-ը կգաղտնագրի ընթացակարգը նախքան այն գրելը Syscomments համակարգի աղյուսակում: Կոդավորված պրոցեդուրաների տեքստը վերականգնելն անհնարին դարձնելու համար անհրաժեշտ է գաղտնագրումից հետո ջնջել համապատասխան tuples-ները syscomments աղյուսակից.
- ՌԵՊԼԻԿԱՑՄԱՆ ՀԱՄԱՐ հիմնաբառեր, որոնք ցույց են տալիս, որ այս ընթացակարգը ստեղծվել է միայն կրկնօրինակման համար: Այս տարբերակը անհամատեղելի է WITH RECOMPILE հիմնաբառերի հետ.
- ՈՐՊԵՍ ընթացակարգի տեքստի սահմանման սկիզբ;
- <Инструкции_SQL>վավեր SQL հայտարարությունների հավաքածու՝ միայն սահմանափակված առավելագույն չափըպահված ընթացակարգ 128 ԿԲ: Հետևյալ հայտարարություններն անվավեր են. ALTER DATABASE , ALTER PROCEDURE , ALTER TABLE , CREATE DEFAULT , CREATE PROCEDURE , ALTER TRIGGER , ALTER VIEW , CREATE DATABASE , CREATE RUBLE , CREATE,REATIGIN DISK, CREATE, CREATE , , , ՆԿԱՏԵԼ ԼՐԱԴՐՎԱԾԸ , ԱՆՑՆԵԼ ԿԱՐԳԸ , ԿԱՌՆԱՑՆԵԼ ԿԱՆՈՆԸ , ՆԿԱՏԵԼ ԿԱՆՈՆԸ , ՆԿԱՏԵԼ ԴԻՏՈՒՄԸ , ՎԵՐԱԿԱՆԳՆԵԼ ՏՎՅԱԼՆԵՐԻ ԲԱԶԱՆ , ՎԵՐԱԿԱՆԳՆԵԼ ՄԱՏԵՆԱԿԸ , ՎԵՐԱԿԱՐԳԱՎՈՐԵԼ , ԹԱՐՄԱՑՆԵԼ ՎԻՃԱԿԱԳՐՈՒԹՅՈՒՆԸ :
Եկեք նայենք պահված ընթացակարգի օրինակին: Եկեք մշակենք պահպանված ընթացակարգ, որը հաշվում և ցուցադրում է գրքերի օրինակների քանակը, որոնք ներկայումս գտնվում են գրադարանում.
ՍՏԵՂԾԵԼ ընթացակարգի հաշվարկ_Ex1
- գրքերի օրինակների քանակի հաշվման կարգը,
-- ներկայումս գրադարանում,
- և ոչ ընթերցողների ձեռքում
Ինչպես
-- սահմանել ժամանակավոր տեղական փոփոխական
Հայտարարել @N int
Ընտրեք @N = count(*) Exemplar-ից, որտեղ Yes_No = "1"
Ընտրեք @N
ԳՆԱՑԵՔ
Քանի որ պահված ընթացակարգը տվյալների բազայի ամբողջական բաղադրիչ է, ինչպես արդեն հասկացաք, կարող եք նոր ընթացակարգ ստեղծել միայն ընթացիկ տվյալների բազայի համար: SQL Server Query Analyzer-ում աշխատելիս ընթացիկ տվյալների բազայի կարգավորումը կատարվում է Use դրույթով, որին հաջորդում է տվյալների բազայի անվանումը, որտեղ պետք է ստեղծվի պահպանված ընթացակարգը: Դուք կարող եք նաև ընտրել ընթացիկ տվյալների բազան՝ օգտագործելով բացվող ցուցակը:
Համակարգում պահպանված ընթացակարգ ստեղծելուց հետո SQL Server-ը կազմում է այն և վավերացնում է իր կողմից գործարկվող ենթածրագրերը: Եթե որևէ խնդիր առաջանա, ընթացակարգը մերժվում է: Սխալները պետք է շտկվեն վերահաղորդումից առաջ:
SQL Server 2000-ն օգտագործում է անվանման հետաձգված լուծում, այնպես որ, եթե պահպանված ընթացակարգը պարունակում է զանգ դեպի այլ ընթացակարգ, որը դեռ չի իրականացվել, ցուցադրվում է նախազգուշացում, բայց գոյություն չունեցող ընթացակարգի զանգը պահպանվում է:
Եթե դուք զանգ եք թողնում համակարգում չսահմանված պահված ընթացակարգին, օգտվողը սխալի հաղորդագրություն կստանա, երբ նրանք փորձեն այն կատարել:
Դուք կարող եք նաև ստեղծել պահված ընթացակարգ՝ օգտագործելով SQL Server Enterprise Manager.
Ստեղծված պահպանված ընթացակարգի կատարումը ստուգելու համար հարկավոր է գնալ Query Analyzer և գործարկել օպերատորի կողմից կատարման ընթացակարգը: EXEC<имя процедуры> . Մեր ստեղծած ընթացակարգի գործարկման արդյունքները ներկայացված են նկ. չորս.
Բրինձ. 4. Query Analyzer-ում պահված ընթացակարգի գործարկում
Բրինձ. 5. Առանց ցուցադրման օպերատորի ընթացակարգի կատարման արդյունքը
1.3. Պահպանված ընթացակարգերի ընտրանքներ
Պահպանված ընթացակարգերը շատ են հզոր գործիք, բայց առավելագույն արդյունավետությունկարելի է հասնել միայն դրանք դինամիկ դարձնելով: Մշակողը պետք է կարողանա արժեքներ փոխանցել պահված ընթացակարգին, որի հետ նա կաշխատի, այսինքն՝ պարամետրեր: Ստորև բերված են պահեստավորված ընթացակարգերում պարամետրերի օգտագործման հիմնական սկզբունքները:
- Դուք կարող եք սահմանել մեկ կամ մի քանի պարամետր ընթացակարգի համար:
- Պարամետրերը օգտագործվում են որպես անվանված պահեստավորման վայրեր, ինչպես ծրագրավորման լեզուների փոփոխականները, ինչպիսիք են C, Visual Basic .NET:
- Պարամետրի անվանմանը պետք է նախորդի @ նշանը:
- Պարամետրերի անունները տեղական են այն ընթացակարգի համար, որտեղ դրանք սահմանված են:
- Պարամետրերը օգտագործվում են տեղեկատվություն փոխանցելու ընթացակարգին, երբ այն կատարվում է: Նրանք տարված են հրամանի տողընթացակարգի անվանումից հետո.
- Եթե պրոցեդուրան ունի մի քանի պարամետր, դրանք բաժանվում են ստորակետերով:
- Որպես պարամետր փոխանցված տեղեկատվության տեսակը որոշելու համար օգտագործվում են համակարգի կամ օգտագործողի կողմից սահմանված տվյալների տեսակները:
Հետևյալը ցույց է տալիս ընթացակարգի սահմանումը, որն ունի մեկ մուտքային պարամետր: Եկեք փոխենք նախորդ առաջադրանքը և կհաշվենք ոչ բոլոր գրքերի օրինակները, այլ միայն որոշակի գրքի օրինակները։ Գրքերը եզակիորեն նույնականացվում են եզակի ISBN-ով, ուստի մենք այս պարամետրը կփոխանցենք ընթացակարգին: Այս դեպքում պահպանված ընթացակարգի տեքստը կփոխվի և կունենա հետևյալ տեսքը.
Ստեղծել ընթացակարգի Count_Ex(@ISBN varchar(14))
Ինչպես
Հայտարարել @N int
Ընտրեք @N
ԳՆԱՑԵՔ
Կատարման այս ընթացակարգը սկսելիս մենք պետք է դրան փոխանցենք մուտքային պարամետրի արժեքը (նկ. 6):
Բրինձ. 6. Պարամետրերի անցումով ընթացակարգ սկսելը
Միևնույն պրոցեդուրաների մի քանի տարբերակներ ստեղծելու համար, որոնք ունեն նույն անունը, հետևեք հիմնական անվանը կետ-ստորակետով և ամբողջ թվով: Ինչպես դա անել, ցույց է տրված հետևյալ օրինակում, որը նկարագրում է երկու պրոցեդուրաների ստեղծումը նույն անունով, բայց տարբեր տարբերակների համարներով (1 և 2): Թիվն օգտագործվում է այս ընթացակարգի կատարվող տարբերակը վերահսկելու համար: Եթե տարբերակի համարը նշված չէ, ապա կատարվում է ընթացակարգի առաջին տարբերակը: Այս տարբերակը ցուցադրված չէ նախորդ օրինակում, բայց այն, այնուամենայնիվ, հասանելի է ձեր հավելվածի համար:
Երկու ընթացակարգերն էլ օգտագործում են տպագիր հայտարարությունը՝ տարբերակը նույնականացնող հաղորդագրություն տպելու համար: Առաջին տարբերակը հաշվում է անվճար օրինակների քանակը, իսկ երկրորդը` տվյալ գրքի համար ձեռքի տակ եղած օրինակների քանակը:
Ընթացակարգերի երկու տարբերակների տեքստը տրված է ստորև.
CREATE Procedure Count_Ex_all; մեկ
(@ISBNvarchar(14))
-- Տվյալ գրքի անվճար օրինակների հաշվման կարգը
Ինչպես
Հայտարարել @N int
Ընտրեք @N = count(*) Exemplar-ից, որտեղ ISBN = @ISBN և Yes_No = "1"
Ընտրեք @N
--
ԳՆԱՑԵՔ
--
CREATE Procedure Count_Ex_all; 2
(@ISBNvarchar(14))
-- Տվյալ գրքի անվճար օրինակների հաշվման կարգը
Ինչպես
Հայտարարել @N1 int
Ընտրեք @N1 = count(*) Exemplar-ից, որտեղ ISBN = @ISBN և Yes_No = «0»
Ընտրեք@N1
ԳՆԱՑԵՔ
Տարբեր տարբերակներով ընթացակարգի կատարման արդյունքները ներկայացված են նկ. 7.
Բրինձ. 7. Գործարկել արդյունքները տարբեր տարբերակներնույն պահված ընթացակարգը
Բազմաթիվ տարբերակներ գրելիս նկատի ունեցեք հետևյալ սահմանափակումները. Քանի որ ընթացակարգի բոլոր տարբերակները կազմված են միասին, բոլոր տեղական փոփոխականները համարվում են հանրային: Ուստի, եթե դա պահանջում է մշակման ալգորիթմը, ապա անհրաժեշտ է օգտագործել ներքին փոփոխականների տարբեր անվանումներ, ինչը մենք արեցինք՝ երկրորդ պրոցեդուրաում @N փոփոխականն անվանելով @N1 անունով։
Մեր գրած պրոցեդուրաները ոչ մի պարամետր չեն վերադարձնում, ուղղակի էկրանին ցուցադրում են ստացված թիվը։ Այնուամենայնիվ, ամենից հաճախ մենք պետք է ստանանք պարամետր հետագա մշակման համար: Պահված ընթացակարգից պարամետրերը վերադարձնելու մի քանի եղանակ կա: Ամենապարզը վերադարձի օպերատորի օգտագործումն է RETURN: Այս օպերատորը կվերադարձնի մեկ թվային արժեք: Բայց մենք պետք է նշենք փոփոխականի անունը կամ արտահայտությունը, որը վերագրված է վերադարձի պարամետրին: Հետևյալ արժեքներն են, որոնք վերադարձվում են RETURN հայտարարությամբ, որոնք վերապահված են համակարգի կողմից.
| Կոդը | Իմաստը |
| 0 | Ամեն ինչ լավ է |
| 1 | Օբյեկտը չի գտնվել |
| 2 | Տվյալների տեսակի սխալ |
| 3 | Գործընթացը դարձավ «փակուղու» զոհ. |
| 4 | մուտքի սխալ |
| 5 | Շարահյուսական սխալ է |
| 6 | Որոշ սխալ |
| 7 | Սխալ ռեսուրսների հետ (տեղ չկա) |
| 8 | Տեղի է ունեցել վերականգնվող ներքին սխալ |
| 9 | Համակարգի սահմանաչափը հասել է |
| 10 | Ներքին ամբողջականության անվերականգնելի խախտում |
| 11 | Նույնը |
| 12 | Աղյուսակի կամ ինդեքսի ոչնչացում |
| 13 | Տվյալների բազայի ոչնչացում |
| 14 | Սարքավորման սխալ |
Այսպիսով, համակարգին չհակասելու համար այս պարամետրով կարող ենք վերադարձնել միայն դրական ամբողջ թվեր։
Օրինակ, մենք կարող ենք փոխել նախկինում գրված Count_ex պահպանված ընթացակարգի տեքստը հետևյալ կերպ.
Ստեղծել ընթացակարգի Count_Ex2(@ISBN varchar(14))
Ինչպես
Հայտարարել @N int
Օրինակից ընտրեք @N = count(*):
Որտեղ ISBN = @ISBN և YES_NO = «1»
- վերադարձնել @N փոփոխականի արժեքը,
- եթե փոփոխականի արժեքը սահմանված չէ, վերադարձրեք 0
Return Coalesce (@N, 0)
ԳՆԱՑԵՔ
Այժմ մենք կարող ենք ստանալ @N փոփոխականի արժեքը և օգտագործել այն հետագա մշակման համար։ Այս դեպքում վերադարձի արժեքը վերագրվում է հենց պահված ընթացակարգին, և այն վերլուծելու համար կարող եք օգտագործել պահպանված ընթացակարգի կանչի հայտարարության հետևյալ ձևաչափը.
Գործադիր<переменная> = <имя_процедуры> <значение_входных_параметров>
Մեր ընթացակարգը կանչելու օրինակը ներկայացված է Նկ. ութ.
Բրինձ. 8. Պահված ընթացակարգի վերադարձի արժեքի փոխանցում տեղական փոփոխականին
Պահված ընթացակարգի մուտքագրման պարամետրերը կարող են օգտագործել լռելյայն արժեքը: Այս արժեքը կօգտագործվի, եթե ընթացակարգը կանչելիս պարամետրի արժեքը նշված չէ:
Լռելյայն արժեքը սահմանվում է հավասար նշանի միջոցով մուտքային պարամետրի և դրա տեսակի նկարագրությունից հետո: Դիտարկենք պահպանված ընթացակարգը, որը հաշվում է գրքերի տպաքանակը տվյալ տարվա ընթացքում: Նախնական թողարկման տարին 2006 թվականն է:
ՍՏԵՂԾԵԼ ԸՆԹԱՑՔԸ ex_books_now (@year int = 2006)
-- հաշվելով հրատարակման տվյալ տարվա գրքերի տպաքանակը
ԱՍ
Հայտարարել @N_books int
ընտրել @N_books = count(*) գրքերից, օրինակ
որտեղ Books.ISBN = exemplar.ISBN և YEARIZD = @տարի
վերադարձի միավորում (@N_books, 0)
ԳՆԱՑԵՔ
Նկ. 9-ը ցույց է տալիս այս պրոցեդուրան կանչելու օրինակ՝ մուտքային պարամետրով և առանց դրա:
Բրինձ. 9. Պահված ընթացակարգի կանչում պարամետրով և առանց պարամետրով
Պահված ընթացակարգերում պարամետրեր օգտագործելու վերը նշված բոլոր օրինակները ներառում են միայն մուտքային պարամետրեր: Այնուամենայնիվ, պարամետրերը կարող են նաև ելք լինել: Սա նշանակում է, որ պարամետրի արժեքը ընթացակարգի ավարտից հետո կփոխանցվի նրան, ով զանգահարել է այս ընթացակարգը (այլ ընթացակարգ, ձգան, հրամանի փաթեթ և այլն): Բնականաբար, ելքային պարամետր ստանալու համար կանչելիս պետք է որպես փաստացի պարամետր նշել ոչ թե հաստատուն, այլ փոփոխական։
Նկատի ունեցեք, որ ընթացակարգում ելքային պարամետրը նշելը ձեզ չի պարտավորեցնում օգտագործել այն որպես այդպիսին: Այսինքն, եթե որպես փաստացի պարամետր նշեք հաստատուն, ապա սխալ չի առաջանա և այն կօգտագործվի որպես սովորական մուտքային պարամետր:
OUTPUT հայտարարությունը օգտագործվում է նշելու, որ պարամետրը ելք է: Այս բանալի բառը գրված է պարամետրի նկարագրությունից հետո: Պահպանված ընթացակարգերի պարամետրերը նկարագրելիս ցանկալի է մուտքային պարամետրերից հետո սահմանել ելքային պարամետրերի արժեքները:
Դիտարկենք ելքային պարամետրերի օգտագործման օրինակ: Եկեք գրենք պահպանված ընթացակարգ, որը տվյալ գրքի համար հաշվում է գրադարանում նրա օրինակների ընդհանուր թիվը և անվճար օրինակների քանակը: Մենք չենք կարող այստեղ օգտագործել RETURN վերադարձի հայտարարությունը, քանի որ այն վերադարձնում է միայն մեկ արժեք, ուստի մենք պետք է այստեղ սահմանենք ելքային պարամետրերը: Պահպանված ընթացակարգի մարմինը կարող է այսպիսի տեսք ունենալ.
ՍՏԵՂԾԵԼ ընթացակարգ Count_books_all
(@ISBN varchar(14), @all int output, @free int output)
-- Տվյալ գրքի ընդհանուր օրինակների հաշվման կարգը
-- և անվճար պատճենների քանակը
Ինչպես
-- հաշվելով օրինակների ընդհանուր թիվը
Ընտրեք @all = count(*) Exemplar-ից, որտեղ ISBN = @ISBN
Ընտրեք @free = count(*) Exemplar-ից, որտեղ ISBN = @ISBN և Yes_No = «1»
ԳՆԱՑԵՔ
Այս ընթացակարգի օրինակը ներկայացված է նկ. տասը.
Բրինձ. 10. Պահված ընթացակարգի փորձարկում ելքային պարամետրերով
Ինչպես նշվեց ավելի վաղ, վերլուծության համար ելքային պարամետրերի արժեքները ստանալու համար մենք պետք է դրանք սահմանենք փոփոխականների վրա, և այդ փոփոխականները պետք է նկարագրվեն Declare հայտարարությամբ: Վերջին ելքային հայտարարությունը մեզ թույլ տվեց պարզապես տպել ստացված արժեքները էկրանին:
Ընթացակարգի պարամետրերը կարող են նույնիսկ լինել կուրսորի փոփոխականներ: Դա անելու համար փոփոխականը պետք է հայտարարվի որպես հատուկ տվյալների տեսակ VARYING, առանց կապվելու ստանդարտ համակարգի տվյալների տեսակների: Բացի այդ, պետք է նշել, որ սա Cursor տիպի փոփոխական է:
Եկեք գրենք մի պարզ ընթացակարգ, որը ցույց կտա մեր գրադարանի գրքերի ցանկը: Այս դեպքում, եթե երեքից ավելի գրքեր չկան, ապա մենք ցուցադրում ենք դրանց անունները հենց ընթացակարգի շրջանակներում, իսկ եթե գրքերի ցանկը գերազանցում է նշված թիվը, ապա դրանք որպես կուրսոր փոխանցում ենք կանչող ծրագրին կամ մոդուլին:
Ընթացակարգի տեքստն ունի հետևյալ տեսքը.
ՍՏԵՂԾԵԼ ԸՆԹԱՑՔԸ GET3TITLES
(@MYCURSOR CURSOR VARYING OUTPUT)
-- Գրքերի վերնագրերը կուրսորով տպելու կարգը
ԱՍ
- ընթացակարգում սահմանեք Cursor տեսակի տեղական փոփոխական
SET @MYCURSOR = CURSOR
ԸՆՏՐԵԼ ՀԱՍՏԱՏՎԱԾ ԱՆՎԱՆԳԻ ՀԱՄԱՐ
ԳՐՔԵՐԻՑ
-- բաց կուրսորը
ԲԱՑ @MYCURSOR-ը
-- հայտարարել ներքին տեղական փոփոխականները
ՀԱՅՏԱՐԱՐԵԼ @TITLE VARCHAR(80), @CNT INT
--- սահմանել գրքի հաշվիչի սկզբնական վիճակը
SET@CNT=0
-- ցատկել կուրսորի առաջին տող
- քանի դեռ կան կուրսորային գծեր,
-- այսինքն, մինչ նոր տողը վավեր է
WHILE (@@FETCH_STATUS = 0) ԵՎ (@CNT<= 2) BEGIN
ՏՊԵՔ @TITLE
ԲԵՐԵԼ ՀԱՋՈՐԴԸ @MYCURSOR-ԻՑ @TITLE
-- փոխել գրքի հաշվիչի վիճակը
SET @CNT = @CNT + 1
ՎԵՐՋ
ԵԹԵ @CNT = 0 ՏՊԵՔ «ՀԱՄԱՍՏԱՆ ԳՐՔԵՐ ՉԿԱ»
ԳՆԱՑԵՔ
Այս պահված պրոցեդուրան կանչելու օրինակ ցույց է տրված նկ. տասնմեկ.
Կանչման ընթացակարգում կուրսորը պետք է հայտարարվի որպես տեղական փոփոխական: Այնուհետև մենք կանչեցինք մեր պրոցեդուրան և այն փոխանցեցինք Cursor տեսակի տեղական փոփոխականի անուն: Ընթացակարգը սկսեց աշխատել և ցուցադրեց առաջին երեք անունները էկրանին, այնուհետև կառավարումը փոխանցեց զանգի ընթացակարգին, և այն շարունակեց մշակել կուրսորը: Դա անելու համար նա կազմակերպեց ցիկլ @@FETCH_STATUS գլոբալ փոփոխականի վրա, որը հետևում է կուրսորի վիճակին, այնուհետև ցուցադրում է կուրսորի մնացած բոլոր տողերը օղակում:
Ելքային պատուհանում մենք տեսնում ենք մեծացված տարածություն առաջին երեք տողերի և հաջորդ վերնագրերի միջև: Այս ընդմիջումը պարզապես ցույց է տալիս, որ վերահսկողությունը փոխանցվել է արտաքին ծրագրի:
Նկատի ունեցեք, որ @TITLE փոփոխականը, լինելով պրոցեդուրաների տեղական, կկործանվի, երբ պրոցեդուրան ավարտվի, ուստի այն կրկին հայտարարվում է ընթացակարգը կանչող բլոկում: Այս օրինակում կուրսորի ստեղծումը և բացումը տեղի է ունենում ընթացակարգով, իսկ փակումը, ոչնչացումը և լրացուցիչ մշակումը կատարվում են հրամանի բլոկում, որտեղ կոչվում է ընթացակարգը:
Ընթացակարգի տեքստը դիտելու, այն փոխելու կամ ջնջելու ամենադյուրին ճանապարհը Enterprise Manager GUI-ի միջոցով: Բայց դուք կարող եք դա անել նաև՝ օգտագործելով Transact-SQL համակարգի պահպանված հատուկ ընթացակարգերը: Transact-SQL-ում ընթացակարգի սահմանումը դիտելը կատարվում է sp_helptext համակարգի ընթացակարգի միջոցով, իսկ sp_help համակարգի պրոցեդուրան թույլ է տալիս ցուցադրել ընթացակարգի վերաբերյալ հսկիչ տեղեկատվություն: Sp_helptext և sp_help համակարգի ընթացակարգերը նույնպես օգտագործվում են տվյալների բազայի օբյեկտները, ինչպիսիք են աղյուսակները, կանոնները և լռելյայն կարգավորումները դիտելու համար:
Անմիջապես ցուցադրվում է մեկ ընթացակարգի բոլոր տարբերակների մասին տեղեկատվությունը, անկախ թվից: Միևնույն պահված ընթացակարգի տարբեր տարբերակների ջնջումը նույնպես տեղի է ունենում միաժամանակ: Հետևյալ օրինակը ցույց է տալիս Count_Ex_all պրոցեդուրի 1-ին և 2-րդ տարբերակի սահմանումները, երբ դրա անունը նշված է որպես sp_helptext համակարգի ընթացակարգի պարամետր (Նկար 12):
Բրինձ. 12. Պահված ընթացակարգի տեքստի դիտում` օգտագործելով համակարգային պահպանված ընթացակարգը
SP_HELP համակարգի ընթացակարգը ցուցադրում է ստեղծված ընթացակարգի բնութագրերը և պարամետրերը հետևյալ ձևով.
|
Created_datetime | |||||
|
2006-12-06 23:15:01.217 | |||||
|
Սանդղակ | Param_order Collation | ||||
|
ԴԱՏԱՐԿ | 1 | Cyrillic_General_CI_AS | |||
|
0 | 2 | ԴԱՏԱՐԿ | |||
|
0 | 3 | ԴԱՏԱՐԿ | |||
Փորձեք ինքներդ վերծանել այս պարամետրերը: Ինչ են նրանք խոսում?
1.4. Պահված ընթացակարգի կազմում
Transact-SQL հայտարարությունների հավաքածուն իրականացնելու համար պահված ընթացակարգերի օգտագործման առավելությունն այն է, որ դրանք կազմվում են առաջին անգամ գործարկվելիս: Կազմման ընթացքում Transact-SQL հայտարարությունները փոխակերպվում են իրենց սկզբնական նիշերի ներկայացումից իրենց գործարկվող ձևի: Ընթացակարգում նշված ցանկացած օբյեկտ նույնպես փոխարկվում է այլընտրանքային ներկայացման: Օրինակ, աղյուսակների անունները փոխարկվում են օբյեկտների ID-ների, իսկ սյունակների անվանումները՝ սյունակների ID-ների:
Կատարման պլանը ստեղծվում է ճիշտ այնպես, ինչպես մեկ Transact-SQL հայտարարությունը կատարելու համար: Այս պլանը պարունակում է, օրինակ, ինդեքսներ, որոնք օգտագործվում են աղյուսակների տողերը կարդալու համար, որոնց հասանելի է ընթացակարգը: Ընթացակարգի կատարման պլանը պահվում է քեշում և օգտագործվում է ամեն անգամ, երբ այն կանչվում է:
Նշում. պրոցեդուրաների քեշը կարող է չափվել այնպես, որ պարունակի կատարման համար հասանելի ընթացակարգերի մեծ մասը կամ բոլորը: Սա խնայում է բուժման պլանը վերականգնելու համար անհրաժեշտ ժամանակը:
1.5. Ավտոմատ վերակազմավորում
Սովորաբար, կատարման պլանը գտնվում է ընթացակարգի քեշում: Սա թույլ է տալիս բարձրացնել կատարումը դրա կատարման ընթացքում: Այնուամենայնիվ, որոշակի հանգամանքներում ընթացակարգը ինքնաբերաբար վերակազմավորվում է:
- Ընթացակարգը միշտ վերակոմպիլացվում է SQL Server-ի գործարկման ժամանակ: Սա սովորաբար տեղի է ունենում օպերացիոն համակարգը վերագործարկելուց հետո և առաջին անգամ, երբ ընթացակարգը գործարկվում է ստեղծումից հետո:
- Ընթացակարգի կատարման պլանը միշտ ինքնաբերաբար վերակոմպիլացվում է, եթե ընթացակարգով մուտք գործած աղյուսակի ինդեքսը հանվում է: Քանի որ ընթացիկ պլանը մուտք է գործում ինդեքս, որն այլևս գոյություն չունի աղյուսակի տողերը կարդալու համար, պետք է ստեղծվի նոր կատարման պլան: Ընթացակարգի հարցումները կկատարվեն միայն այն դեպքում, եթե այն թարմացվի:
- Կատարման պլանը նույնպես կազմվում է, եթե մեկ այլ օգտվող ներկայումս աշխատում է քեշավորված պլանի վրա: Երկրորդ օգտագործողի համար ստեղծվում է կատարման պլանի անհատական պատճեն: Եթե պլանի առաջին օրինակը զբաղված չլիներ, երկրորդ օրինակ ստեղծելու կարիք չէր լինի: Երբ օգտատերն ավարտում է ընթացակարգի կատարումը, կատարման պլանը հասանելի է քեշում մեկ այլ օգտագործողի համար՝ համապատասխան մուտքի թույլտվությամբ:
- Ընթացակարգը ավտոմատ կերպով վերակոմպիլացվում է, եթե այն ջնջվի և ստեղծվի: Քանի որ նոր ընթացակարգը կարող է տարբերվել հին տարբերակից, քեշի կատարման պլանի բոլոր պատճենները ջնջվում են, և պլանը նորից կազմվում է:
SQL Server-ը ձգտում է օպտիմալացնել պահպանված ընթացակարգերը՝ քեշավորելով ամենաշատ օգտագործվող ընթացակարգերը: Հետևաբար, քեշում բեռնված հին կատարողական պլանը կարող է օգտագործվել նոր պլանի փոխարեն: Այս խնդիրը կանխելու համար դուք պետք է ջնջեք և նորից ստեղծեք պահված ընթացակարգը կամ դադարեցնեք և նորից ակտիվացնեք SQL Server-ը: Սա կջնջի պրոցեդուրաների քեշը և կվերացնի կատարման հին պլանով աշխատելու հնարավորությունը:
Կարող եք նաև պրոցեդուրա ստեղծել ՎԵՐԱԿՈՄՊԻԼՈՎ տարբերակով։ Այս դեպքում այն ավտոմատ կերպով կվերակազմավորվի ամեն անգամ, երբ այն կատարվի: WITH RECOMPILE տարբերակը պետք է օգտագործվի այն դեպքերում, երբ ընթացակարգը մուտք է գործում շատ դինամիկ աղյուսակներ, որոնց տողերը հաճախ ավելացվում, ջնջվում կամ թարմացվում են, քանի որ դա հանգեցնում է աղյուսակի հատուկ ինդեքսների զգալի փոփոխությունների:
Եթե ընթացակարգերը ինքնաբերաբար չեն վերակոմպիլյացիայի ենթարկվում, կարող եք ստիպել: Օրինակ, եթե վիճակագրությունը, որն օգտագործվում է որոշելու համար, թե արդյոք ինդեքսը կարող է օգտագործվել տվյալ հարցումում, թարմացվում են, կամ եթե ստեղծվում է նոր ինդեքս, պետք է կատարվի հարկադիր վերակազմավորում: Վերակազմավորումը հարկադրելու համար EXECUTE հայտարարությունը օգտագործում է WITH RECOMPILE դրույթը.
EXECUTE procedure_name;
ԱՍ
<инструкции Transact-SQL>
ՎԵՐԱԿԱԶՄԵԼՈՎ
Եթե պրոցեդուրան աշխատում է այն պարամետրերով, որոնք վերահսկում են դրա կատարման հաջորդականությունը, ապա պետք է օգտագործվի ՎԵՐԱԿԱՓՈԽԵԼՈՎ տարբերակը: Եթե պահպանված ընթացակարգի պարամետրերը կարող են որոշել դրա կատարման լավագույն միջոցը, խորհուրդ ենք տալիս աշխատանքի ընթացքում ստեղծել կատարման պլան, այլ ոչ թե ստեղծել այն առաջին անգամ, երբ զանգահարեք ընթացակարգը բոլոր հետագա զանգերի համար օգտագործելու համար:
Ծանոթագրություն. Երբեմն կարող է դժվար լինել որոշել՝ օգտագործել ՎԵՐԱԿՈՄՊԻԼՈՎ տարբերակը պրոցեդուրա ստեղծելիս, թե ոչ: Եթե կասկածներ ունեք, ավելի լավ է չօգտագործել այս տարբերակը, քանի որ ամեն անգամ այն կատարելիս ընթացակարգը վերակազմավորելը կկորցնի շատ արժեքավոր պրոցեսորի ժամանակը: Եթե ապագայում ձեզ անհրաժեշտ է վերակոմպիլյացիա կատարել պահված պրոցեդուրան կատարելիս, կարող եք դա անել՝ EXECUTE քաղվածքում ավելացնելով WITH RECOMPILE կետ:
Դուք չեք կարող օգտագործել «ՎԵՐԿՈՄՊԻԼԻ ՀԵՏ» տարբերակը «ՍՏԵՂԾԵԼ ԸՆԹԱՑՔԻ» հայտարարության մեջ, որը պարունակում է ՀԱՄԱՐ REPLICATION տարբերակ: Այս տարբերակը օգտագործվում է պրոցեդուրա ստեղծելու համար, որն իրականացվում է կրկնօրինակման գործընթացում:
1.6. Պահեստավորված պրոցեդուրաների բնադրում
Պահպանված պրոցեդուրաները կարող են անվանել այլ պահված պրոցեդուրաներ, սակայն կա բույնի մակարդակի սահմանափակում: Բնադրման առավելագույն մակարդակ 32. Ներկայիս բնադրման մակարդակը կարող է որոշվել @@NESTLEVEL գլոբալ փոփոխականի միջոցով:
2. Օգտագործողի կողմից սահմանված գործառույթներ (UDF)
MS SQL SERVER 2000-ն ունի բազմաթիվ նախապես սահմանված գործառույթներ, որոնք թույլ են տալիս կատարել մի շարք գործողություններ: Այնուամենայնիվ, միշտ կարող է լինել որոշակի հատուկ գործառույթներ օգտագործելու անհրաժեշտություն: Դա անելու համար, սկսած 8.0 տարբերակից (2000 թ.), հնարավոր դարձավ նկարագրել օգտատիրոջ կողմից սահմանված գործառույթները (User Defined Functions, UDF) և դրանք պահել որպես տվյալների բազայի ամբողջական օբյեկտ՝ պահպանված ընթացակարգերի, դիտումների և այլնի հետ միասին։
Օգտատիրոջ կողմից սահմանված գործառույթների օգտագործման հարմարավետությունն ակնհայտ է: Ի տարբերություն պահված ընթացակարգերի, գործառույթները կարող են ուղղակիորեն ներկառուցվել SELECT հայտարարության մեջ և օգտագործվել ինչպես որոշակի արժեքներ (SELECT կետում) և այնպես էլ որպես տվյալների աղբյուր (FROM կետում):
UDF-ները որպես տվյալների աղբյուրներ օգտագործելիս, դիտումների նկատմամբ նրանց առավելությունն այն է, որ UDF-ները, ի տարբերություն դիտումների, կարող են ունենալ մուտքային պարամետրեր, որոնք կարող են օգտագործվել ֆունկցիայի արդյունքի վրա ազդելու համար:
Օգտագործողի կողմից սահմանված գործառույթները կարող են լինել երեք տեսակի. սկալյար ֆունկցիաներ, ներկառուցված գործառույթներև մի քանի դրույթով գործառույթներ, որոնք վերադարձնում են աղյուսակային արդյունք. Դիտարկենք այս բոլոր տեսակի գործառույթները ավելի մանրամասն:
2.1. Scalar ֆունկցիաներ
Scalar ֆունկցիաները վերադարձնում են մեկ սկալյար արդյունք: Այս արդյունքը կարող է լինել վերը նկարագրված տեսակներից որևէ մեկը, բացառությամբ տեքստի, ntext, պատկերի և ժամանակի դրոշմակնիքի: Սա ամենապարզ տեսակի գործառույթն է: Դրա շարահյուսությունը հետևյալն է.
RETURNS scalar_data_type
ՍԿՍԵԼ
ֆունկցիա_մարմին
RETURN scalar_expression
ՎԵՐՋ
- ENCRYPTION պարամետրն արդեն նկարագրված է պահվող ընթացակարգերի բաժնում.
- SCHEMABINDING-ը կապում է ֆունկցիան սխեմային: Սա նշանակում է, որ դուք չեք կարողանա հեռացնել աղյուսակները կամ դիտումները, որոնց վրա հիմնված է ֆունկցիան՝ առանց այդ գործառույթը հեռացնելու կամ փոփոխելու: Անհնար է նաև փոխել այս աղյուսակների կառուցվածքը, եթե փոփոխվող մասը օգտագործվում է ֆունկցիայի կողմից։ Այսպիսով, այս տարբերակը թույլ է տալիս բացառել այն իրավիճակները, երբ ֆունկցիան օգտագործում է ցանկացած աղյուսակ կամ դիտում, և ինչ-որ մեկը, առանց դրա մասին իմանալու, ջնջել կամ փոխել է դրանք.
- RETURNS scalar_data_typeնկարագրում է տվյալների տեսակը, որը վերադարձնում է ֆունկցիան.
- scalar_expressionարտահայտություն, որն ուղղակիորեն վերադարձնում է ֆունկցիայի կատարման արդյունքը: Այն պետք է լինի նույն տիպի, ինչ նկարագրված է ՎԵՐԱԴԱՐՁՈՒՄՆԵՐԻՑ հետո.
- function_body-ը Transact-SQL հայտարարությունների մի շարք է:
Դիտարկենք սկալյար ֆունկցիաների օգտագործման օրինակներ:
Ստեղծեք ֆունկցիա, որը կընտրի որպես պարամետրեր տրված երկու ամբողջ թվերից ամենափոքրը:
Թող ֆունկցիան այսպիսի տեսք ունենա.
CREATE FUNCTION min_num (@a INT, @b INT)
RETURNS INT
ՍԿՍԵԼ
ՀԱՅՏԱՐԱՐԵԼ @c INT
Եթե< @b SET @c = @a
ԱՅԼՍ SET @c = @b
ՎԵՐԱԴԱՐՁ @ք
ՎԵՐՋ
Եկեք հիմա կատարենք այս գործառույթը.
SELECT dbo.min_num(4, 7)
Արդյունքում մենք կստանանք 4 արժեքը:
Աղյուսակի սյունակի արժեքներից ամենափոքրը գտնելու համար կարող եք օգտագործել այս ֆունկցիան.
SELECT min_lvl, max_lvl, min_num(min_lvl, max_lvl)
ԱՇԽԱՏԱՆՔՆԵՐԻՑ
Եկեք ստեղծենք ֆունկցիա, որը որպես մուտքագրում կստանա datetime տեսակի պարամետր և կվերադարձնի նշված օրվա սկզբին համապատասխան ամսաթիվը և ժամը։ Օրինակ, եթե մուտքագրման պարամետրը 09/20/03 13:31 է, ապա արդյունքը կլինի 09/20/03 00:00:
ՍՏԵՂԾԵԼ ՖՈՒՆԿՑԻԱ dbo.daybegin (@dat DATETIME)
ՎԵՐԱԴԱՐՁՈՒՄ է smalldatetime AS
ՍԿՍԵԼ
RETURN CONVERT (ամսաթվի ժամը, FLOOR (փոխակերպում (FLOAT, @dat)))
ՎԵՐՋ
Այստեղ CONVERT ֆունկցիան կատարում է տիպի փոխակերպում։ Նախ, ամսաթիվ-ժամային տեսակը փոխանցվում է FLOAT-ին: Այս կրճատմամբ ամբողջ թիվը 1900 թվականի հունվարի 1-ից հաշված օրերի թիվն է, իսկ կոտորակայինը՝ ժամանակը։ Այնուհետև տեղի է ունենում FLOOR ֆունկցիայի միջոցով կլորացում մինչև ավելի փոքր ամբողջ թիվ և փոխանցում ամսաթվի-ժամանակի տիպին:
Եկեք ստուգենք ֆունկցիայի գործողությունը.
SELECT dbo.daybegin(GETDATE())
Այստեղ GETDATE()-ը ֆունկցիա է, որը վերադարձնում է ընթացիկ ամսաթիվը և ժամը:
Նախորդ գործառույթները հաշվարկում օգտագործում էին միայն մուտքային պարամետրեր: Այնուամենայնիվ, դուք կարող եք նաև օգտագործել տվյալների բազայում պահվող տվյալները:
Եկեք ստեղծենք մի ֆունկցիա, որը որպես պարամետր կընդունի երկու ամսաթվեր՝ ժամանակային միջակայքի սկիզբը և ավարտը և հաշվարկենք վաճառքի ընդհանուր եկամուտը այս ընդմիջման համար: Վաճառքի ամսաթիվը և քանակը կվերցվեն Վաճառքի աղյուսակից, իսկ վաճառվող անվանումների գները՝ Վերնագրեր աղյուսակից:
CREATE FUNCTION dbo.SumSales (@datebegin DATETIME, @dateend DATETIME)
ՎԵՐԱԴԱՐՁՈՒՄ Է ՓՈՂ
ԱՍ
ՍԿՍԵԼ
ՀԱՅՏԱՐԱՐԵԼ @Sum Money
SELECT @Sum = գումար (t.price * s.qty)
ՎԵՐԱԴԱՐՁ @Sum
ՎԵՐՋ
2.2. Ներքին գործառույթներ
Այս տեսակի ֆունկցիան արդյունքում վերադարձնում է ոչ թե սկալյար արժեք, այլ աղյուսակ, ավելի ճիշտ՝ տվյալների հավաքածու։ Սա կարող է շատ հարմար լինել այն դեպքերում, երբ նույն տեսակի ենթհարցումը հաճախ կատարվում է տարբեր ընթացակարգերի, գործարկիչների և այլնի մեջ: Այնուհետև այս հարցումն ամենուր գրելու փոխարեն կարող եք ստեղծել ֆունկցիա և օգտագործել այն ապագայում։
Այս տեսակի գործառույթները նույնիսկ ավելի օգտակար են, երբ ցանկանում եք, որ վերադարձված աղյուսակը կախված լինի մուտքային պարամետրերից: Ինչպես գիտեք, դիտումները չեն կարող ունենալ պարամետրեր, ուստի միայն ներկառուցված գործառույթները կարող են լուծել այս տեսակի խնդիրը:
Ներքին գործառույթների առանձնահատկությունն այն է, որ դրանք կարող են պարունակել միայն մեկ հարցում իրենց մարմնում: Այսպիսով, այս տիպի գործառույթները շատ նման են դիտումների, բայց բացի այդ, դրանք կարող են ունենալ մուտքային պարամետրեր: Ներքին ֆունկցիայի շարահյուսությունը հետևյալն է.
CREATE FUNCTION [սեփականատեր.]function_name
([(@parameter_name scalar_data_type [= default_value]) [, n]])
ՎԵՐԱԴԱՐՁՆԵՐԻ ՍԵՂԱՆԱԿ
ՎԵՐԱԴԱՐՁ [(<запрос>)]
Ֆունկցիայի սահմանումը սահմանում է, որ այն կվերադարձնի աղյուսակ;<запрос>սա այն խնդրանքն է, որի արդյունքը կլինի ֆունկցիայի արդյունքը։
Եկեք գրենք մի ֆունկցիա, որը նման է վերջին օրինակի սկալարի ֆունկցիային, բայց վերադարձնելով ոչ միայն ընդհանուր արդյունքը, այլև վաճառքի տողերը՝ ներառյալ վաճառքի ամսաթիվը, գրքի անվանումը, գինը, կտորների քանակը և վաճառքի գումարը: Պետք է ընտրվեն միայն այն վաճառքները, որոնք ընկնում են նշված ժամանակահատվածում: Եկեք գաղտնագրենք գործառույթի տեքստը, որպեսզի այլ օգտվողներ կարողանան օգտագործել այն, բայց չկարողանան կարդալ և ուղղել այն.
CREATE FUNCTION Sales_Period (@datebegin DATETIME, @dateend DATETIME)
ՎԵՐԱԴԱՐՁՆԵՐԻ ՍԵՂԱՆԱԿ
ԿՈՂԾԱԳՐՈՎ
ԱՍ
ՎԵՐԱԴԱՐՁ (
SELECT t.title, t.price, s.qty, ord_date, t.price * s.qty as stoim
Վերնագրերից t ՄԻԱՑԵՔ Վաճառքները ON t.title_Id = s.Title_ID
ՈՐՏԵՂ ord_date-ը @datebegin-ի և @dateend-ի միջև
)
Հիմա եկեք անվանենք այս գործառույթը: Ինչպես արդեն նշվեց, այն կարող է կանչվել միայն SELECT հայտարարության FROM կետում.
SELECT * FROM Sales_Period ("09/01/94", "09/13/94")
2.3. Բազմաթիվ ֆունկցիաներ, որոնք վերադարձնում են աղյուսակային արդյունք
Դիտարկված ֆունկցիայի առաջին տեսակը թույլ էր տալիս կամայականորեն մեծ թվով Transact-SQL հայտարարությունների օգտագործումը, բայց վերադարձրեց միայն սկալային արդյունք: Ֆունկցիայի երկրորդ տեսակը կարող է վերադարձնել աղյուսակներ, բայց դրա մարմինը ներկայացնում է միայն մեկ հարցում: Multi-statement ֆունկցիաները, որոնք վերադարձնում են աղյուսակի արդյունքը, թույլ են տալիս համատեղել առաջին երկու ֆունկցիաների հատկությունները, այսինքն՝ դրանք կարող են պարունակել բազմաթիվ Transact-SQL հայտարարություններ մարմնում և արդյունքում վերադարձնել աղյուսակ: Բազմակի դրույթներով ֆունկցիայի շարահյուսությունը հետևյալն է.
CREATE FUNCTION [սեփականատեր.]function_name
([(@parameter_name scalar_data_type [= default_value]) [,... n]])
ՎԵՐԱԴԱՐՁՈՒՄ Է @result_variable_name ԱՂՅՈՒՍԱԿԸ
<описание_таблицы>
ՍԿՍԵԼ
<тело_функции>
ՎԵՐԱԴԱՐՁ
ՎԵՐՋ
- ՍԵՂԱՆԱԿ<описание_таблицы> նկարագրում է վերադարձված աղյուսակի կառուցվածքը.
- <описание_таблицы> պարունակում է սյունակների և սահմանափակումների թվարկում:
Հիմա եկեք նայենք մի օրինակի, որը հնարավոր է անել միայն այս տեսակի գործառույթներով:
Թող նրանց մեջ ընկած լինի դիրեկտորիաների և ֆայլերի ծառ: Թող այս ամբողջ կառուցվածքը նկարագրվի տվյալների բազայում աղյուսակների տեսքով (նկ. 13): Փաստորեն, այստեղ մենք ունենք դիրեկտորիաների հիերարխիկ կառուցվածք, ուստի դիագրամը ցույց է տալիս Folders աղյուսակի հարաբերությունն իր հետ:
Բրինձ. 13. Ֆայլերի և գրացուցակների հիերարխիան նկարագրելու համար տվյալների բազայի կառուցվածքը
Հիմա եկեք գրենք մի ֆունկցիա, որը կվերցնի գրացուցակի ID-ն որպես մուտքագրում և դուրս կբերի բոլոր ֆայլերը, որոնք պահվում են դրանում և հիերարխիայի տակ գտնվող բոլոր դիրեկտորիաներում: Օրինակ, եթե դիրեկտորիաները Faculty1, Faculty2 և այլն ստեղծվում են Ինստիտուտի գրացուցակում, դրանք պարունակում են բաժինների դիրեկտորիաներ, և դիրեկտորիաներից յուրաքանչյուրը պարունակում է ֆայլեր, ապա երբ որպես մեր ֆունկցիայի պարամետր նշում ենք ինստիտուտի գրացուցակի նույնացուցիչը, ցուցակը: բոլոր ֆայլերը այս բոլոր դիրեկտորիաների համար: Յուրաքանչյուր ֆայլի համար պետք է ցուցադրվի անունը, չափը և ստեղծման ամսաթիվը:
Անհնար է լուծել խնդիրը՝ օգտագործելով inline ֆունկցիա, քանի որ SQL-ը նախատեսված չէ հիերարխիկ հարցումներ կատարելու համար, ուստի մեկ SQL հարցումն այստեղ բավարար չէ։ Scalar ֆունկցիան նույնպես չի կարող օգտագործվել, քանի որ արդյունքը պետք է լինի աղյուսակ: Այստեղ մեզ օգնության կգա մի քանի օպերատորի ֆունկցիա, որը վերադարձնում է աղյուսակը.
ՍՏԵՂԾԵԼ ՖՈՒՆԿՑԻԱ dbo.GetFiles(@Folder_ID int)
RETURNS @files TABLE (Անուն VARCHAR(100), Date_Create DATETIME, FileSize INT) AS
ՍԿՍԵԼ
ՀԱՅՏԱՐԱՐԵԼ @tmp TABLE (Folder_Id int)
ՀԱՅՏԱՐԱՐԵԼ @Cnt INT
INSERT INTO @tmp արժեքների մեջ (@Folder_ID)
SET @Cnt = 1
Մինչդեռ @Cnt<>0 ՍԿՍԵԼ
INSERT INTO @tmp SELECT Folder_Id
FROM Թղթապանակներից f JOIN @tmp t ON f.parent=t.Folder_ID
WHERE F.id NOT IN (SELECT Folder_ID FROM @tmp)
SET @Cnt = @@ROWCOUNT
ՎԵՐՋ
INSERT INTO @Files (Անուն, ամսաթիվ_Ստեղծման, Ֆայլի չափ)
SELECT F.Name, F.Date_Create, F.FileSize
FROM Ֆայլերից f JOIN Թղթապանակներ Fl on f.Folder_id = Fl.id
ՄԻԱՑԵՔ @tmp t Fl.id = t.Folder_Id-ում
ՎԵՐԱԴԱՐՁ
ՎԵՐՋ
Այստեղ, մի օղակում, բոլոր nested դիրեկտորիաները բոլոր nesting մակարդակներում ավելացվում են @tmp փոփոխականին այնքան ժամանակ, մինչև այլևս չմնան nested դիրեկտորիաներ: @Files արդյունք փոփոխականն այնուհետև սահմանվում է @tmp փոփոխականում թվարկված դիրեկտորիաներում տեղակայված ֆայլերի բոլոր անհրաժեշտ հատկանիշներին:
Անկախ աշխատանքի առաջադրանքներ
Դուք պետք է ստեղծեք և կարգաբերեք հինգ պահված ընթացակարգեր հետևյալ պարտադիր ցանկից.
Ընթացակարգ 1. Երկարացնել գրքի պատճենների վերջնաժամկետը մեկ շաբաթով, եթե ընթացիկ ժամկետը գտնվում է ընթացիկ ամսաթվից երեք օր առաջ և ընթացիկ ամսաթվից երեք օր հետո:
Ընթացակարգ 2. Հաշվել տրված գրքի անվճար օրինակների քանակը:
Ընթացակարգ 3. Տվյալ ազգանունով և ծննդյան տարեթիվով ընթերցողի առկայության ստուգում.
Ընթացակարգ 4. Նոր ընթերցող մուտքագրում, տվյալների բազայում դրա առկայության ստուգում և գրադարանի նոր քարտի համարի որոշումը:
Ընթացակարգ 5. Պարտապան ընթերցողների համար տուգանքի հաշվարկը դրամական արտահայտությամբ.
Ընթացակարգերի համառոտ նկարագրությունը
Ընթացակարգ 1. Գրքերի ժամկետի երկարացում
Exemplar աղյուսակի յուրաքանչյուր գրառման համար ստուգվում է, թե արդյոք գրքի վերջնաժամկետը համապատասխանում է նշված ժամանակային միջակայքին: Եթե այդպես է, ապա գրքի վերադարձի ժամկետը մեկ շաբաթով ավելանում է։ Ընթացակարգը կատարելիս դուք պետք է օգտագործեք ամսաթվերի հետ աշխատելու գործառույթը.
Ամսաթիվ Ավելացնել (օր,<число добавляемых дней>, <начальная дата>)
Ընթացակարգ 2. Տրված գրքի անվճար օրինակների քանակի հաշվում
Ընթացակարգի մուտքագրման պարամետրը ISBN գրքի եզակի ծածկագիրն է: Ընթացակարգը վերադարձնում է 0 (զրո), եթե այս գրքի բոլոր օրինակները գտնվում են ընթերցողների ձեռքում: Ընթացակարգը վերադարձնում է N արժեքը, որը հավասար է գրքի այն օրինակների քանակին, որոնք ներկայումս գտնվում են ընթերցողների ձեռքում:
Եթե գրադարանում տվյալ ISBN-ով գիրք չկա, ապա պրոցեդուրան վերադարձնում է 100 (մինուս հարյուր):
Ընթացակարգ 3. Տվյալ ազգանունով և ծննդյան տարեթիվով ընթերցողի առկայության ստուգում
Ընթացակարգը վերադարձնում է գրադարանի քարտի համարը, եթե այդպիսի տվյալներ ունեցող ընթերցող կա, իսկ հակառակ դեպքում՝ 0 (զրո):
Ծննդյան ամսաթիվը համեմատելիս պետք է օգտագործեք Convert() փոխակերպման ֆունկցիան՝ ծննդյան ամսաթիվը, Varchar(8) տիպի նիշերի փոփոխական, որն օգտագործվում է որպես ընթացակարգի մուտքային պարամետր, տվյալների ժամանակի տիպի տվյալների փոխակերպելու համար, որն օգտագործվում է: Ընթերցողների աղյուսակը: Հակառակ դեպքում, այս ընթերցողի որոնման ժամանակ համեմատության գործողությունը չի հաջողվի:
Ընթացակարգ 4. Նոր ընթերցող մուտքագրում
Ընթացակարգն ունի հինգ մուտքային և երեք ելքային պարամետր:
Մուտքային պարամետրեր.
- Ամբողջական անունը սկզբնատառերով;
- Հասցե;
- Ծննդյան ամսաթիվ;
- Տնային հեռախոս;
- Հեռախոսն աշխատում է։
Ելքային պարամետրեր.
- Գրադարանի քարտի համարը;
- Նշան, թե արդյոք ընթերցողը նախկինում գրանցված է եղել գրադարանում (0՝ ոչ, 1՝);
- Գրքերի թիվը, որը նշված է ընթերցողի համար:
Ընթացակարգ 5. Պարտապան ընթերցողների համար տուգանքի հաշվարկը դրամական արտահայտությամբ
Ընթացակարգն աշխատում է կուրսորով, որը պարունակում է բոլոր պարտապանների գրադարանային քարտերի համարների ցանկը: Աշխատանքի ընթացքում պետք է ստեղծվի ##DOLG գլոբալ ժամանակավոր աղյուսակ, որում յուրաքանչյուր պարտապանի համար կմուտքագրվի նրա ընդհանուր պարտքը դրամական արտահայտությամբ բոլոր այն գրքերի համար, որոնք նա պահում է վերադարձման ժամկետից ավելի երկար։ Կանխիկ փոխհատուցումը հաշվարկվում է գրքի արժեքի 0,5%-ի չափով՝ ուշացման օրվա համար:
Աշխատանքային կարգը
- տվյալների բազաներում կատարված փոփոխությունները հաստատող էկրանների (սքրինշոթերի) պատճենները.
- տվյալների բազայի աղյուսակների բովանդակությունը, որն անհրաժեշտ է ճիշտ աշխատանքը հաստատելու համար.
- պահպանված ընթացակարգի տեքստը մեկնաբանություններով;
- աշխատանքի արդյունքների արդյունքով պահեստավորված ընթացակարգի վարման գործընթացը:
Լրացուցիչ առաջադրանքներ
Հետևյալ լրացուցիչ պահպանվող ընթացակարգերը նախատեսված են անհատական աշխատանքների համար:
Ընթացակարգ 6. Տվյալ առարկայի վերաբերյալ գրքերի քանակի հաշվում, որոնք ներկայումս առկա են գրադարանում առնվազն մեկ օրինակով: Թեմայի տարածքը փոխանցվում է որպես մուտքային պարամետր:
Ընթացակարգ 7. Մուտքագրեք նոր գիրք՝ դրա օրինակների քանակի նշումով: Նոր գրքի օրինակներ մուտքագրելիս մի մոռացեք մուտքագրել դրանց ճիշտ համարները: Մտածեք, թե ինչպես կարելի է դա անել: Որպես հիշեցում, դուք ունեք Max և Min գործառույթները, որոնք թույլ են տալիս գտնել ցանկացած թվային հատկանիշի առավելագույն կամ նվազագույն արժեքը՝ օգտագործելով Ընտրել հարցումը:
Ընթացակարգ 8. Սեղանի ձևավորում՝ պարտապան ընթերցողների ցուցակով, այսինքն՝ նրանց, ովքեր պետք է գրքերը վերադարձնեին գրադարան, բայց դեռ չեն վերադարձել։ Ստացված աղյուսակում յուրաքանչյուր պարտք ընթերցող պետք է հայտնվի միայն մեկ անգամ, անկախ նրանից, թե որքան գիրք է պարտք: Ստացված աղյուսակում, բացի լրիվ անվանումից և գրադարանի քարտի համարից, պետք է նշվեն հասցեն և հեռախոսահամարը:
Ընթացակարգ 9. Որոնել տվյալ գրքի վերնագրի անվճար օրինակ: Եթե կա ազատ օրինակ, ապա ընթացակարգը վերադարձնում է ատյանի միացման համարը. եթե ոչ, ապա ընթացակարգը վերադարձնում է այս գիրքն ունեցող ընթերցողների ցուցակը՝ նշելով գիրքը վերադարձնելու ամսաթիվը և ընթերցողի հեռախոսահամարը:
Ընթացակարգ 10. Ցուցադրել այն ընթերցողների ցուցակը, ովքեր այս պահին ձեռքում ոչ մի գիրք չեն բռնում: Նշեք ձեր անունը և հեռախոսահամարը:
Ընթացակարգ 11. Գրքերի ցանկի ցուցադրում, որտեղ նշվում է գրադարանում այս գրքի տպաքանակը և տվյալ պահին անվճար տպաքանակը:
տպագիր տարբերակը
Պահպանված ընթացակարգպահեստավորված ընթացակարգ) տվյալների բազայի անվանված ծրագրի օբյեկտ է: SQL Server-ն ունի մի քանի տեսակի պահված ընթացակարգեր:
Համակարգի պահպանված ընթացակարգերհամակարգի պահպանման ընթացակարգը) տրամադրվում են 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-ի CRL (Common Language Runtime) միջավայրում: Այս ձեռնարկում կքննարկվի միայն առաջին մեթոդը:
Պահված ընթացակարգեր ստեղծելու համար օգտագործեք CREATE PROCEDURE հայտարարությունը (կարելի է կրճատվել PROC-ով), որի ձևաչափը տրված է ստորև.
CREATE (PROC I PROCEDURE) proc_name [ ; թիվ]
[(gparameter data_type )
[«լռելյայն] |
[ՀԵՏ
[ԿՐՊԵԿՏՈՐՄԱՆ ՀԱՄԱՐ]
AS ([ BEGIN ] sql_statement [;] [ ...n ] [ՎԵՐՋ ])
Եթե պահպանված պրոցեդուրան (կամ ձգան, ֆունկցիա, դիտում) ստեղծվում է 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 OUTPUT) AS
SET @result=0a+0b
Մենք երեք պարամետրով պրոցեդուրա ենք ստեղծել, որտեղ @b պարամետրը ունի լռելյայն 0, իսկ @result պարամետրը ելքային պարամետր է՝ դրա միջոցով արժեքը վերադարձվում է կանչող ծրագրին։ Կատարված գործողությունները բավականին պարզ են. ելքային պարամետրը ստանում է երկու մուտքերի գումարի արժեքը:
SQL Server Management Studio-ում աշխատելիս ստեղծված պահպանված ընթացակարգը կարելի է գտնել ծրագրավորվող տվյալների բազայի օբյեկտներ բաժնում։ (անգլերեն)Ծրագրավորելիություն) պահվող պրոցեդուրաների բաժնում (Նկար 10.2):
Ընթացակարգ կանչելիս և՛ փոփոխականները, և՛ հաստատունները կարող են օգտագործվել որպես մուտքային պարամետրեր: Դիտարկենք երկու օրինակ։ Առաջինում պրոցեդուրի մուտքային պարամետրերը բացահայտորեն սահմանված են հաստատուններով, զանգի ելքային պարամետրի համար նշվում է OUTPUT հիմնաբառը: Երկրորդ տարբերակում փոփոխականի արժեքը օգտագործվում է որպես առաջին մուտքային պարամետր, իսկ երկրորդ պարամետրը նշվում է օգտագործելով DEFAULT բանալի բառը, որը պետք է օգտագործվի լռելյայն արժեքը.
Բրինձ. 10.2.
ՀԱՅՏԱՐԱՐԵԼ @with int;
EXEC ամփոփում 10,5,@c OUTPUT;
PRINT0c; - կցուցադրվի 15
ՀԱՅՏԱՐԱՐԵԼ Gi int = 5;
- զանգելիս օգտագործեք լռելյայն արժեքը
EXEC ամփոփում Gi, DEFAULT, 0s OUTPUT;
PRINT0c; - 5-ը կցուցադրվի
Այժմ դիտարկենք վերադարձի կոդի վերլուծության օրինակ, որով ավարտվում է ընթացակարգը: Թող անհրաժեշտ լինի հաշվարկել, թե քանի գիրք է հրատարակվել Bookl աղյուսակում տարիների տվյալ միջակայքում: Այս դեպքում, եթե մեկնարկային տարին ավելի մեծ է, քան ավարտի տարին, ապա ընթացակարգը վերադարձնում է «1» և չի հաշվում, հակառակ դեպքում մենք հաշվում ենք գրքերի քանակը և վերադարձնում 0.
CREATE PROC dbo.rownum (0FirsYear int, GLastYear int, 0result int OUTPUT) AS
ԵԹԵ 0FirsYear>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))
Պահված պրոցեդուրաները կարող են ոչ միայն կարդալ տվյալները աղյուսակից, այլև փոփոխել տվյալները և նույնիսկ ստեղծել աղյուսակներ և տվյալների բազայի մի շարք այլ օբյեկտներ:
Այնուամենայնիվ, սխեմաները, գործառույթները, գործարկիչները, ընթացակարգերը և դիտումները չեն կարող ստեղծվել պահված ընթացակարգից:
Հետևյալ օրինակը ցույց է տալիս ինչպես այս հնարավորությունները, այնպես էլ ժամանակավոր օբյեկտների շրջանակի հետ կապված խնդիրները: Հետևյալ պահված ընթացակարգը ստուգում է ժամանակավոր աղյուսակի առկայությունը #Tab2; եթե այս աղյուսակը գոյություն չունի, այն ստեղծում է այն: Դրանից հետո երկու սյունակների արժեքները մուտքագրվում են #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
Նախքան պահված ընթացակարգի առաջին զանգը, եկեք ստեղծենք դրանում օգտագործվող #Tab2 ժամանակավոր աղյուսակը: Ուշադրություն դարձրեք EXEC օպերատորին: Նախորդ օրինակներում պարամետրերը փոխանցվել են ընթացակարգին «ըստ դիրքի», բայց այս դեպքում օգտագործվում է պարամետրերի փոխանցման այլ ձևաչափ՝ «անվանմամբ», պարամետրի անվանումը և դրա արժեքը հստակորեն նշվում են.
ՍՏԵՂԾԵԼ ԱՂՅՈՒՍԱԿ dbo.#Tab2 (id int, անունը varchar(30));
EXEC My_Procl 0name = "lvan", 0id=2;
SELECT * FROM dbo.#Tab2; -#2
Վերոնշյալ օրինակում SELECT հայտարարությունը կկատարվի երկու անգամ՝ առաջին անգամ՝ ընթացակարգի ներսում, երկրորդ անգամ՝ կանչող կոդի հատվածից (նշված «No. 2» մեկնաբանությամբ):
Մինչև երկրորդ պրոցեդուրաների կանչը, եկեք ջնջենք #Tab2 ժամանակավոր աղյուսակը։ Այնուհետև պահված ընթացակարգից կստեղծվի համանուն ժամանակավոր աղյուսակը.
ԿԱՌՆԵԼ ՍԵՂԱՆԻ dbo.#Tab2;
EXEC My_Procl 0name = "Իվան", 0id=2;
SELECT * FROM dbo.#Tab2; -#2
Այս դեպքում միայն ընթացակարգի ներսում SELECT հայտարարությունը («Xa 1» մեկնաբանությամբ) կցուցադրի տվյալները: SELECT «#2»-ի գործարկումը կհանգեցնի սխալի, քանի որ պահված ընթացակարգում ստեղծված ժամանակավոր աղյուսակն արդեն կջնջվի tempdb տվյալների բազայից, երբ պրոցեդուրան վերադառնա:
Դուք կարող եք թողնել պահպանված ընթացակարգը՝ օգտագործելով DROP PROCEDURE հայտարարությունը: Դրա ձևաչափը ներկայացված է ստորև: Մեկ հայտարարությամբ դուք կարող եք ջնջել մի քանի պահպանված ընթացակարգեր՝ թվարկելով դրանք բաժանված ստորակետերով.
DROP (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 - սահմանել տարբերակ
ԵԹԵ 0FirsYear>0 LastYear RETURN 1 ELSE BEGIN
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 բառացի հաստատուն է, ինչպես պահանջվում է ընթացակարգով: Պարամետրին կարելի է վերագրել ոչ միայն հաստատուն արժեք, այլև մեկ այլ փոփոխականի արժեք:
Վերջին թարմացումը՝ 14.08.2017թ
Հաճախ տվյալների գործողությունը ներկայացնում է հրահանգների մի շարք, որոնք պետք է կատարվեն որոշակի հաջորդականությամբ: Օրինակ, ապրանքի գնումն ավելացնելիս անհրաժեշտ է տվյալներ մուտքագրել պատվերի աղյուսակում: Սակայն մինչ այդ անհրաժեշտ է ստուգել՝ արդյոք գնված ապրանքը պահեստում է։ Թերեւս, այս դեպքում անհրաժեշտ կլինի ստուգել մի շարք լրացուցիչ պայմաններ։ Այսինքն, ըստ էության, ապրանքի գնման գործընթացը ներառում է մի քանի գործողություններ, որոնք պետք է կատարվեն որոշակի հաջորդականությամբ։ Եվ այս դեպքում ավելի օպտիմալ կլինի այս բոլոր գործողությունները մեկ օբյեկտի մեջ ամփոփել. պահված կարգը(պահեստավորված ընթացակարգ):
Այսինքն, ըստ էության, պահպանված ընթացակարգերը հայտարարությունների մի շարք են, որոնք կատարվում են որպես մեկ միավոր: Այսպիսով, պահպանված ընթացակարգերը թույլ են տալիս պարզեցնել բարդ գործողությունները և դրանք բերել մեկ օբյեկտի մեջ: Կփոխվի ապրանքների գնման գործընթացը, համապատասխանաբար բավական կլինի փոխել ընթացակարգի կոդը։ Այսինքն՝ ընթացակարգը նաև պարզեցնում է կոդի կառավարումը։
Նաև պահպանված ընթացակարգերը թույլ են տալիս սահմանափակել մուտքը աղյուսակների տվյալներին և դրանով իսկ նվազեցնել այս տվյալների հետ կապված դիտավորյալ կամ անգիտակից անցանկալի գործողությունների հավանականությունը:
Եվ մեկ այլ կարևոր ասպեկտ է կատարումը: Պահված ընթացակարգերը սովորաբար ավելի արագ են աշխատում, քան սովորական SQL հայտարարությունները: Դա պայմանավորված է նրանով, որ ընթացակարգի կոդը կազմվում է առաջին անգամ գործարկվելուց հետո, այնուհետև պահվում է կոմպիլացված ձևով:
Պահված ընթացակարգ ստեղծելու համար օգտագործեք CREATE PROCEDURE կամ CREATE PROC հրամանը:
Այսպիսով, պահպանված ընթացակարգը ունի երեք ԿԱՐԵՎՈՐ մասերկոդի պարզեցում, անվտանգություն և կատարում:
Օրինակ, ենթադրենք տվյալների բազայում կա աղյուսակ, որը պահպանում է ապրանքների մասին տվյալները.
CREATE TABLE Products (Id INT IDENTITY PRIMARY KEY, Product Name NVARCHAR(30) NOT NULL, Արտադրող NVARCHAR(20) NOT NULL, Product Count INT DEFAULT 0, Price MONEY NOT NULL);
Եկեք ստեղծենք պահպանված ընթացակարգ այս աղյուսակից տվյալներ ստանալու համար.
Օգտագործեք ապրանքներdb; GO CREATE PROCEDURE Productssummary AS SELECT Ապրանքի անվանումը AS Product, Արտադրող, Գինը Ապրանքներից
Քանի որ CREATE PROCEDURE հրամանը պետք է կանչվի առանձին փաթեթում, GO հրամանն օգտագործվում է USE հրամանից հետո, որը սահմանում է ընթացիկ տվյալների բազան, նոր փաթեթ սահմանելու համար:
Ընթացակարգի անվանմանը պետք է հաջորդի AS հիմնաբառը:
Ընթացակարգի մարմինը մնացած սցենարից առանձնացնելու համար ընթացակարգի կոդը հաճախ տեղադրվում է BEGIN...END բլոկում.
Օգտագործեք ապրանքներdb; GO CREATE PROCEDURE ProductSummary AS BEGIN SELECT ProductName AS Product, Manufacturer, Price FROM Products END;
Ընթացակարգը ավելացնելուց հետո մենք կարող ենք տեսնել այն տվյալների բազայի հանգույցում SQL Server Management Studio-ում ենթահանգույցում: Ծրագրավորելիություն -> Պահպանված ընթացակարգեր:
Եվ մենք կկարողանանք կառավարել ընթացակարգը նաև տեսողական ինտերֆեյսի միջոցով:
Ընթացակարգի իրականացում
Պահված ընթացակարգը կատարելու համար EXEC կամ EXECUTE հրամանը կոչվում է.
EXEC արտադրանքի ամփոփում
Ընթացակարգի ջնջում
Ընթացակարգը թողնելու համար օգտագործեք DROP PROCEDURE հրամանը.
ԸՆԹԱՑԵԼՈՒ ԿԱՐԳԸ Ապրանքի ամփոփում
Դրանում ուսումնական ուղեցույցդուք կսովորեք, թե ինչպես ստեղծել և ջնջել ընթացակարգերը SQL Server-ում(Transact-SQL) շարահյուսությամբ և օրինակներով:
Նկարագրություն
SQL Server-ում ընթացակարգը պահված ծրագիր է, որին կարող եք փոխանցել պարամետրերը: Այն գործառույթի նման արժեք չի վերադարձնում: Այնուամենայնիվ, այն կարող է վերադարձնել հաջողության/ձախողման կարգավիճակը այն ընթացակարգին, որը կոչվում է այն:
Ստեղծման կարգը
Դուք կարող եք ստեղծել ձեր սեփական պահպանված ընթացակարգերը SQL Server-ում (Transact-SQL): Եկեք ավելի սերտ նայենք:
Շարահյուսություն
SQL Server-ում շարահյուսության ընթացակարգերը (Transact-SQL):
CREATE ( PROCEDURE | PROC ) procedure_name
[ @parameterdatatype
[ՏԱՐԲԵՐՎՈՒՄ] [= լռելյայն] [ԴՈՒՐՍ | ԱՐԴՅՈՒՆՔ | ՄԻԱՅՆ ԿԱՐԴԱԼՈՒ ՀԱՄԱՐ]
, @parameter տվյալների տեսակը
[ՏԱՐԲԵՐՎՈՒՄ] [= լռելյայն] [ԴՈՒՐՍ | ԱՐԴՅՈՒՆՔ | ՄԻԱՅՆ ԿԱՐԴԱԼՈՒ ՀԱՄԱՐ ] ]
[ՎԵՐԱԿԱՆԳՆՈՒՄՈՎ
[ԿՐՊԵԿՏՈՐՄԱՆ ՀԱՄԱՐ]
ԱՍ
ՍԿՍԵԼ
executable_section
ՎԵՐՋ;
Ընտրանքներ կամ փաստարկներ
schema_name-ն այն սխեմայի անունն է, որին պատկանում է պահպանված պրոցեդուրան:
procedure_name-ն այն անունն է, որին պետք է վերագրել այս ընթացակարգը SQL Server-ում:
@parameter - Մեկ կամ մի քանի պարամետր փոխանցվում է ընթացակարգին:
type_schema_name-ն այն սխեման է, որին պատկանում է տվյալների տեսակը, եթե կիրառելի է:
Datatype - տվյալների տեսակը @parameter-ի համար:
VARYING-ը սահմանված է կուրսորի պարամետրերի համար, երբ արդյունքների հավաքածուն ելքային պարամետր է:
default-ը @parameter պարամետրին վերագրվող լռելյայն արժեքն է:
OUT - սա նշանակում է, որ @parameter-ը ելքային պարամետր է:
OUTPUT - սա նշանակում է, որ @parameter-ը ելքային պարամետր է:
READONLY - Սա նշանակում է, որ @parameter-ը չի կարող վերագրվել պահպանված ընթացակարգով:
ԿՈՂՄԱԳՐՈՒՄ - Սա նշանակում է, որ պահպանված ընթացակարգի աղբյուրը չի պահվի որպես պարզ տեքստ SQL Server համակարգի դիտումներում:
ՎԵՐԱԿԱԶՄԵԼ - Սա նշանակում է, որ հարցման պլանը չի պահվի այս պահված ընթացակարգի համար:
EXECUTE AS - Սահմանում է անվտանգության համատեքստը պահված ընթացակարգի կատարման համար:
ՌԵՊԼԻԿԱՑՄԱՆ ՀԱՄԱՐ - Սա նշանակում է, որ պահպանված ընթացակարգը կատարվում է միայն կրկնօրինակման ժամանակ:
Օրինակ
Եկեք նայենք SQL Server-ում (Transact-SQL) պահպանված ընթացակարգի ստեղծման օրինակին:
Ստորև բերված է ընթացակարգի պարզ օրինակ.
Գործարք SQL
ՍՏԵՂԾԵԼ ԸՆԹԱՑՔԸ FindSite @site_name VARCHAR(50) ԴՈՒՐՍ ՍԿՍԵԼԻ ՀԱՅՏԱՐԱՐԵԼ @site_id INT; SET @site_id = 8; ԵԹԵ @site_id< 10 SET @site_name = "yandex.com"; ELSE SET @site_name = "google.com"; END;
ՍՏԵՂԾԵԼ ԿԱՐԳԸ FindSite @site_name VARCHAR(50) ԴՈՒՐՍ ՍԿՍԵԼ ՀԱՅՏԱՐԱՐԵԼ @ site_id INT ; SET @site_id = 8 ; ԵԹԵ @site_id< 10 SET @site_name = "yandex.com" ; ԱՅԼՍ SET @site_name = "google.com" ; ՎԵՐՋ ; |
Այս ընթացակարգը կոչվում է FindSite: Այն ունի մեկ պարամետր, որը կոչվում է @site_name, որը ելքային պարամետր է, որը թարմացվում է @site_id փոփոխականի հիման վրա:
Այնուհետև կարող եք դիմել նոր պահպանված ընթացակարգին, որը կոչվում է FindSite հետևյալ կերպ.
