განიხილება სიტუაცია, როდესაც შენახულ პროცედურებს შეუძლიათ შეამცირონ მოთხოვნის შესრულება.
MS SQL Server 2000-ში შენახული პროცედურების შედგენისას, შენახული პროცედურები მოთავსებულია პროცედურულ ქეშში, რომელსაც შეუძლია გააუმჯობესოს შესრულება მათი შესრულებისას, რაც გამორიცხავს შენახული პროცედურების კოდის ანალიზის, ოპტიმიზაციისა და შედგენის საჭიროებას.
მეორეს მხრივ, შენახული პროცედურის შედგენილი კოდის შენახვაში არის ხარვეზები, რომლებსაც შეიძლება ჰქონდეს საპირისპირო ეფექტი.
ფაქტია, რომ შენახული პროცედურის შედგენისას, შედგენილია იმ ოპერატორების შესრულების გეგმა, რომლებიც ქმნიან პროცედურების კოდს, შესაბამისად, თუ შედგენილი შენახული პროცედურა ქეშირებულია, მაშინ მისი შესრულების გეგმა ასევე ქეშირებულია და, შესაბამისად, შენახული პროცედურა არ იქნება. იყოს ოპტიმიზირებული კონკრეტული სიტუაციისა და შეკითხვის პარამეტრებისთვის.
გავაკეთებთ პატარა ექსპერიმენტს ამის საჩვენებლად.
ᲜᲐᲑᲘᲯᲘ 1... მონაცემთა ბაზის შექმნა.
მოდით შევქმნათ ცალკე მონაცემთა ბაზა ექსპერიმენტისთვის.
მონაცემთა ბაზის შექმნა test_sp_perf
ON (NAME = "ტესტი_მონაცემები", FILENAME = "c: \ temp \ test_data", SIZE = 1, MAXSIZE = 10, FILEGROWTH = 1 მბ)
LOG ON (NAME = "test_log", FILENAME = "c: \ temp \ test_log", SIZE = 1, MAXSIZE = 10, FILEGROWTH = 1Mb)
ნაბიჯი 2.მაგიდის შექმნა.
CREATE TABLE sp_perf_test (სვეტი1 int, სვეტი2 სიმბოლო (5000))
ნაბიჯი 3.ცხრილის შევსება ტესტის ხაზებით. დუბლიკატი რიგები განზრახ ემატება ცხრილში. 10000 სტრიქონი დანომრილია 1-დან 10000-მდე და 10000 სტრიქონი 50000-ს.
გამოაცხადე @i int
SET @ i = 1
Სანამ მე<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
ᲓᲐᲡᲐᲡᲠᲣᲚᲘ
აირჩიეთ COUNT (*) FROM sp_perf_test
წადი
ნაბიჯი 4.შექმენით არაკლასტერული ინდექსი. ვინაიდან შესრულების გეგმა ქეშირებულია პროცედურასთან ერთად, ინდექსი ერთნაირად იქნება გამოყენებული ყველა ზარისთვის.
შექმენით არაკლუსტერული ინდექსი CL_perf_test ON sp_perf_test (სვეტი1)
წადი
ნაბიჯი 5.შენახული პროცედურის შექმნა. პროცედურა უბრალოდ ახორციელებს SELECT განცხადებას პირობით.
PROC proc1-ის შექმნა (@param int)
ას
აირჩიეთ სვეტი1, სვეტი2 FROM sp_perf_test WHERE [ელფოსტა დაცულია]
წადი
ნაბიჯი 6.შენახული პროცედურის გაშვება. დაუცველი პროცედურის დაწყებისას სპეციალურად გამოიყენება შერჩევითი პარამეტრი. პროცედურის შედეგად ვიღებთ 1 ხაზს. შესრულების გეგმა მიუთითებს არაკლასტერული ინდექსის გამოყენებაზე, რადგან მოთხოვნა არის შერჩევითი და საუკეთესო გზაა მწკრივის მისაღებად. პროცედურა, რომელიც ოპტიმიზირებულია ერთი მწკრივის მისაღებად, ინახება პროცედურულ ქეშში.
EXEC proc1 1234
წადი
ნაბიჯი 7.შენახული პროცედურის გაშვება არასელექტიური პარამეტრით. პარამეტრად გამოიყენება მნიშვნელობა 50000. ხაზები პირველი სვეტის ასეთი მნიშვნელობით დაახლოებით 10000, შესაბამისად, არაეფექტურია არაკლასტერული ინდექსისა და სანიშნეების მოძიების ოპერაციის გამოყენება, მაგრამ რადგან შედგენილი კოდი შესრულების გეგმასთან ერთად ინახება. პროცედურულ ქეშში ის იქნება გამოყენებული. შესრულების გეგმა აჩვენებს ამას, ისევე როგორც ის, რომ სანიშნეების მოძიების ოპერაცია შესრულდა 9999 სტრიქონზე.
EXEC proc1 50,000
წადი
ნაბიჯი 8.პირველი ველის 50000-ის ტოლი მწკრივების მოძიება. ცალკე მოთხოვნის შესრულება გამოიწვევს მოთხოვნის ოპტიმიზაციას და შედგენას პირველი სვეტის კონკრეტული მნიშვნელობით. შედეგად, შეკითხვის ოპტიმიზატორი აღმოაჩენს, რომ ველი მრავალჯერ დუბლირებულია და გადაწყვეტს გამოიყენოს ცხრილის სკანირების ოპერაცია, რაც ამ შემთხვევაში ბევრად უფრო ეფექტურია, ვიდრე არაკლასტერული ინდექსის გამოყენება.
აირჩიეთ სვეტი1, სვეტი2 FROM sp_perf_test WHERE სვეტი1 = 50000
წადი
ამრიგად, შეგვიძლია დავასკვნათ, რომ შენახული პროცედურების გამოყენება შეიძლება ყოველთვის არ გააუმჯობესოს მოთხოვნის შესრულება. ძალიან ფრთხილად უნდა იყოთ შენახულ პროცედურებთან, რომლებიც მოქმედებენ შედეგებზე ცვლადი რაოდენობის ხაზებით და იყენებენ განსხვავებულ შესრულების გეგმებს.
თქვენ შეგიძლიათ გამოიყენოთ სკრიპტი ექსპერიმენტის გასამეორებლად ახალ MS SQL სერვერზე.
შენახული პროცედურების ტიპები
SQL Server-ში რამდენიმე ტიპია შენახული პროცედურები.
- სისტემური შენახული პროცედურებიშექმნილია სხვადასხვა ადმინისტრაციული მოქმედებების შესასრულებლად. სერვერის ადმინისტრირების თითქმის ყველა მოქმედება მათი დახმარებით ხორციელდება. შეგვიძლია ვთქვათ, რომ სისტემა შენახული პროცედურებიარის ინტერფეისი, რომელიც უზრუნველყოფს სისტემის ცხრილებთან მუშაობას, რაც საბოლოოდ მთავრდება როგორც მომხმარებლის, ასევე სისტემის მონაცემთა ბაზების სისტემის ცხრილებიდან მონაცემების შეცვლაზე, დამატებაზე, წაშლაზე და მიღებაზე. სისტემური შენახული პროცედურებიარის პრეფიქსი sp_, ინახება სისტემის მონაცემთა ბაზაში და შეიძლება გამოიძახონ ნებისმიერი სხვა მონაცემთა ბაზის კონტექსტში.
- საბაჟო შენახული პროცედურებიგანახორციელოს გარკვეული ქმედებები. შენახული პროცედურები- სრულფასოვანი მონაცემთა ბაზის ობიექტი. შედეგად, თითოეული შენახული პროცედურამდებარეობს კონკრეტულ მონაცემთა ბაზაში, სადაც ის სრულდება.
- დროებითი შენახული პროცედურებიარსებობენ მხოლოდ გარკვეული პერიოდის განმავლობაში, რის შემდეგაც ისინი ავტომატურად ანადგურებენ სერვერს. ისინი იყოფა ადგილობრივ და გლობალურად. ადგილობრივი დროებითი შენახული პროცედურებიშეიძლება გამოძახება მხოლოდ იმ კავშირიდან, რომელშიც ისინი შეიქმნა. როდესაც თქვენ შექმნით ასეთ პროცედურას, თქვენ უნდა მისცეთ მას სახელი, რომელიც იწყება ერთი # სიმბოლოთი. როგორც ყველა დროებითი ობიექტი, შენახული პროცედურებიამ ტიპის ავტომატურად წაიშლება, როდესაც მომხმარებელი გათიშავს, გადატვირთავს ან აჩერებს სერვერს. გლობალური დროებითი შენახული პროცედურებიხელმისაწვდომია ნებისმიერი სერვერის კავშირებისთვის, რომლებსაც აქვთ იგივე პროცედურა. მისი განსაზღვრისთვის, თქვენ უბრალოდ უნდა მისცეთ სახელი, რომელიც იწყება ## სიმბოლოებით. ეს პროცედურები იშლება სერვერის გადატვირთვის ან შეჩერებისას, ან როდესაც კავშირი, რომლის კონტექსტშიც შეიქმნა, დახურულია.
შენახული პროცედურების შექმნა, შეცვლა და წაშლა
შემოქმედება შენახული პროცედურამოიცავს შემდეგი ამოცანების გადაწყვეტას:
- შექმნის ტიპის განსაზღვრა შენახული პროცედურა: დროებითი ან საბაჟო. გარდა ამისა, თქვენ შეგიძლიათ შექმნათ თქვენი საკუთარი სისტემა შენახული პროცედურასახელის მინიჭებით sp_ პრეფიქსით და მოთავსებით სისტემის მონაცემთა ბაზაში. ეს პროცედურა ხელმისაწვდომი იქნება ლოკალურ სერვერზე არსებული ნებისმიერი მონაცემთა ბაზის კონტექსტში;
- წვდომის უფლებების დაგეგმვა. შექმნისას შენახული პროცედურაგასათვალისწინებელია, რომ მას ექნება მონაცემთა ბაზის ობიექტებზე წვდომის იგივე უფლებები, რაც მის შემქმნელ მომხმარებელს;
- განმარტება შენახული პროცედურის პარამეტრები... პროგრამირების უმეტეს ენებში ნაპოვნი პროცედურების მსგავსად, შენახული პროცედურებიშეიძლება ჰქონდეს შემავალი და გამომავალი პარამეტრები;
- კოდის განვითარება შენახული პროცედურა... პროცედურული კოდი შეიძლება შეიცავდეს ნებისმიერი SQL ბრძანების თანმიმდევრობას, მათ შორის ზარებს სხვებთან. შენახული პროცედურები.
ახლის შექმნა და არსებულის შეცვლა შენახული პროცედურაკეთდება შემდეგი ბრძანებით:
<определение_процедуры>:: = (CREATE | ALTER) პროცედურის_სახელი [; ნომერი] [(@ parameter_name datatype) [= default]] [, ... n] AS sql_operator [... n]
მოდით განვიხილოთ ამ ბრძანების პარამეტრები.
პრეფიქსების sp_, #, ## გამოყენებით შექმნილი პროცედურა შეიძლება განისაზღვროს, როგორც სისტემური ან დროებითი. როგორც ბრძანების სინტაქსიდან ხედავთ, დაუშვებელია იმ მფლობელის სახელის მითითება, რომელიც ეკუთვნის შექმნილ პროცედურას, ასევე მონაცემთა ბაზის დასახელებას, სადაც ის უნდა იყოს განთავსებული. ამგვარად, იმისათვის რომ მოათავსოთ შექმნილი შენახული პროცედურაკონკრეტულ მონაცემთა ბაზაზე, თქვენ უნდა გაუშვათ CREATE PROCEDURE ბრძანება ამ მონაცემთა ბაზის კონტექსტში. სხეულის გარეთ გატარებისას შენახული პროცედურაშეგიძლიათ გამოიყენოთ შემოკლებული სახელები იმავე მონაცემთა ბაზის ობიექტებისთვის, ანუ მონაცემთა ბაზის სახელის მითითების გარეშე. როდესაც გჭირდებათ სხვა მონაცემთა ბაზებში მდებარე ობიექტებზე მითითება, საჭიროა მონაცემთა ბაზის სახელის მითითება.
სახელის ნომერი არის საიდენტიფიკაციო ნომერი შენახული პროცედურა, რომელიც ცალსახად განსაზღვრავს მას პროცედურების ჯგუფში. პროცედურების მართვის მოხერხებულობისთვის, ლოგიკურად იგივე ტიპის შენახული პროცედურებიშეიძლება დაჯგუფდეს ერთი და იგივე სახელის მინიჭებით, მაგრამ განსხვავებული საიდენტიფიკაციო ნომრებით.
შეყვანილი და გამომავალი მონაცემების გადასატანად შექმნილში შენახული პროცედურაშეიძლება გამოყენებულ იქნას პარამეტრები, რომელთა სახელები, ისევე როგორც ლოკალური ცვლადების სახელები, უნდა იწყებოდეს @ სიმბოლოთი. ერთი შენახული პროცედურაშეიძლება ბევრი პარამეტრის მითითება, გამოყოფილი მძიმეებით. პროცედურის ძირითადი ნაწილი არ უნდა გამოიყენოს ლოკალური ცვლადები, რომელთა სახელები იგივეა, რაც ამ პროცედურის პარამეტრების სახელები.
რათა დადგინდეს მონაცემების ტიპი, რომელსაც ექნება შესაბამისი შენახული პროცედურის პარამეტრი, SQL მონაცემთა ნებისმიერი ტიპი, მომხმარებლის მიერ განსაზღვრულის ჩათვლით, იმუშავებს. თუმცა, CURSOR მონაცემთა ტიპი შეიძლება გამოყენებულ იქნას მხოლოდ როგორც გამომავალი პარამეტრი შენახული პროცედურა, ე.ი. საკვანძო სიტყვის OUTPUT მითითებით.
OUTPUT საკვანძო სიტყვის არსებობა ნიშნავს, რომ შესაბამისი პარამეტრი განკუთვნილია მონაცემების დასაბრუნებლად შენახული პროცედურა... თუმცა, ეს საერთოდ არ ნიშნავს იმას, რომ პარამეტრი არ არის შესაფერისი მნიშვნელობების გადასაცემად შენახული პროცედურა... OUTPUT საკვანძო სიტყვის მითითება სერვერს ავალებს გასვლას შენახული პროცედურაპარამეტრის მიმდინარე მნიშვნელობა მიანიჭეთ ლოკალურ ცვლადს, რომელიც მითითებული იყო პარამეტრის მნიშვნელობად პროცედურის გამოძახებისას. გაითვალისწინეთ, რომ როდესაც მითითებულია OUTPUT საკვანძო სიტყვა, პროცედურის გამოძახებისას შესაბამისი პარამეტრის მნიშვნელობა შეიძლება დაყენდეს მხოლოდ ადგილობრივი ცვლადის გამოყენებით. თქვენ არ გაქვთ უფლება გამოიყენოთ რაიმე გამონათქვამები ან მუდმივები, რომლებიც მოქმედებს ნორმალური პარამეტრებისთვის.
VARYING საკვანძო სიტყვა გამოიყენება ერთად
შენახვის პროცედურა (ინგლ.შენახული პროცედურა) არის დასახელებული მონაცემთა ბაზის პროგრამის ობიექტი. SQL Server-ში შენახული პროცედურების რამდენიმე ტიპი არსებობს.
სისტემაში შენახული პროცედურები (ინგლ.სისტემაში შენახული პროცედურა) მოწოდებულია DBMS დეველოპერების მიერ და გამოიყენება სისტემის კატალოგთან მოქმედებების შესასრულებლად ან სისტემის ინფორმაციის მისაღებად. მათი სახელები ჩვეულებრივ იწყება "sp_" პრეფიქსით. ყველა ტიპის შენახული პროცედურების გამოძახება ხდება EXECUTE ბრძანებით, რომელიც შეიძლება შემოკლებული იყოს როგორც EXEC. მაგალითად, sp_hellogins შენახული პროცედურა, რომელიც მუშაობს პარამეტრების გარეშე, ქმნის ორ ანგარიშს ანგარიშის სახელებზე. (ინგლ.შესვლა) და მათი შესაბამისი მომხმარებლები თითოეულ მონაცემთა ბაზაში (ინგლ.მომხმარებლები).
EXEC sp_hellogins;
სისტემაში შენახული პროცედურების გამოყენებით შესრულებული მოქმედებების წარმოდგენა ცხრილში. 10.6 მოცემულია რამდენიმე მაგალითი. SQL Server-ში ათასზე მეტი სისტემური შენახული პროცედურაა.
ცხრილი 10.6
SQL Server სისტემის შენახული პროცედურის მაგალითები
მომხმარებელს შეუძლია შექმნას შენახული პროცედურები მომხმარებლის მონაცემთა ბაზაში და მონაცემთა ბაზაში დროებითი ობიექტებისთვის. ამ უკანასკნელ შემთხვევაში შენახული პროცედურა იქნება დროებითი.როგორც დროებითი ცხრილების შემთხვევაში, დროებითი შენახული პროცედურის სახელი უნდა იწყებოდეს „#“ პრეფიქსით, თუ ეს არის ლოკალური დროებით შენახული პროცედურა, ან „##“, თუ ის გლობალურია. ადგილობრივი დროებითი პროცედურის გამოყენება შესაძლებელია მხოლოდ იმ კავშირის ფარგლებში, რომელშიც ის შეიქმნა, გლობალურში - და სხვა კავშირებში.
SQL Server პროგრამირებადი ობიექტები შეიძლება შეიქმნას Transact-SQL ინსტრუმენტების ან ასამბლეის გამოყენებით (ინგლ.ასამბლეა) 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 არის ნაგულისხმევი და ნიშნავს, რომ კოდი შესრულდება მომხმარებლის უსაფრთხოების კონტექსტში, რომელიც ამ მოდულს ურეკავს. შესაბამისად, მომხმარებელს უნდა ჰქონდეს ნებართვები არა მხოლოდ თავად დაპროგრამებული ობიექტისთვის, არამედ სხვა მონაცემთა ბაზის ობიექტებზეც, რომლებიც გავლენას ახდენს მასზე. EXECUTE AS SELF ნიშნავს მომხმარებლის კონტექსტის გამოყენებას პროგრამირებადი ობიექტის შექმნას ან შეცვლას. OWNER მიუთითებს, რომ კოდი შესრულდება პროცედურის ამჟამინდელი მფლობელის კონტექსტში. თუ მისთვის არ არის განსაზღვრული მფლობელი, მაშინ იგულისხმება იმ სქემის მფლობელი, რომელსაც ის ეკუთვნის. EXECUTE AS "user_name" გაძლევთ საშუალებას ცალსახად მიუთითოთ მომხმარებლის სახელი (ერთ ბრჭყალებში).
პროცედურისთვის შეიძლება განისაზღვროს პარამეტრები. ეს არის ადგილობრივი ცვლადები, რომლებიც გამოიყენება პროცედურისთვის მნიშვნელობების გადასაცემად. თუ პარამეტრი გამოცხადებულია OUTPUT საკვანძო სიტყვით (ან მოკლედ OUT), ეს არის გამომავალი პარამეტრი: პროცედურაში მითითებული მნიშვნელობა მისი შეწყვეტის შემდეგ შეიძლება გამოიყენოს პროგრამამ, რომელმაც პროცედურა გამოიძახა. საკვანძო სიტყვა READONLY ნიშნავს, რომ პარამეტრის მნიშვნელობა არ შეიძლება შეიცვალოს შენახული პროცედურის შიგნით.
პარამეტრებს შეიძლება მიენიჭოთ მნიშვნელობები, მაგრამ ნაგულისხმევი, რომლებიც გამოყენებული იქნება, თუ პარამეტრის მნიშვნელობა პირდაპირ არ არის მითითებული პროცედურის გამოძახებისას. განვიხილოთ მაგალითი:
CREATE PROC surma (@ a int, @b int = 0,
© შედეგი int OUTPUT) AS
SET @ შედეგი = 0a + 0b
ჩვენ შევქმენით პროცედურა სამი პარამეტრით და @b პარამეტრს აქვს ნაგულისხმევი მნიშვნელობა 0, ხოლო @result პარამეტრი არის გამომავალი პარამეტრი: მისი მეშვეობით მნიშვნელობა უბრუნდება გამოძახების პროგრამას. შესრულებული მოქმედებები საკმაოდ მარტივია - გამომავალი პარამეტრი იღებს ორი შეყვანის ჯამის მნიშვნელობას.
SQL Server Management Studio-ში მუშაობისას შექმნილი შენახული პროცედურა შეგიძლიათ იხილოთ პროგრამირებადი DB ობიექტების განყოფილებაში. (ინგლ.პროგრამირებადობა) შენახული პროცედურების ქვეთავში (სურათი 10.2).
პროცედურის გამოძახებისას, შეყვანის პარამეტრებად შეგიძლიათ გამოიყენოთ როგორც ცვლადები, ასევე მუდმივები. მოდით შევხედოთ ორ მაგალითს. პირველში, პროცედურის შეყვანის პარამეტრები ცალსახად არის დაყენებული მუდმივებით; საკვანძო სიტყვა OUTPUT მითითებულია გამომავალი პარამეტრისთვის ზარში. მეორე ვარიანტში ცვლადის მნიშვნელობა გამოიყენება, როგორც პირველი შეყვანის პარამეტრი, ხოლო მეორე პარამეტრისთვის, DEFAULT საკვანძო სიტყვის გამოყენებით, მითითებულია, რომ გამოყენებული უნდა იყოს ნაგულისხმევი მნიშვნელობა:
ბრინჯი. 10.2.
დეკლარირება @ int-ით;
EXEC summa 10.5, @ c OUTPUT;
PRINT 0c; - 15 გამოჩნდება
დეკლარირება Gi int = 5;
- დარეკვისას გამოიყენეთ ნაგულისხმევი მნიშვნელობა
EXEC ჯამი Gi, DEFAULT, 0с OUTPUT;
PRINT 0c; - 5 გამოჩნდება
ახლა განვიხილოთ მაგალითი დაბრუნების კოდის ანალიზით, რომლითაც მთავრდება პროცედურა. დაგვჭირდება გამოთვლა, რამდენი წიგნი გამოიცა Bookl ცხრილში მოცემულ პერიოდში. უფრო მეტიც, თუ საწყისი წელი ბოლო წელზე მეტი აღმოჩნდა, პროცედურა აბრუნებს "1"-ს და არ ითვლება, წინააღმდეგ შემთხვევაში, ვითვლით წიგნების რაოდენობას და ვაბრუნებთ 0-ს:
CREATE PROC dbo.rownum (0FirsYear int, GLastYear int, 0result int OUTPUT) როგორც
IF 0 FirstYear> 0 LastYear RETURN 1
SET @ შედეგი = (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))
IF OBJECT_ID ("tempdb.dbo. # Tab21) არის NULL
ჩასმა dbo-ში # Tab2 (id, სახელი) VALUES (0id, 0name)
აირჩიეთ * dbo-დან. # ჩანართი2 –№1
შენახული პროცედურის პირველ გამოძახებამდე ჩვენ შევქმნით მასში გამოყენებულ დროებით ცხრილს # Thab2. ყურადღება მიაქციეთ EXEC ოპერატორს. წინა მაგალითებში პარამეტრები გადაეცა პროცედურას "პოზიციის მიხედვით" და ამ შემთხვევაში გამოიყენება პარამეტრების გადაცემის სხვა ფორმატი - "სახელით", პარამეტრის სახელი და მისი მნიშვნელობა პირდაპირ არის მითითებული:
CREATE TABLE dbo.# Tab2 (id int, name varchar (30));
EXEC My_Procl 0name = "lvan", 0id = 2;
SELECT * FROM dbo.# Tab2; –№2
ზემოხსენებულ მაგალითში SELECT განცხადება შესრულდება ორჯერ: პირველად - პროცედურის შიგნით, მეორედ - გამოძახების კოდის ფრაგმენტიდან (მონიშნული "# 2" კომენტარით).
პროცედურის მეორე გამოძახებამდე ჩვენ წავშლით დროებით ცხრილს # Tab2. შემდეგ შეიქმნება ამავე სახელწოდების დროებითი ცხრილი შენახული პროცედურისგან:
ჩამოაგდეს TABLE dbo.# Tab2;
EXEC My_Procl 0name = "Ivan", 0id = 2;
SELECT * FROM dbo.# Tab2; –№2
ამ შემთხვევაში, მხოლოდ SELECT განცხადება პროცედურის შიგნით (კომენტარის "Xa 1") აჩვენებს მონაცემებს. SELECT "# 2" გამოიწვევს შეცდომას, რადგან შენახულ პროცედურაში შექმნილი დროებითი ცხრილი უკვე წაშლილია tempdb-დან პროცედურის დაბრუნების დროს.
შეგიძლიათ შენახული პროცედურის ჩამოგდება DROP PROCEDURE განაცხადის გამოყენებით. მისი ფორმატი ნაჩვენებია ქვემოთ. ერთ ოპერატორს შეუძლია წაშალოს რამდენიმე შენახული პროცედურა მძიმით გამოყოფილი მათი ჩამოთვლით:
ვარდნა (პროცენტი I პროცედურა) (პროცედურა) [
მაგალითად, მოდით ამოვიღოთ ადრე შექმნილი პროცედურის ჯამი:
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 არის დასაყენებელი ვარიანტი
IF 0 FirstYear> 0 LastYear RETURN 1 სხვა დასაწყისი
SET 0result = (SELECT COUNT (*) FROM dbo.Bookl
WHERE BETWEEN SfirsYear და SLastYear);
ზოგიერთ შემთხვევაში შეიძლება საჭირო გახდეს ბრძანების დინამიურად ჩამოყალიბება და მონაცემთა ბაზის სერვერზე შესრულება. ამ ამოცანის გადაჭრა ასევე შესაძლებელია EXEC ოპერატორის გამოყენებით. ქვემოთ მოყვანილი მაგალითი იღებს ჩანაწერებს Bookl ცხრილიდან იმ პირობით, რომ Year ატრიბუტი უდრის ცვლადის გამოყენებით დაყენებულ მნიშვნელობას:
დეკლარირება 0y int = 2000;
EXEC ("SELECT * FROM dbo.Bookl WHERE =" [ელფოსტა დაცულია]) ;
დინამიურად გენერირებული ინსტრუქციების შესრულება ქმნის წინაპირობებს კომპიუტერული შეტევების განხორციელებისთვის, როგორიცაა "SQL injection" (ინგლ. SQL ინექცია). თავდასხმის არსი იმაში მდგომარეობს, რომ თავდამსხმელი შეაქვს საკუთარ SQL კოდს დინამიურად გენერირებულ მოთხოვნაში. ეს ჩვეულებრივ ხდება, როდესაც ჩანაცვლებული პარამეტრები აღებულია მომხმარებლის შეყვანის შედეგებიდან.
ცოტა შევცვალოთ წინა მაგალითი:
დეკლარირება 0y varchar (100);
SET 0y = "2OOO"; - ეს მომხმარებლისგან მივიღეთ
თუ ვივარაუდებთ, რომ მომხმარებლისგან მივიღეთ SET განცხადებაში მინიჭებული სტრიქონის მნიშვნელობა (არ აქვს მნიშვნელობა როგორ, მაგალითად, ვებ აპლიკაციის საშუალებით), მაშინ მაგალითი ასახავს ჩვენი კოდის "რეგულარულ" ქცევას.
დეკლარირება 0y varchar (100);
SET 0y = "2000; DELETE FROM dbo.Book2"; - ინექცია
EXEC ("SELECT * FROM dbo.Book2 WHERE =" + 0y);
ასეთ შემთხვევებში რეკომენდებულია sp_executcsql სისტემის შენახული პროცედურის გამოყენება შეძლებისდაგვარად, რაც საშუალებას გაძლევთ გააკონტროლოთ პარამეტრების ტიპი, რაც ერთ-ერთი ბარიერია SQL ინექციისთვის. მისი ფორმატის დეტალურად განხილვის გარეშე, მოდით გავაანალიზოთ ადრე წარმოდგენილი მაგალითის მსგავსი:
EXECUTE sp_executesql
N "SELECT * FROM dbo.Bookl WHERE = 0y",
ეს ცალსახად განსაზღვრავს მოთხოვნაში გამოყენებული პარამეტრის ტიპს და მონიტორინგს გაუწევს SQL Server-ის მიერ შესრულების დროს. ასო "N" ბრჭყალების წინ მიუთითებს, რომ ეს არის უნიკოდის ლიტერალური მუდმივი, როგორც ეს პროცედურა მოითხოვს. პარამეტრს შეიძლება მიენიჭოს არა მხოლოდ მუდმივი მნიშვნელობა, არამედ სხვა ცვლადის მნიშვნელობაც.
შენახული პროცედურაარის Transact-SQL განცხადებების სპეციალური ტიპი, რომელიც შექმნილია SQL ენისა და პროცედურული გაფართოებების გამოყენებით. ძირითადი განსხვავება პაკეტსა და შენახულ პროცედურას შორის არის ის, რომ ეს უკანასკნელი ინახება როგორც მონაცემთა ბაზის ობიექტი. სხვა სიტყვებით რომ ვთქვათ, შენახული პროცედურები შენარჩუნებულია სერვერის მხარეს მუშაობისა და განმეორებადობის გასაუმჯობესებლად.
მონაცემთა ბაზის ძრავა მხარს უჭერს შენახულ პროცედურებსა და სისტემის პროცედურებს. შენახული პროცედურები იქმნება ისევე, როგორც ყველა სხვა მონაცემთა ბაზის ობიექტი, ე.ი. DDL ენის გამოყენებით. სისტემური პროცედურებიმოწოდებულია მონაცემთა ბაზის ძრავით და შეიძლება გამოყენებულ იქნას სისტემის კატალოგში ინფორმაციის წვდომისა და შესაცვლელად.
როდესაც შექმნით შენახულ პროცედურას, შეგიძლიათ განსაზღვროთ არჩევითი პარამეტრების სია. ამრიგად, პროცედურა მიიღებს შესაბამის არგუმენტებს ყოველ ჯერზე, როდესაც ის გამოიძახის. შენახულ პროცედურებს შეუძლიათ დააბრუნონ მნიშვნელობა, რომელიც შეიცავს მომხმარებლის მიერ განსაზღვრულ ინფორმაციას ან, შეცდომის შემთხვევაში, დაკავშირებული შეცდომის შესახებ შეტყობინებას.
შენახული პროცედურა წინასწარ შედგენილია მონაცემთა ბაზაში ობიექტად შენახვამდე. პროცედურის წინასწარ შედგენილი ფორმა ინახება მონაცემთა ბაზაში და გამოიყენება ყოველი გამოძახებისას. შენახული პროცედურების ეს თვისება მნიშვნელოვან სარგებელს იძლევა იმით, რომ გამორიცხავს (თითქმის ყველა შემთხვევაში) პროცედურის ხელახალი შედგენას და უზრუნველყოფს შესრულების შესაბამის გაუმჯობესებას. შენახული პროცედურების ეს თვისება ასევე დადებითად მოქმედებს მონაცემთა ბაზის სისტემასა და აპლიკაციებს შორის გაცვლილი მონაცემების რაოდენობაზე. კერძოდ, რამდენიმე ათასი ბაიტის ზომის შენახულ პროცედურაზე დარეკვა შეიძლება მოითხოვოს 50 ბაიტზე ნაკლები. როდესაც მრავალი მომხმარებელი ასრულებს განმეორებით დავალებებს შენახული პროცედურების გამოყენებით, ამ დანაზოგის კუმულაციური ეფექტი შეიძლება იყოს მნიშვნელოვანი.
შენახული პროცედურები ასევე შეიძლება გამოყენებულ იქნას შემდეგი მიზნებისთვის:
მონაცემთა ბაზის ცხრილებით მოქმედებების ჟურნალის შესაქმნელად.
შენახული პროცედურების გამოყენება უზრუნველყოფს უსაფრთხოების კონტროლის დონეს, რომელიც მნიშვნელოვნად აღემატება უსაფრთხოების დონეს, რომელიც უზრუნველყოფილია GRANT და REVOKE განცხადებების გამოყენებით, რომლებიც ანიჭებენ მომხმარებლებს წვდომის სხვადასხვა პრივილეგიებს. ეს შესაძლებელია, რადგან შენახული პროცედურის შესრულების ავტორიზაცია დამოუკიდებელია მოცემულ შენახულ პროცედურაში შემავალი ობიექტების შეცვლის ავტორიზაციისგან, როგორც ეს აღწერილია შემდეგ ნაწილში.
შენახული პროცედურები, რომლებიც ქმნიან ჟურნალებს ცხრილებზე ჩასაწერად და/ან წასაკითხად, უზრუნველყოფს მონაცემთა ბაზის დამატებით უსაფრთხოებას. ამ პროცედურების გამოყენებით, მონაცემთა ბაზის ადმინისტრატორს შეუძლია თვალყური ადევნოს მომხმარებლის ან აპლიკაციების მიერ მონაცემთა ბაზაში შეტანილ ცვლილებებს.
შენახული პროცედურების შექმნა და შესრულება
შენახული პროცედურები იქმნება განცხადების გამოყენებით პროცედურების შექმნარომელსაც აქვს შემდეგი სინტაქსი:
CREATE PROC proc_name [((@ param1) type1 [ცვალებადი] [= ნაგულისხმევი1])] (,…) AS batch | EXTERNAL NAME მეთოდი_სახელი სინტაქსური კონვენციები
schema_name პარამეტრი განსაზღვრავს სქემის სახელს, რომელიც მინიჭებულია გენერირებული შენახული პროცედურის მფლობელად. proc_name პარამეტრი განსაზღვრავს შენახული პროცედურის სახელს. @ param1 პარამეტრი არის პროცედურის პარამეტრი (ფორმალური არგუმენტი), რომლის მონაცემთა ტიპი მითითებულია type1 პარამეტრით. პროცედურის პარამეტრები ლოკალურია პროცედურის ფარგლებში, ისევე როგორც ლოკალური ცვლადები ლოკალური პაკეტის შიგნით. პროცედურის პარამეტრები არის მნიშვნელობები, რომლებიც აბონენტს გადასცემს მასში გამოსაყენებლად პროცედურას. default1 პარამეტრი განსაზღვრავს ნაგულისხმევ მნიშვნელობას შესაბამისი პროცედურის პარამეტრისთვის. (ნაგულისხმევი ასევე შეიძლება იყოს NULL.)
OUTPUT ვარიანტიმიუთითებს, რომ პროცედურის პარამეტრი არის დასაბრუნებელი პარამეტრი, რომელიც შეიძლება გამოყენებულ იქნას შენახული პროცედურისგან მნიშვნელობის დასაბრუნებლად გამოძახების პროცედურაში ან სისტემაში.
როგორც უკვე აღვნიშნეთ, პროცედურის წინასწარ შედგენილი ფორმა ინახება მონაცემთა ბაზაში და გამოიყენება ყოველი გამოძახებისას. თუ რაიმე მიზეზის გამო, შენახული პროცედურა უნდა იყოს შედგენილი ყოველ ჯერზე მისი გამოძახებისას, პროცედურის გამოცხადებისას გამოიყენეთ ვარიანტი RECOMPILE-ით... პარამეტრის WITH RECOMPILE გამოყენება უარყოფს შენახული პროცედურების ერთ-ერთ ყველაზე მნიშვნელოვან უპირატესობას: შესრულების გაუმჯობესებას ერთი კომპილაციისგან. ამიტომ, WITH RECOMPILE ვარიანტი უნდა იყოს გამოყენებული მხოლოდ მონაცემთა ბაზის ობიექტებში ხშირი ცვლილებების შეტანისას, რომლებიც გამოიყენება შენახული პროცედურის მიერ.
EXECUTE AS პუნქტიგანსაზღვრავს უსაფრთხოების კონტექსტს, რომელშიც შენახული პროცედურა უნდა შესრულდეს მისი გამოძახების შემდეგ. ამ კონტექსტის დაყენებით, შეგიძლიათ გამოიყენოთ მონაცემთა ბაზის ძრავა, რათა აკონტროლოთ მომხმარებლის ანგარიშების შერჩევა ამ შენახული პროცედურის მიერ მითითებულ ობიექტებზე წვდომის ნებართვების შესამოწმებლად.
ნაგულისხმევად, მხოლოდ sysadmin ფიქსირებული სერვერის როლის წევრებს და db_owner ან db_ddladmin ფიქსირებული მონაცემთა ბაზის როლს შეუძლიათ გამოიყენონ CREATE PROCEDURE განაცხადი. მაგრამ ამ როლების წევრებს შეუძლიათ ეს უფლება მიანიჭონ სხვა მომხმარებლებს ინსტრუქციის გამოყენებით გრანტის შექმნის პროცედურა.
ქვემოთ მოყვანილი მაგალითი გვიჩვენებს, თუ როგორ უნდა შექმნათ მარტივი შენახული პროცედურა პროექტის ცხრილთან მუშაობისთვის:
გამოიყენეთ SampleDb; GO CREATE PROCEDURE IncreaseBudget (@percent INT = 5) განახლების სახით პროექტის ნაკრები ბიუჯეტი = ბიუჯეტი + ბიუჯეტი * @ პროცენტი / 100;
როგორც უკვე აღვნიშნეთ, ორი პაკეტის გამოსაყოფად გამოიყენეთ GO ინსტრუქცია... CREATE PROCEDURE განაცხადი არ შეიძლება გაერთიანდეს სხვა Transact-SQL განცხადებებთან იმავე პაკეტში. IncreaseBudget შენახული პროცედურა ზრდის ბიუჯეტებს ყველა პროექტისთვის გარკვეული პროცენტით, რომელიც მითითებულია @percent პარამეტრით. პროცედურა ასევე განსაზღვრავს ნაგულისხმევ პროცენტულ მნიშვნელობას (5), რომელიც გამოიყენება, თუ ეს არგუმენტი არ არის პროცედურის დროს.
შენახულ პროცედურებს შეუძლიათ წვდომა იმ ცხრილებზე, რომლებიც არ არსებობს. ეს თვისება საშუალებას გაძლევთ გამართოთ პროცედურული კოდი, ჯერ შესაბამისი ცხრილების შექმნის ან დანიშნულების სერვერთან დაკავშირების გარეშე.
ძირითადი შენახული პროცედურებისგან განსხვავებით, რომლებიც ყოველთვის ინახება მიმდინარე მონაცემთა ბაზაში, შესაძლებელია დროებითი შენახული პროცედურების შექმნა, რომლებიც ყოველთვის მოთავსებულია სისტემის დროებით მონაცემთა ბაზაში tempdb. დროებით შენახული პროცედურების შექმნის ერთ-ერთი მიზეზი შეიძლება იყოს მონაცემთა ბაზასთან დაკავშირებისას განცხადებების კონკრეტული ჯგუფის განმეორებითი შესრულების თავიდან აცილება. თქვენ შეგიძლიათ შექმნათ ადგილობრივი ან გლობალური დროებითი პროცედურები. ამისთვის ლოკალური პროცედურის სახელწოდება მითითებულია ერთი # სიმბოლოთი (#proc_name), ხოლო გლობალური პროცედურის სახელი მითითებულია ორმაგით (## proc_name).
ადგილობრივი დროებით შენახული პროცედურა შეიძლება შესრულდეს მხოლოდ მომხმარებლის მიერ, რომელმაც შექმნა იგი და მხოლოდ მონაცემთა ბაზასთან კავშირის დროს, რომელშიც ის შეიქმნა. გლობალური დროებითი პროცედურა შეიძლება შესრულდეს ყველა მომხმარებლის მიერ, მაგრამ მხოლოდ ბოლო კავშირის დასრულებამდე, რომელშიც ის შესრულდება (ჩვეულებრივ, პროცედურის შემქმნელის კავშირი).
შენახული პროცედურის სასიცოცხლო ციკლი შედგება ორი ეტაპისგან: მისი შექმნა და შესრულება. თითოეული პროცედურა იქმნება ერთხელ და შესრულებულია არაერთხელ. შენახული პროცედურა ახორციელებს შეასრულეთ განცხადებებიმომხმარებელი, რომელიც ფლობს პროცედურას ან აქვს ამ პროცედურაზე წვდომის ნებართვა EXECUTE. EXECUTE განცხადებას აქვს შემდეგი სინტაქსი:
[] [@return_status =] (პროკის_სახელი | @proc_name_var) ([[@ პარამეტრი1 =] მნიშვნელობა | [@ პარამეტრი1 =] @ცვლადი] | ნაგულისხმევი) .. სინტაქსური კონვენციები
გარდა return_status პარამეტრისა, EXECUTE განცხადების ყველა პარამეტრს აქვს იგივე ლოგიკური მნიშვნელობა, რაც იმავე სახელწოდების პარამეტრებს CREATE PROCEDURE განცხადებისთვის. return_status პარამეტრი განსაზღვრავს მთელი რიცხვის ცვლადს, რომელიც ინახავს პროცედურის დაბრუნების მდგომარეობას. მნიშვნელობა შეიძლება მიენიჭოს პარამეტრს მუდმივის (მნიშვნელობის) ან ლოკალური ცვლადის (@variable) გამოყენებით. დასახელებული პარამეტრების მნიშვნელობების თანმიმდევრობა არ არის მნიშვნელოვანი, მაგრამ უსახელო პარამეტრების მნიშვნელობები უნდა იყოს მიწოდებული იმ თანმიმდევრობით, რომლითაც ისინი განისაზღვრება CREATE PROCEDURE განცხადებაში.
DEFAULT პუნქტიუზრუნველყოფს ნაგულისხმევ მნიშვნელობებს პროცედურის პარამეტრისთვის, რომელიც მითითებულია პროცედურის განმარტებაში. შეცდომა ჩნდება, როდესაც პროცედურა მოელის მნიშვნელობას იმ პარამეტრისთვის, რომლისთვისაც ნაგულისხმევი მნიშვნელობა არ არის განსაზღვრული და არ არის მითითებული პარამეტრი, ან მითითებულია საკვანძო სიტყვა DEFAULT.
როდესაც EXECUTE განცხადება არის პირველი განცხადება ჯგუფში, EXECUTE საკვანძო სიტყვა შეიძლება გამოტოვდეს. თუმცა, უფრო უსაფრთხოა ამ სიტყვის ჩართვა ყველა პაკეტში. EXECUTE განაცხადის გამოყენება ნაჩვენებია ქვემოთ მოცემულ მაგალითში:
გამოიყენეთ SampleDb; EXECUTE IncreaseBudget 10;
EXECUTE განცხადება ამ მაგალითში ახორციელებს IncreaseBudget შენახულ პროცედურას, რომელიც ზრდის ყველა პროექტის ბიუჯეტს 10%-ით.
ქვემოთ მოყვანილი მაგალითი გვიჩვენებს, თუ როგორ უნდა შექმნათ შენახული პროცედურა მონაცემების დასამუშავებლად Employee და Works_on ცხრილებში:
მაგალითში ModifyEmpId პროცედურა ასახავს შენახული პროცედურების გამოყენებას, როგორც რეფერენციული მთლიანობის პროცესის ნაწილს (ამ შემთხვევაში, Employee და Works_on ცხრილებს შორის). მსგავსი შენახული პროცედურა შეიძლება გამოყენებულ იქნას ტრიგერის განმარტებაში, რომელიც რეალურად ახორციელებს რეფერენციალურ მთლიანობას.
ქვემოთ მოყვანილი მაგალითი გვიჩვენებს OUTPUT პუნქტის გამოყენებას შენახულ პროცედურაში:
ეს შენახული პროცედურა შეიძლება შესრულდეს შემდეგი ინსტრუქციების გამოყენებით:
გამოაცხადეთ @quantityDeleteEmployee INT; EXECUTE DeleteEmployee @ empId = 18316, @ [ელფოსტა დაცულია] OUTPUT; PRINT N "წაშლილი თანამშრომლები:" + კონვერტირება (nvarchar (30), @quantityDeleteEmployee);
ეს პროცედურა ითვლის პროექტების რაოდენობას, რომლებზეც დაკავებულია თანამშრომელი პერსონალის ნომრით @empId და მიღებულ მნიშვნელობას ანიჭებს პარამეტრს © მრიცხველს. პერსონალის მოცემული ნომრის ყველა მწკრივის წაშლის შემდეგ Employee და Works_on ცხრილებიდან, გამოთვლილი მნიშვნელობა ენიჭება @quantityDeleteEmployee ცვლადს.
პარამეტრის მნიშვნელობა უბრუნდება გამოძახების პროცედურას მხოლოდ იმ შემთხვევაში, თუ მითითებულია OUTPUT ვარიანტი. ზემოთ მოყვანილ მაგალითში, DeleteEmployee პროცედურა გადასცემს @counter პარამეტრს გამოძახების პროცედურას, ამიტომ შენახული პროცედურა სისტემას უბრუნებს მნიშვნელობას. ამიტომ, @counter პარამეტრი უნდა იყოს მითითებული როგორც OUTPUT ოფციაში პროცედურის გამოცხადებისას, ასევე EXECUTE განცხადებაში მისი გამოძახებისას.
WITH RESULTS ადგენს EXECUTE განცხადების პუნქტს
SQL Server 2012-ში შეყვანილია EXECUTE განცხადება შედეგების კომპლექტით პუნქტი, რომლის მეშვეობითაც გარკვეული პირობების დაკმაყოფილებისას შეგიძლიათ შეცვალოთ შენახული პროცედურის შედეგის ნაკრების ფორმა.
შემდეგი ორი მაგალითი დაგეხმარებათ ამ წინადადების ახსნაში. პირველი მაგალითი არის შესავალი მაგალითი, რომელიც გვიჩვენებს, თუ როგორი შეიძლება იყოს შედეგი, როდესაც WITH RESULTS STS პუნქტი გამოტოვებულია:
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 სერვერი მხარს უჭერს Common Language Runtime-ს (CLR), რომელიც საშუალებას გაძლევთ განავითაროთ მონაცემთა ბაზის სხვადასხვა ობიექტები (შენახული პროცედურები, UDF, ტრიგერები, UDF და UDD) C # და Visual Basic-ის გამოყენებით. CLR ასევე საშუალებას გაძლევთ შეასრულოთ ეს ობიექტები საერთო Runtime სისტემის გამოყენებით.
CLR დაშვებულია და უარყოფილია ოფციონის მიერ clr_enabledსისტემური პროცედურა sp_configure, რომელიც დაწყებულია შესასრულებლად ინსტრუქციით ხელახლა კონფიგურაცია... ქვემოთ მოყვანილი მაგალითი გვიჩვენებს, თუ როგორ შეიძლება CLR-ის ჩართვა sp_configure სისტემის პროცედურის გამოყენებით:
გამოიყენეთ SampleDb; EXEC sp_configure "clr_enabled", 1 RECONFIGURE
CLR-ის გამოყენებით პროცედურის შესაქმნელად, შედგენისა და შესანახად, თქვენ უნდა შეასრულოთ ნაბიჯების შემდეგი თანმიმდევრობა, თანმიმდევრობით:
შექმენით შენახული პროცედურა C #-ში ან Visual Basic-ში და შემდეგ შეადგინეთ იგი შესაბამისი კომპილერის გამოყენებით.
ინსტრუქციის გამოყენებით ასამბლეის შექმნა, შექმენით შესაბამისი შესრულებადი ფაილი.
შეასრულეთ პროცედურა EXECUTE განაცხადის გამოყენებით.
ქვემოთ მოყვანილი ფიგურა გვიჩვენებს ადრე აღწერილი ნაბიჯების დიაგრამას. ქვემოთ მოცემულია ამ პროცესის უფრო დეტალური აღწერა.
პირველი, შექმენით საჭირო პროგრამა განვითარების გარემოში, როგორიცაა Visual Studio. შეადგინეთ დასრულებული პროგრამა ობიექტის კოდისთვის C # ან Visual Basic შემდგენელის გამოყენებით. ეს კოდი ინახება დინამიური ბმული ბიბლიოთეკის (.dll) ფაილში, რომელიც არის CREATE ASSEMBLY განაცხადის წყარო, რომელიც წარმოქმნის შესრულებად შუალედურ კოდს. შემდეგი, გაუშვით CREATE PROCEDURE განცხადება, რათა შეინახოთ შესრულებადი კოდი მონაცემთა ბაზის ობიექტად. და ბოლოს, გაუშვით პროცედურა ნაცნობი EXECUTE განაცხადის გამოყენებით.
ქვემოთ მოყვანილი მაგალითი გვიჩვენებს C #-ში შენახული პროცედურის წყაროს კოდს:
System.Data.SqlClient-ის გამოყენებით; Microsoft.SqlServer.Server-ის გამოყენებით; საჯარო ნაწილობრივი კლასი StoredProcedures (საჯარო სტატიკური int CountEmployees () (int რიგები; SqlConnection კავშირი = ახალი SqlConnection ("კონტექსტური კავშირი = true"); კავშირი.Open (); SqlCommand cmd = კავშირი.CreateCommand (); cmd.CommandText = "select დაითვალეთ (*) როგორც "თანამშრომლების რაოდენობა" "+" თანამშრომლისგან "; რიგები = (int) cmd.ExecuteScalar (); კავშირი. დახურვა (); დაბრუნების რიგები;))
ეს პროცედურა ახორციელებს მოთხოვნას Employee ცხრილის რიგების რაოდენობის დასათვლელად. პროგრამის დასაწყისში გამოყენების დირექტივები განსაზღვრავს პროგრამის შესასრულებლად საჭირო სახელთა სივრცეებს. ამ დირექტივების გამოყენება საშუალებას გაძლევთ მიუთითოთ კლასების სახელები საწყის კოდში, შესაბამისი სახელების სივრცის მკაფიოდ მითითების გარეშე. შემდეგი, განისაზღვრა StoredProcedures კლასი, რისთვისაც SqlProcedure ატრიბუტირომელიც აცნობებს შემდგენელს, რომ ეს კლასი არის შენახული პროცედურა. CountEmployees () მეთოდი განსაზღვრულია კლასის კოდის შიგნით. მონაცემთა ბაზის სისტემასთან კავშირი მყარდება კლასის ინსტანციის საშუალებით SqlConnection... კავშირის გასახსნელად გამოიყენება ამ მაგალითის Open () მეთოდი. ა CreateCommand () მეთოდისაშუალებას გაძლევთ შეხვიდეთ კლასის მაგალითზე SqlCommndრომელსაც გადაეცემა საჭირო SQL ბრძანება.
კოდის შემდეგ ნაწყვეტში:
Cmd.CommandText = "აირჩიეთ რაოდენობა (*) როგორც" თანამშრომელთა რაოდენობა "" + "თანამშრომლისგან";
იყენებს SELECT განცხადებას Employee ცხრილის რიგების რაოდენობის დასათვლელად და შედეგის საჩვენებლად. ბრძანების ტექსტი მითითებულია 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 = SAFE
CREATE ASSEMBLY განცხადება იღებს მართულ კოდს, როგორც შეყვანას და ქმნის შესაბამის ობიექტს, რომლისთვისაც შეგიძლიათ შექმნათ CLR შენახული პროცედურები, UDF-ები და ტრიგერები. ამ განცხადებას აქვს შემდეგი სინტაქსი:
CREATE ASSEMBLY assembly_name [AUTHORIZATION owner_name] FROM (dll_file) სინტაქსური კონვენციებიდან
Assembly_name განსაზღვრავს ასამბლეის სახელს. არასავალდებულო AUTHORIZATION პუნქტი განსაზღვრავს როლის სახელს, როგორც ამ ასამბლეის მფლობელი. FROM პუნქტი განსაზღვრავს გზას, სადაც განთავსებულია ჩატვირთვის ასამბლეა.
PERMISSION_SET პუნქტითარის CREATE ASSEMBLY განცხადების ძალიან მნიშვნელოვანი პუნქტი და ყოველთვის უნდა იყოს შეტანილი. იგი განსაზღვრავს ასამბლეის კოდს მინიჭებული წვდომის უფლებების ერთობლიობას. უფლებების უსაფრთხო ნაკრები ყველაზე შემზღუდველია. ასამბლეის კოდს, რომელსაც აქვს ეს უფლებები, არ შეუძლია წვდომა სისტემის გარე რესურსებზე, როგორიცაა ფაილები. EXTERNAL_ACCESS პრივილეგიების ნაკრები საშუალებას აძლევს ასამბლეის კოდს წვდომა ჰქონდეს კონკრეტული გარე სისტემის რესურსებზე, ხოლო UNSAFE პრივილეგიების ნაკრები იძლევა შეუზღუდავ წვდომას რესურსებზე, როგორც მონაცემთა ბაზის სისტემაში, ასევე მის გარეთ.
მომხმარებელს უნდა შეეძლოს შეასრულოს CREATE ASSEMBLY განცხადება ასამბლეის კოდის შესახებ ინფორმაციის შესანარჩუნებლად. ასამბლეა ეკუთვნის მომხმარებელს (ან როლს), რომელიც ახორციელებს ამ განცხადებას. შეგიძლიათ ასამბლეის მფლობელი სხვა მომხმარებელი გახადოთ CREATE SCHEMA განაცხადის AUTHORIZATION პუნქტის გამოყენებით.
მონაცემთა ბაზის ძრავა ასევე მხარს უჭერს ALTER ASSEMBLY და DROP ASSEMBLY განცხადებებს. ALTER ASSEMBLY განცხადებაგამოიყენება ასამბლეის უახლესი ვერსიის განახლებისთვის. ეს განცხადება ასევე ამატებს ან შლის ფაილებს, რომლებიც დაკავშირებულია შესაბამის ასამბლეასთან. DROP ASSEMBLY განცხადებაშლის მითითებულ ასამბლეას და ყველა დაკავშირებულ ფაილს მიმდინარე მონაცემთა ბაზიდან.
ქვემოთ მოყვანილი მაგალითი გვიჩვენებს, თუ როგორ უნდა შექმნათ შენახული პროცედურა მართული კოდის საფუძველზე, რომელიც ადრე დანერგეთ:
გამოიყენეთ SampleDb; GO CREATE PROCEDURE CountEmployees AS EXTERNAL NAME 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 განცხადება აბრუნებს მწკრივების მიმდინარე რაოდენობას Employee ცხრილში.
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 ოპერატორი. ამ ოპერატორთან მოთხოვნების ჩამოყალიბების გასაადვილებლად ( მოგეხსენებათ, 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 - ინსტრუქცია მონაცემების დამატების ჩასმა TestTable-ში (CategoryId, ProductName, Price) (1 , "მაუსი", 100), (1, "კლავიატურა", 200), (2, "ტელეფონი", 400) GO --აირჩიეთ მოთხოვნა SELECT * FROM TestTable
მონაცემები არსებობს, ახლა მოდით გადავიდეთ შენახული პროცედურების შექმნაზე.
T-SQL შენახული პროცედურის შექმნა - CREATE PROCEDURE განაცხადი
შენახული პროცედურები იქმნება განცხადების გამოყენებით პროცედურების შექმნა, ამ ინსტრუქციის შემდეგ, თქვენ უნდა დაწეროთ თქვენი პროცედურის დასახელება, შემდეგ, საჭიროების შემთხვევაში, განსაზღვროთ შეყვანის და გამომავალი პარამეტრების ფრჩხილებში. ამის შემდეგ თქვენ წერთ AS საკვანძო სიტყვას და ხსნით ინსტრუქციების ბლოკს BEGIN საკვანძო სიტყვით, ხურავთ ამ ბლოკს END სიტყვით. ამ ბლოკის შიგნით თქვენ წერთ ყველა ინსტრუქციას, რომელიც ახორციელებს თქვენს ალგორითმს ან რაიმე სახის თანმიმდევრულ გამოთვლას, სხვა სიტყვებით რომ ვთქვათ, თქვენ დაპროგრამებთ 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 განცხადებაში
თქვენ შეგიძლიათ ცვლილებები შეიტანოთ პროცედურის ალგორითმში ინსტრუქციის გამოყენებით შეცვალეთ პროცედურა... სხვა სიტყვებით რომ ვთქვათ, იმისათვის, რომ შეცვალოთ არსებული პროცედურა, თქვენ უბრალოდ უნდა დაწეროთ ALTER PROCEDURE ნაცვლად CREATE 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 განაცხადი
საჭიროების შემთხვევაში, შეგიძლიათ წაშალოთ შენახული პროცედურა, ეს კეთდება ინსტრუქციის გამოყენებით ჩამოშვების პროცედურა.
მაგალითად, წავშალოთ ჩვენ მიერ შექმნილი ტესტის პროცედურა.
ვარდნის პროცედურა ტესტიპროცედურა
შენახული პროცედურების წაშლისას გაითვალისწინეთ, რომ თუ პროცედურას სხვა პროცედურებით ან SQL განცხადებებით მიმართავენ, წაშლის შემდეგ ისინი მარცხდებიან, რადგან პროცედურა, რომელსაც ისინი მიუთითებენ, აღარ არსებობს.
ყველაფერი მაქვს, იმედია მასალა თქვენთვის საინტერესო და სასარგებლო იყო, ჯერჯერობით!
