ms SQL პროცედურები. პროცედურების შექმნა, რომლებიც ინახება microsoft sql სერვერზე. RETURN-ის გამოყენება შენახულ პროცედურაში
ჩართეთ თქვენს პროცედურაში სტრიქონი - SET NOCOUNT ON:
კანისთვის მოსახერხებელი DML ვირუსით, SQL სერვერი დაუყოვნებლივ გვეუბნება, რომ შურისძიება უნდა მოხდეს ჩაწერილი ჩანაწერების რაოდენობაზე. მოცემული ინფორმაცია შეიძლება სწორი იყოს ჩვენთვის კოდის საათში, მაგრამ ამის შემდეგ იქნება აბსოლუტურად კარგი. SET NOCOUNT ON წერით ჩვენ ვააქტიურებთ ამ ფუნქციას. პროცედურების დაზოგვის მიზნით, აუცილებელია ვირუსების რაოდენობის ამოღება, ან მოცემულია ციკლები, რამაც შეიძლება მნიშვნელოვნად გაზარდოს პროდუქტიულობა, ამიტომ ტრაფიკის რაოდენობა მნიშვნელოვნად შემცირდება.
ტრანსაქცია SQL
Vykoristovuy im'ya სქემები im'yam ობიექტით:
ხო, აქ მგონი ზრაზმილო. ოპერაცია მოცემულია იმისათვის, რომ სერვერს უთხრას de shukati ob'єkti და zamіst რომ, ტირილი ურცხვად nisporit თქვენს zasіkah, ჩვენ ზუსტად ვიცით სად უნდა დალიოთ და რა მივიღოთ. დიდი რაოდენობით ბაზების, ცხრილებისა და პროცედურების შენახვით, მას შეუძლია დაზოგოს ჩვენი დრო და ნერვები.
ტრანსაქცია SQL
SELECT * FROM dbo.MyTable -- ღერძი ძალიან კარგია -- ჩაანაცვლეთ SELECT * FROM MyTable -- და ეს ცუდია -- EXEC პროცედურა დარეკეთ dbo.MyProc -- ბოდიშს გიხდით კიდევ -- შეცვალეთ EXEC MyProc -- ცუდი!
არ გამოიყენოთ "sp_" პრეფიქსი თქვენი პროცედურების სახელებში, რომლებიც აცილებულია:
ფაქტობრივად, ჩვენი პროცედურა ეფუძნება sp_, SQL სერვერს პირველ რიგში მის ძირითად მონაცემთა ბაზაში. მარჯვნივ, მოცემული პრეფიქსი არჩეულია სპეციალური შიდა სერვერის პროცედურებისთვის, რომლებიც ინახება. ეს იოგას ექსპერიმენტი შეიძლება მიიყვანოს დამატებით ვიტრატებამდე და გამოიღოს არასწორი შედეგი, რადგან პროცედურა იგივე სახელებით, როგორიც თქვენია, ნახავთ იოგას მონაცემთა ბაზაში.
შეცვალეთ IF EXISTS (აირჩიეთ 1) ნაცვლად IF EXISTS (SELECT *):
შემდეგ ცხრილში ჩანაწერის გარეგნობის შესაცვლელად, ჩვენ ვიმარჯვებთ IF EXISTS viraz. დანიური ფანჯარა გამოდის ჭეშმარიტი, ასე რომ, თუნდაც ერთი მნიშვნელობა, არ არის მნიშვნელოვანი "1", ყველა სვეტი ან ცხრილი გადაბრუნებულია შიდა ფანჯრიდან. Vіdomі danі, პრინციპში არ vikoristovuyutsya. ამ გზით, მონაცემთა გადაცემის საათზე ტრაფიკის გასააქტიურებლად, უფრო ლოგიკურია "1"-ის ცემა, როგორც ეს ნაჩვენებია ქვემოთ.
Microsoft SQL Server-მა უნდა განახორციელოს და ავტომატიზირდეს საკუთარი ალგორითმები ( როზრახუნკოვი) შეგიძლიათ დაამარცხოთ შენახული პროცედურები, ამიტომ დღეს ვისაუბრებთ იმაზე, თუ როგორ იქმნება, იცვლება და ქრება სუნი.
ცოტა თეორია, ასე რომ თქვენ გაარკვიეთ რა პროცედურებია, რა არის შენახული და რატომ გჭირდებათ სუნი T-SQL-ში.
Შენიშვნა! პროგრამისტებისთვის მე გირჩევთ შემდეგ ძირითად მასალებს T-SQL თემაზე:
- T-SQL ენის დეტალური გაგებისთვის, ასევე გირჩევთ წაიკითხოთ წიგნი - The Way of the T-SQL Programmer. Self Reader for Transact-SQL;
- პროფესიონალური ონლაინ კურსები T-SQL-ით
რა პროცედურები ინახება T-SQL-ში?
შენახვის პროცედურები- მონაცემთა ბაზის ყველა ობიექტი, რომელსაც აქვს ალგორითმი, როგორც SQL ინსტრუქციების ნაკრები. სხვა სიტყვებით რომ ვთქვათ, შეგვიძლია ვთქვათ, რომ პროცედურები, რომლებიც შენახულია, არის პროგრამები მონაცემთა ბაზის შუაში. შენახვის პროცედურები ინახება სერვერზე ხელახლა გაყვანილი კოდის შესანახად, მაგალითად, თქვენ დაწერეთ რაიმე სახის ალგორითმი, ბოლო, ან მდიდარი SQL ინსტრუქცია, ისე, რომ ერთხელ თქვენ არ მოიგოთ ყველა ინსტრუქცია, რომელიც შედის მასში. ალგორითმი, შეგიძლიათ შეამოწმოთ პროცედურები. ამ შემთხვევაში, თუ თქვენ შექმნით SQL პროცედურას, სერვერი შეადგენს კოდს და შემდეგ, როდესაც SQL პროცედურას აწარმოებთ სკინზე, სერვერი აღარ შეადგენს მას.
SQL Server-ში შენახული პროცედურის გასაშვებად აუცილებელია ზარის წინ ჩაწეროთ EXECUTE ბრძანება, ან შეგიძლიათ დაწეროთ EXEC ბრძანების სტენოგრამა. გამოძახების პროცედურას შევინახავ SELECT განცხადებაში, მაგალითად, რადგან ფუნქციას ვერ ვხედავ, ესე იგი. პროცედურები დაწყებულია ოკრემოში.
პროცედურებისთვის, რომლებიც შენახულია ფუნქციების სანახავად, ასევე შესაძლებელია მონაცემთა მოდიფიკაციის ოპერაციების უგულებელყოფა, როგორიცაა: UNSERT, UPDATE, DELETE. ასევე პროცედურებში შესაძლებელია SQL ინსტრუქციების შეცვლა პრაქტიკულად ნებისმიერი ტიპის, მაგალითად CREATE TABLE EXECUTE ცხრილის შექმნამდე, შემდეგ. ყოველკვირეული სხვა პროცედურები. არსებობს უამრავი სახის ინსტრუქცია, როგორიცაა: ფუნქციების შექმნა ან შეცვლა, გარეგნობა, ტრიგერები, სქემების შექმნა და რამდენიმე სხვა მსგავსი ინსტრუქცია, მაგალითად, ასევე შეუძლებელია იმ პროცედურაში, რომელიც აღებულია, გადართვა. მონაცემთა ბაზასთან (USE) კავშირის კონტექსტში.
პროცედურა შენახულია, შეგიძლიათ შეცვალოთ შეყვანის პარამეტრები და გამომავალი პარამეტრები, შეგიძლიათ ტაბულური მონაცემების როტაცია, თქვენ არ შეგიძლიათ არაფრის როტაცია, უბრალოდ შეცვალეთ ჩანაწერები ინსტრუქციებში.
შენახვის პროცედურები უფრო რთულია, სუნი გვეხმარება ბევრი ოპერაციის ავტომატიზაციაში და გამარტივებაში, მაგალითად, დაგჭირდებათ ანალიტიკური მონაცემების სხვადასხვა ნაკეცების ჩამოყალიბება დამატებითი ცხრილებით, ტობტო. PIVOT ოპერატორი. მოითხოვეთ სასმელის ფორმირება cym ოპერატორისგან ( მოგეხსენებათ, 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 -- მონაცემთა დამატება განცხადება ჩადეთ ტესტის ცხრილში (CategoryId, ProductName, Price (1) , "Misha", 100), (1, "Keyboard", 200), (2, "Phone", 400) GO --აირჩიე SELECT * FROM TestTable
დენი, ახლა გადავიდეთ დაზოგვის პროცედურების ჩამოყალიბებაზე.
შექმნილი პროცედურები, რომლებიც უნდა იქნას მიღებული T-SQL - CREATE PROCEDURE განცხადებაში
შენახვის პროცედურები იქმნება დამატებითი ინსტრუქციებისთვის პროცედურების შექმნაამ ინსტრუქციების შემდეგ, თქვენ პასუხისმგებელნი ხართ დაწეროთ თქვენი პროცედურის დასახელება, შემდეგ, მოხმარების დროს, მკლავებში დააყენოთ შეყვანის და გამომავალი პარამეტრები. მას შემდეგ რაც დაწერთ AS საკვანძო სიტყვას, გახსენით ინსტრუქციის ბლოკი BEGIN საკვანძო სიტყვით, დახურეთ ბლოკი END სიტყვით. გამოიყენეთ ბლოკის შუა ნაწილი თქვენ წერთ ინსტრუქციებს თქვენი ალგორითმის განსახორციელებლად, წინააღმდეგ შემთხვევაში, როგორც ჩანს, თქვენ პროგრამირდებით T-SQL-ში.
მაგალითად, დავწეროთ შენახვის პროცედურა, როგორიცაა ახალი ჩანაწერის დამატება, tobto. ახალი პროდუქტი ჩვენს სატესტო მაგიდაზე. ამისთვის მნიშვნელოვანია სამი შეყვანის პარამეტრი: @CategoryId – პროდუქტის კატეგორიის იდენტიფიკატორი, @ProductName — პროდუქტის დასახელება і @Price – პროდუქტის ფასი, ეს პარამეტრი იქნება ჩვენში neobov'azkoviy, tobto. იოგა არ შეიძლება გადავიდეს პროცედურაზე ( მაგალითად, ფასი არ ვიცით), ვისთვისაც იოგაში ენიჭება ჩაკეტვის მნიშვნელობა. Qi პარამეტრები პროცედურის ტიპისთვის, ტობტო. BEGIN ... END ბლოკში შეგიძლიათ გადატრიალდეთ, ასე რომ, ეს იგივეა, რაც პირველადი ცვლილება ( იაკ იცით, ცვლილება მითითებულია @ ნიშნით). თუ თქვენ გჭირდებათ გარე პარამეტრების მითითება, მაშინ პარამეტრის დასახელების შემდეგ მიუთითეთ საკვანძო სიტყვა OUTPUT ( ან შემცირდა OUT).
BEGIN…END ბლოკში ჩვენ დავწერთ დანამატის მონაცემებს, ასევე დასრულებულ SELECT დანამატის პროცედურაში, პროცედურა, რომელიც zberіgaєtsya, გადმოგვცა ცხრილის მონაცემები საქონლის შესახებ დანიშნულ კატეგორიაში ახალი, კარგად გაუმჯობესებით. დამატებული პროდუქტი. ასევე, ამ პროცედურაში დავამატე შეყვანის პარამეტრის დამუშავება და ყველაზე თვალსაჩინო დაკეცილი გაწმენდები კობზე და ტექსტის მწკრივის ბოლოს, სიტუაციის გამორიცხვის მეთოდით, თუ ჩირქოვანები შემოიტანეს.
ღერძის კოდის tsієї პროცედურები ( yogo მეც გავაკეთე კომენტარი).
პროცედურის შექმნა 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 ბრძანების მითითება). თუმცა, პარამეტრების სახელი შეიძლება გამოტოვოთ, მაგრამ სხვა შემთხვევაში აუცილებელია მნიშვნელობის მითითების თანმიმდევრობის დამატება, ანუ. შეიყვანეთ მნიშვნელობები იმ თანმიმდევრობით, რომლითაც მითითებულია შეყვანის პარამეტრები ( ღირებულება და გამომავალი პარამეტრები).
პარამეტრები, რომლებსაც შეიძლება ჰქონდეთ პოპულარიზაციის მნიშვნელობა, შეიძლება იყოს მითითებული ან არ იყოს მითითებული, როგორც ეგრეთ წოდებული neobov'yazykovі პარამეტრები.
პროცედურების გაშვების რამდენიმე განსხვავებული, თუმცა ექვივალენტური გზების ღერძი, რომლებიც შენახულია, არის ჩვენი ტესტის პროცედურის ბირთვი.
1. პროცედურის გამოძახება ფასის შეყვანის გარეშე EXECUTE TestProcedure @CategoryId = 1, @ProductName = "სატესტო პროდუქტი 1"-2. ჩვენ ვუწოდებთ პროცედურას მინიჭებული ფასიდან EXEC TestProcedure @CategoryId = 1, @ProductName = "სატესტო პროდუქტი 2", @Price = 300-3. პროცედურის გამოძახება პარამეტრის სახელის მითითების გარეშე EXEC TestProcedure 1, "Test Item 3", 400
პროცედურის შეცვლა, რომელიც აღებულია T-SQL - ALTER PROCEDURE განცხადებაში
დამატებითი ინსტრუქციებისთვის შეგიძლიათ ცვლილებები შეიტანოთ რობოტული პროცედურის ალგორითმში შეცვალეთ პროცედურა. ანუ უკვე არსებული პროცედურის შესაცვლელად საკმარისია CREATE PROCEDURE-ის ნაცვლად დაწეროთ ALTER PROCEDURE და საჭიროებისამებრ შეცვალოთ ყველაფერი.
ვთქვათ, ჩვენ გვჭირდება ცვლილებების შეტანა ჩვენი ტესტირების პროცედურაში, ვთქვათ @Price პარამეტრი, მაშინ. ფასი, რომლისთვისაც ჩვენ გავითვალისწინებთ აბრევიატურის მნიშვნელობას და ასევე ცხადი გახდება, რომ ჩვენ გვაქვს საჭიროება მიღებული მონაცემთა ნაკრების შეგროვებაში, რისთვისაც ჩვენ უბრალოდ ავიღებთ SELECT განცხადებას პროცედურისგან, რომ აღებულია.
პროცედურის შეცვლა ALTER PROCEDURE TestProcedure (--შეყვანის პარამეტრები @CategoryId INT, @ProductName VARCHAR(100), @Price MONEY) AS BEGIN -- ინსტრუქციები თქვენი ალგორითმის განხორციელების შესახებ -- შეყვანის პარამეტრების დამუშავება -- ამოიღეთ გვერდითი ხარვეზები კობზე და ტექსტის ბოლოს SET @ProductName = LTRIM(RTRIM(@ProductName)); --დაამატეთ ახალი ჩანაწერი INSERT INTO TestTable(CategoryId, ProductName, Price) VALUES (@CategoryId, @ProductName, @Price) END GO
პროცედურების ნახვა, რომლებიც აღებულია T-SQL - DROP PROCEDURE განაცხადი
საჭიროების შემთხვევაში, შეგიძლიათ ნახოთ პროცედურა, რომლის შენახვაც გჭირდებათ, ნუ დააყოვნებთ დამატებითი ინსტრუქციების მოთხოვნას ჩამოშვების პროცედურა.
მაგალითად, მოდით, აშკარად შევქმნათ ჩვენთვის ტესტის პროცედურა.
ვარდნის პროცედურა ტესტიპროცედურა
როდესაც ხედავთ პროცედურების დანაზოგს, გაიხსენეთ ისინი, რომ პროცედურა აღსრულდება სხვა პროცედურებით ან SQL ინსტრუქციებით, თუ ხედავთ, რომ სუნი დასრულდება პატიებით, პროცედურის ნატეხები, სუნისთვის, იქ აღარ არის.
მე ყველაფერი მაქვს, დარწმუნებული ვარ, მასალა კარგია თქვენთვის და ყავისფერი, ჯერჯერობით!
ბოლო განახლება: 14.08.2017
ხშირად, მონაცემებით ოპერაცია წარმოადგენს ინსტრუქციების ერთობლიობას, რადგან აუცილებელია სიმღერის თანმიმდევრობის დაცვა. მაგალითად, პროდუქტზე შესყიდვის დამატებისას საჭიროა ცხრილებში მონაცემების შეყვანა. თუმცა, cim-მდე უნდა გადაიხედოს და რა არის რეალურად ნაყიდი საქონელი. შესაძლოა, როდესაც თქვენ მოხდება დაბალი დოდატკოვის გონების გარდაქმნა. ეს არის რეალურად საქონლის ყიდვის პროცესი ohoplyuє kіlka dіy, yakі შეიძლება vykonuvatsya at pevnіy poslіdovnostі. І ამ გზით უფრო ოპტიმალურად აერთიანებს ყველაფერს ერთ ობიექტში - ჩასატარებელი პროცედურა(შენახული პროცედურა).
ტობტო იმ პროცედურის არსებითად, რომელიც გათვალისწინებულია, წარმოადგენს ინსტრუქციების ერთობლიობას, რადგან ისინი სრულდება როგორც ერთიანი მთლიანობა. თავად პროცედურები, რომლებიც შენახულია, იძლევა მარტივ კომპლექსურ ოპერაციებს და მათ ერთ ობიექტში დადანაშაულებას. შეცვალეთ საქონლის ყიდვის პროცესი, საკმარისი არ არის პროცედურის კოდის შესაცვლელად. ეს პროცედურა ასევე ითხოვს კოდს.
ასევე, შენახული პროცედურები საშუალებას გაძლევთ დაბლოკოთ ცხრილების მონაცემებზე წვდომა და, იმავე პრინციპით, შეცვალოთ ამ ან ამოუცნობი, უმნიშვნელო მონაცემების უძრავობა.
კიდევ ერთი მნიშვნელოვანი ასპექტია პროდუქტიულობა. პროცედურების შენახვა უკეთესად ჟღერს, დაბალი ხმოვანი SQL-ინსტრუქციები. ყველაფერი, რაც პროცედურის კოდი შედგენილია ერთხელ პირველი გაშვების დროს, შემდეგ კი ინახება კომპილირებული ფორმით.
პროცედურის შესაქმნელად შეჩერებულია ბრძანება CREATE PROCEDURE ან CREATE PROC.
ამ გზით, შენახულ პროცედურას აქვს სამი ძირითადი მახასიათებელი: კოდის სიმარტივე, უსაფრთხოება და პროდუქტიულობა.
მაგალითად, მიეცით მონაცემთა ბაზას ჰქონდეს ცხრილი, რათა შეაგროვოთ მონაცემები საქონლის შესახებ:
CREATE TABLE Products (ID INT IDENTITY PRIMARY KEY, პროდუქტის სახელი NVARCHAR(30) NOT NULL, მწარმოებელი NVARCHAR(20) NOT NULL, ProductCount INT DEFAULT 0, Price MONEY NOT NULL);
მოდით შევქმნათ პროცედურა, რომელიც აღებულია მოცემული ცხრილებიდან მონაცემების შესამოწმებლად:
გამოიყენე პროდუქტებიdb; GO CREATE PROCEDURE პროდუქტის შეჯამება AS SELECT პროდუქტის სახელი როგორც პროდუქტი, მწარმოებელი, ფასი პროდუქტებიდან
თუმცა, CREATE PROCEDURE ბრძანება პასუხისმგებელია ორიგინალური პაკეტის გამოძახებაზე, მაგრამ USE ბრძანების შემდეგ, ნაკადის მონაცემთა ბაზის დაყენების მიზნით, GO ბრძანება გამოიძახება ახალი პაკეტის დასანიშნად.
პროცედურის სახელწოდების შემდეგ შეგიძლიათ გამოიყენოთ AS საკვანძო სიტყვა.
სკრიპტში პროცედურის სხეულის დასამატებლად, პროცედურის კოდი ხშირად მოთავსებულია BEGIN...END ბლოკში:
გამოიყენე პროდუქტებიdb; GO CREATE PROCEDURE ProductSsummary AS BEGIN SELECT ProductName AS Product, მწარმოებელი, ფასი Products END;
პროცედურების დამატების შემდეგ შეგვიძლია ვიმუშაოთ მონაცემთა ბაზის კვანძთან SQL Server Management Studio-ში ქვე კვანძში პროგრამირებადობა -> შენახული პროცედურები:
ჩვენ ასევე შეგვიძლია ჩავატაროთ პროცედურა ვიზუალური ინტერფეისის საშუალებით.
ვიკონანის პროცედურები
პროცედურის შესანახად, ბრძანება EXEC ან EXECUTE ეწოდება:
EXEC პროდუქტის რეზიუმე
VIDALENNYA პროცედურები
პროცედურის გასაშლელად, გამოიძახება DROP PROCEDURE ბრძანება:
ჩამოშვების პროცედურა პროდუქტის შეჯამება
შენახვის პროცედურები
ამ განაწილების საგანი არის ერთ-ერთი ყველაზე რთული ინსტრუმენტი, რომელიც გააცნო საცალო ვაჭრობას InterBase მონაცემთა ბაზების დამატებით ბიზნეს ლოგიკის განსახორციელებლად. და შეცვალეთ დავალებული ამოცანების ასარჩევად საჭირო კოდის რაოდენობა, თუ თქვენ გჭირდებათ დამატებითი მონაცემთა ბაზების დამატება, შენახული პროცედურების შეცვლის გარეშე არ შეგიძლიათ.
Krіm tsikh ფართოდ vodomih vіdomih vіdomih vіdomih protsіnі іnіv, scho vіdomih vіdomih vikoristannya scho sho vіdіgayutsya, zagalny іn bolshostі რელაციური DBMS, პროცედურები საშუალებას გაძლევთ ითამაშოთ InterBase-ის როლი, scho შეასრულოთ. შედეგები SQL შეკითხვებში.
როსობნიკები, ხშირად უბიძგებენ, სწავლობენ სობერეჟეჟეს პროცედურებს მხოლოდ იაკ ნაბირი კონკრეტული sql-zapitiv, იაკი პანსიონი სერიოზულად გარუჯულ ტანკებს და პრაზუვატი, ნაბჰაგატო, ნიბაგატო, ნიჟ რენიტაციები ამავე დროს მაღალ დონეზე.
რა არის პროცედურები, რომლებიც ინახება InterBase-ში?
შენახული პროცედურა (CP) არის მონაცემთა ბაზის მეტამონაცემების ნაწილი, რომელიც არის ქვეპროგრამა, რომელიც შედგენილია შიდა InterBase აპლიკაციიდან, დაწერილი სპეციალურ ენაზე, ერთგვარი ინდუქციის შემდგენელი InteiBase სერვერის ბირთვში.
პროცედურის არჩევისას, შეგიძლიათ აირჩიოთ კლიენტის დამატებებიდან, ტრიგერებიდან და სხვა შენახული პროცედურებიდან. პროცედურა ინახება სერვერის პროცესის შუაში და შეგიძლიათ მანიპულირება მოახდინოთ მონაცემთა ბაზაში, ასევე გადააბრუნოთ კლიენტი, რომ დააწკაპუნოთ (ეს ტრიგერები, HP, დამატება) თქვენი მოგების შედეგებზე.
HP-ის მიერ დაწესებული რთული შესაძლებლობების საფუძველია პროცედურული ენის პროგრამირება, რომელსაც შეუძლია შეცვალოს დიდი SQL-ის წინადადებები მის საწყობში, როგორიცაა INSERT, UPDATE და SELECT, ასევე პარსინგისა და მარყუჟების ორგანიზება (IF, WHILE). ისევე როგორც შეწყალების და გაუმართავი სიტუაციების უპირატესობები Mova-ს პროცედურები, რომლებიც შენახულია, საშუალებას გაძლევთ განახორციელოთ მონაცემებით მუშაობის დასაკეცი ალგორითმები, ხოლო HP-ის რელაციურ მონაცემებთან მუშაობაზე ფოკუსირება შეიძლება მნიშვნელოვნად კომპაქტური იყოს მსგავსი პროცედურებისთვის ტრადიციულ ენაზე.
უნდა აღინიშნოს, რომ ტრიგერი იმარჯვებს იმავე პროგრამით, დანაშაული დაბალია ფუნქციებითა და საზღვრით. Vіdminnosti pіdmіnnosti movі, scho і trigery, vіd movі KHP გავრცელებული ინფორმაციით ათვალიერებდა დისტრიბუციას "Trigery" (1 წელი).
მარტივი პროცედურის მაგალითი, რომელიც შენახულია
დადგა საათი, რომ შეიქმნას პირველი პროცედურა, რომელიც შენახულია, ხოლო її კონდახზე, პროცედურების შექმნის პროცესი, რომლებიც შენახულია. ალე შემდეგის დასაწყისისთვის რამდენიმე სიტყვით რომ ვთქვათ, როგორ ვივარჯიშოთ იმ პროცედურებთან, რომლებიც შენახულია. InterBase დოკუმენტაცია გირჩევთ შექმნათ პროცედურები დამატებითი ფაილებისთვის SQL სკრიპტებში, რომლებიც გაასუფთავებს HP-ს ტექსტს, რადგან ისინი გადაეცემა isql თარჯიმნის შეყვანას და ამ გზით შექმნას HP-ის მოდიფიკაცია ამ SQL სკრიპტში. BLR პროცედურის ტექსტში შედგენის ეტაპი (BLR პროცედურის ტექსტის შესახებ მე დავყავი "InterBase მონაცემთა ბაზების სტრუქტურა" (ნაწილი 4)) შეწყალების შემდეგ, შემდეგ isql გეტყვით მათ შესახებ, რომელ სტრიქონშია SQL სკრიპტის ფაილს აქვს შეწყალება. შეასწორეთ შეწყალება და გაიმეორეთ ყველაფერი უკან. Nagodzhennya-ს შესახებ სიტყვის ყოველდღიურ გაგებაში, ანუ ტრასუვანია ვიკონანიას შესახებ, ცვლილების ცვალებად მნიშვნელობებით გაოცების შესაძლებლობით, თქვენ არ შეგიძლიათ გახვიდეთ თქვენს გზაზე. აშკარაა, რომ ასეთი პიდჰიდი არ ემთხვევა საცალო ვაჭრობის თვალში შენახული პროცედურების კონფიდენციალურობის გაზრდას.
თუმცა, კრემი სტანდარტული მინიმალისტური მიდგომის განვითარების HP<_\ществ\ют также
инструменты сторонних разработчиков, которые делают работу с хранимыми
процедурами весьма удобной Большинство универсальных продуктов для работы с
InterBase, перечисленных в приложении "Инструменты администратора и разработчика
InterBase", предоставляют удобный инструментарий для работы с ХП. Мы рекомендуем
обязательно воспользоваться одним из этих инструментов для работы с хранимыми
процедурами и изложение материала будем вести в предположении, что у вас имеется
удобный GUI-инструмент, избавляющий от написания традиционных SQL-скриптов
შენახული პროცედურების სინტაქსი აღწერილია შემდეგი ნაბიჯით:
CREATE PROCEDURE სახელი
[(param datatype [, param datatype...])]
)]
ას
< procedure_body> =
[
<
block>
< vanable_declaration_list>
=
DECLARE VARIABLE var მონაცემთა ტიპი;
დასაწყისი
< compound_statement>
[< compound_statement> ...]
ᲓᲐᲡᲐᲡᲠᲣᲚᲘ
< compound_statement> =
(
ერთი შეხედვით, დიდი ზომისაა და შეიძლება იყოს რთული, მაგრამ სინამდვილეში ყველაფერი კიდევ უფრო მარტივია.
ისევ, კონდახის ღერძი არის მარტივი პროცედურა, რომელიც კეთდება, რადგან ის იღებს ორ რიცხვს, როგორც შეყვანის სახით, აგროვებს მათ და აბრუნებს შედეგს:
CREATE PROCEDURE SP_Add(first_arg DOUBLE PRECISION,
second_arg ორმაგი სიზუსტე)
დაბრუნება (შედეგი ორმაგი სიზუსტით)
ას
დასაწყისი
შედეგი=პირველი_არგ+მეორე_არგ;
შეჩერება;
ᲓᲐᲡᲐᲡᲠᲣᲚᲘ
ზუსტად ასე, ყველაფერი მარტივია: CREATE PROCEDURE ბრძანების შემდეგ მითითებულია ახლად შექმნილი პროცედურის სახელი (რომელიც შეიძლება იყოს უნიკალური მონაცემთა ბაზის საზღვრებში) - დროდადრო SP_Add, შემდეგ კი მხრებზე, რომლის მეშვეობითაც შეყვანილი პარამეტრები. HP გადატვირთულია - first_arg და second_arg - მითითებული ტიპებიდან.
შეყვანის პარამეტრების სია CREATE PROCEDURE განცხადების არაენოვან ნაწილში - გამოტოვება იკვეთება, თუ მისი მუშაობის პროცედურის ყველა მონაცემი აღებულია ცხრილის დამატებითი შეყვანისთვის პროცედურის სხეულის შუაში.
შენახულ პროცედურებში არის მონაცემთა სკალარული ტიპები InteiBase
მიეცით საკვანძო სიტყვა RETURNS, რის შემდეგაც პარამეტრები ხელახლა განლაგებულია მკლავებში, რომლებიც ტრიალებს მინიჭებული ტიპების მიხედვით - ამ კატეგორიაში მხოლოდ ერთი - შედეგი.
როგორ პროცედურა არ არის დამნაშავე პარამეტრების, სიტყვა RETURNS და დასაბრუნებელი პარამეტრების ჩამონათვალის როტაციაში, ყოველდღიურად.
მას შემდეგ, რაც RETURNSQ საკვანძო სიტყვა AS იყო მითითებული. AS საკვანძო სიტყვამდე სათაური,და ახლის შემდეგ - ტექოპროცედურები.
პროცედურის ტექსტი, რომელიც აღებულია, არის შინაგანი (ლოკალური) ცვლილებების აღწერილობის ასლი (სუნის მსგავსად, ამას ქვემოთ განვიხილავთ), რომლებიც იყოფა წერტილით კომის შემდეგ (;) და ოპერატორების ბლოკი, ადგილები ოპერატორში რკალი BEGIN END. ამ შემთხვევაში HP-ის სხეული კიდევ უფრო მარტივია - გთხოვთ, დაამატოთ ორი შეყვანის არგუმენტი და მათი შედეგი მივანიჭოთ გამომავალს, შემდეგ კი გამოიძახოთ SUSPEND ბრძანება. ნათელია ბრძანების არსი, მაგრამ ამ დროისთვის ნაკლებად მნიშვნელოვანია ის, რომ აუცილებელია პარამეტრების გადაცემისთვის, რომ ისინი იქ ტრიალებენ, ბულა ვიკლიკანას პროცედურის ვარსკვლავები, რომლებიც შენახულია.
ვარიაციები პროცედურებში, რომლებიც შენახულია
გაითვალისწინეთ, რომ ოპერატორი პროცედურის შუაში დასრულდება კომით ლაქით (;). როგორც ჩანს, წერტილი, რომლითაც სტანდარტული SQL ბრძანების დისტრიბუტორი გამორთულია, არის სიგნალი SQL თარჯიმანისთვის, რომ შესავალი ბრძანების ტექსტი სწორია და საჭიროებს დამუშავებას. Chi ვერ ვხედავ ასე, scho, აჩვენებს ლაქას კომაში შუა HP-ში, SQL თარჯიმანი აღიარებს, რომ ბრძანება ზუსტად იყო შეყვანილი და ცდილობს პროცედურის ნაწილის ვიკონატს, რა არის აღებული? Tse pripuschennya არ maє sensu. ცხადია, რომ შევქმნათ ფაილი, რომელშიც ჩაიწერება ფიშინგის კონდახი, დაამატეთ ბრძანება მონაცემთა ბაზიდან დასაკავშირებლად და სცადეთ SQL სკრიპტი isql თარჯიმანის დასახმარებლად, შემდეგ ის შეუსაბამობის გამო შეწყალდება. ფიქრობდა თარჯიმანზე, ბრძანებების პროცედურების დასრულება. დამატებითი SQL სკრიპტის ფაილების შენახვის პროცედურების შესაქმნელად, InterBase საცალო ვაჭრობის სპეციალური ხელსაწყოების გამოყენების გარეშე, კანის ბრძანებამდე აუცილებელია HP-ის შექმნა (ისინი დაამატებენ 1 ტრიგერებს) HP ინოვაციური იოგა. isql ბრძანება, რომელიც ცვლის SQL წინადადების გამყოფს, ასე გამოიყურება:
ვადის დაყენება
პროცედურის შექმნის ტიპიური ხერხისთვის, რაზეც ზრუნავენ, ასე გამოიყურება:
ვადის დაყენება ^;
CREATE PROCEDURE some_procedure
... . .
ᲓᲐᲡᲐᲡᲠᲣᲚᲘ
^
დააყენეთ ვადა ;^
ყოველკვირეული დაზოგვის პროცედურები
მოდით მივმართოთ ჩვენს პროცედურას, რაზე ვიზრუნოთ. ახლა, თუ ის შეიქმნა, საჭიროა გამოძახება, პარამეტრების გადაცემა და შებრუნებული შედეგების აღება. ამის გაკეთება კიდევ უფრო ადვილია - საკმარისია დაწეროთ SQL მოთხოვნა შეურაცხმყოფელი გარეგნობისთვის:
აირჩიეთ *
FROM Sp_add (181.35, 23.09)
Tsey გვთხოვს, რომ შემოგვიბრუნოს ერთი მწკრივი, რომელიც წაართმევს მხოლოდ ერთ Result ველს, რომელშიც შეიცვლება რიცხვების ჯამი 181.35 და 23.09, შემდეგ 204.44.
ამ გზით, ჩვენი პროცედურის გატეხვა შესაძლებელია სპეციალურ SQL შეკითხვებში, რომლებიც გატეხილია როგორც კლიენტის პროგრამებში, ასევე სხვა HP-ში ან ტრიგერებში. ჩვენი პროცედურის ეს ვარიაცია შესაძლებელი გახდა განსახორციელებელი პროცედურის ბოლოს SUSPEND ბრძანების დამატებით.
მარჯვნივ, InterBase-ში (და მის ყველა კლონში) არის ორი ტიპის პროცედურების შენახვა: შესარჩევი პროცედურები და შესრულებადი პროცედურები. ის ფაქტი, რომ რობოტებს აქვთ ორი ტიპის HP დაკავშირებულია იმ ფაქტთან, რომ შერჩევის პროცედურები ჟღერს შეყვანის პარამეტრების უპიროვნო ნაკრების როტაციაზე, რომლებიც დაჯგუფებულია ზედიზედ, რადგან მათ შეუძლიათ შეხედონ მონაცემთა ერთობლიობას, ხოლო ვიკონაციის პროცედურები არ შეიძლება. დაატრიალეთ პარამეტრები, ან მათ შეუძლიათ მარტო დაატრიალონ. აბრუნებს აქვს პარამეტრების ერთი რიგი. არჩეული პროცედურები გამოიძახება SELECT მოთხოვნების გვერდით, ხოლო პროცედურები, რომლებიც გამოძახებულია, მიჰყვება EXECUTE PROCEDURE ბრძანების დახმარებას.
შეურაცხყოფა რომ ხედავს შენახულ პროცედურებს, შექმნის იგივე სინტაქსი და ფორმალურად არაფერში არ ერევა, ასე რომ შესაძლებელია თუ არა პროცედურის შექმნა SELECT მოთხოვნაში და არის თუ არა პროცედურა-შერჩევა EXECUTE PROCEDURE-ს დასახმარებლად. კვება არის ის, თუ როგორ იქცევა CP სხვადასხვა სახის ბოროტებასთან. სხვა სიტყვებით რომ ვთქვათ, განსხვავება განსხვავებულია ყოველკვირეული სიმღერის ტიპის პროცედურის დიზაინში. ასე რომ, შერჩევის პროცედურა იქმნება სპეციალურად შეკითხვისთვის SELECT, ხოლო პროცედურა, რომელიც არჩეულია, შექმნილია სპეციალურად შეკითხვისთვის EXECUTE PROCEDURE. მოდით შევხედოთ რა უფლებამოსილებებს განიხილება ამ ორი ტიპის HP-ის დიზაინის შექმნისას.
გავიგოთ, როგორ ვივარჯიშოთ პროცედურა-ვიბრაცია, ცოტა ჩავიდეთ თეორიაში. ავიღოთ უფრო კონკრეტული SQL მოთხოვნა, როგორიცაა SELECT ID, NAME FROM Table_example. ამის შედეგად ჩვენ ვითვალისწინებთ გამომავალ ცხრილს, რომელიც შედგება ორი სვეტისაგან (ID და NAME) და მწკრივების იგივე რაოდენობისგან (რაც უფრო მეტია სტრიქონების რაოდენობა ცხრილში Table_example). ამ მოთხოვნის შედეგებში გადაქცეულ ცხრილს ასევე უწოდებენ SQL მონაცემთა ბაზას. . მას შემდეგ, რაც სერვერი წაიკითხავს კანის ჩანაწერს, რომელიც კმაყოფილია მოთხოვნის შედეგებით, აირჩიეთ ახალი საჭირო ველი (მაგალითად, ID და NAME) და წარუდგინეთ კლიენტს. ისევ გავიმეოროთ პროცესი - და ა.შ. კანის ვიბრაციის ჩანაწერი.
ყველა ნაბიჯი აუცილებელია იმისათვის, რომ ჭკვიანმა მკითხველმა გაიგოს, რომ ყველა SQL მონაცემთა ნაკრები ფორმირებულია ზედიზედ, მათ შორის შენახულ პროცედურებში! ეს არის პროცედურების მთავარი ვიდმინისტი - პროცედურების შერჩევა, რომლებიც ეფუძნება იმ ფაქტს, რომ პირველი განკუთვნილი იყო უსახური რიგების დასაბრუნებლად, ხოლო სხვები - მხოლოდ ერთისთვის. სწორედ ამიტომ, სუნი zastosovyatsya სხვაგვარად: პროცედურა-შერჩევის მოუწოდებს დახმარებას SELECT ბრძანება, როგორიცაა "wimage" პროცედურაში, რათა შეამოწმოს ყველა ჩანაწერი, ასე რომ თქვენ შეგიძლიათ მისი შემობრუნება. პროცედურა, რომელსაც ეძახიან, გამოძახებულია EXECUTE PROCEDURE-ის დასახმარებლად, როგორიცაა "wiymaє" HP-დან მხოლოდ ერთი რიგის და რეშტა (navit yakshcho stink!) იგნორირება.
მოდით შევხედოთ შერჩევის პროცედურის მაგალითს, რომ უფრო ნათელი გახდეს. პატიებისთვის, შევინახოთ პროცედურა, რადგან ის მუშაობს ზუსტად ისევე, როგორც ითხოვს SELECT ID, NAME FROM Table_Example, ასე რომ, ცხრილებისთვის ID და NAME ველების არჩევა შეუძლებელი იქნება. ღერძული კონდახი:
CREATE PROCEDURE Simple_Select_SP
დაბრუნება (
procID მთელი,
procNAME VARCHAR(80))
ას
დასაწყისი
FOR
აირჩიეთ ID, NAME ცხრილიდან_მაგალითი
INTO:procID, :procNAME
ᲙᲔᲗᲔᲑᲐ
დასაწყისი
შეჩერება;
ᲓᲐᲡᲐᲡᲠᲣᲚᲘ
ᲓᲐᲡᲐᲡᲠᲣᲚᲘ
მოდით შევხედოთ პროცედურას სახელწოდებით Simple_Select_SP. ფაქტობრივად, არ არის შეყვანის პარამეტრი და ორი გამომავალი პარამეტრი - ID და NAME. Naytsіkavіshe, zvichayno, stowed at tіli პროცედურა. აქ არის FOR SELECT კონსტრუქცია:
FOR
აირჩიეთ ID, NAME ცხრილიდან_მაგალითი
INTO:procID, :procNAME
ᲙᲔᲗᲔᲑᲐ
დასაწყისი
/* ჩვენ უნდა შევცვალოთ procID და procName */
ᲓᲐᲡᲐᲡᲠᲣᲚᲘ
ეს shmachok კოდი ნიშნავს შეურაცხმყოფელს: Table_example ცხრილიდან არჩეული კანის მწკრივისთვის, აირჩიეთ ცვლილების მნიშვნელობა procID და procName და შემდეგ დაამატეთ ცვლილების მნიშვნელობა.
შეგიძლიათ შეიმუშაოთ გარეგნობა და მოითხოვოთ: "შეცვალეთ? სხვაგვარად როგორ შეიცვალოთ 9" თუ ეს სხვაობის სიურპრიზის მსგავსია - ვინც იმ პროცედურებშია, რომლებიც შენახულია, ჩვენ შეგვიძლია მოვიგოთ ცვლილება. HP-ის ენაზე, თქვენ შეგიძლიათ გახმოვანდეთ, როგორც ლოკალური ცვლილება პროცედურის შუა პერიოდში, და შეცვალოთ შეყვანის და გამომავალი პარამეტრების შეცვლა.
იმისათვის, რომ გამოცხადდეს ლოკალური ცვლილება შენახულ პროცედურაში, აუცილებელია აღწერილობის შეტანა AS საკვანძო სიტყვის შემდეგ და პირველი სიტყვის BEGIN-მდე. ლოკალური ცვლილების აღწერა ასე გამოიყურება:
ცვლადის დეკლარირება
მაგალითად, Mylnt-ის ლოკალური ცვლილების ხანგრძლივობის გამოცხადებისთვის აუცილებელია AS და BEGIN შეურაცხმყოფელი აღწერილობის ჩასმა.
ცვლადის დეკლარირება MyInt INTEGER;
ჩვენს კონდახში ცვლილებები კეთდება ორ ნაწილად. ამის მიზეზი არის ის, რომ აუცილებელია მათი შეცვლა FOR SELECT SQL ბრძანების შუაში, ცხრილების ველების დაყოფისთვის, რომლებიც დალაგებულია SELECT-ში, ეს ცვლილება უნდა გადავიდეს დანარჩენ ორეულებზე. მაშინაც კი, თუ შეცვლით, შეგიძლიათ დაასახელოთ იგივე სახელი, ისევე როგორც ცხრილების ველები!
Ale dvokrapka სახელის წინ ცვლილება აუცილებელია, რომ მოიგოთ მხოლოდ SQL მოთხოვნების შუაში. პოზირდით ურჩხულის ტექსტებთან ერთად სიკვდილამდე ბრძოლა დვოკრაპკას გარეშე, მაგალითად:
procName="რაღაც სახელი";
მოდით მივმართოთ ჩვენი პროცედურის არსს. წინადადება FOR SELECT ატრიალებს მონაცემებს ვიზუალურ ცხრილებზე - მონაცემთა ერთობლიობაზე და თითო რიგში. კანის ველი, რომელიც ბრუნავს, შეიძლება განთავსდეს საკუთარი ცვლილების მიხედვით: ID => procID, NAME => procName. DO და ცვლილებების ნაწილისთვის, კლიენტს სთხოვენ დააწკაპუნოს პროცედურაზე> p>, SUSPEND ბრძანების დასახმარებლად.
ამ გზით, FOR SELECT... DO ბრძანება აწყობს ჩანაწერების ციკლს, რომლებიც არჩეულია ბრძანების SELECT ნაწილში. ამავე ციკლში, რომელიც არის DO-ს ნაწილი, შედგენილი ჩანაწერის გადაცემა კლიენტზე დამატებითი SUSPEND ბრძანების დასრულების შემდეგ.
ასევე, პროცედურა-შერჩევის აღიარება ხდება ერთი ან მეტი მწკრივის როტაციისთვის, რისთვისაც HP კორპუსის შუაში ეწყობა ციკლი, რომელიც აღადგენს მიღებული ცვლილების პარამეტრებს. მაგალითად, SUSPEND ბრძანება უნდა იყოს გამოყენებული ციკლის ბოლო ციკლისთვის, თითქოს მონაცემთა რიგს კლიენტს უბრუნებს.
ციკლები და ოპერატორები
Crim FOR SELECT... DO ბრძანება, რომელიც აწყობს ციკლს ნებისმიერი არჩევანის ჩანაწერებიდან, სხვა ტიპის ციკლი - WHILE...DO, რომელიც იძლევა ციკლის ორგანიზებას ნებისმიერი გონების ხელახალი გადამოწმების საფუძველზე. Axis საფონდო HP, scho vikoristovu ციკლი WHILE. ᲙᲔᲗᲔᲑᲐ. ეს პროცედურა აბრუნებს მთელი რიცხვების კვადრატებს 0-დან 99-მდე:
შექმენით PROCEDJRE QUAD
RETURNs (QUADRAT INTEGER)
ას
ცვლადის დეკლარირება I მთელი;
დასაწყისი
i = 1;
Სანამ მე<100) DO
დასაწყისი
QUADRAT=I*I;
I=I+1;
შეჩერება;
ᲓᲐᲡᲐᲡᲠᲣᲚᲘ
ᲓᲐᲡᲐᲡᲠᲣᲚᲘ
SELECT FROM QUAD მოთხოვნის შედეგად, ჩვენ გვჭირდება ცხრილი, რომელიც ჩაანაცვლებს QUADRAT-ის ერთ მწკრივს, რომელსაც ექნება მთელი რიცხვების კვადრატები 1-დან 99-მდე.
SQL შერჩევისა და კლასიკური ციკლის შედეგების დასათვლელად, გადაადგილების პროცედურებში, რომლებიც შენახულია, არჩეულია IF...THEN..ELSE ოპერატორი, რომელიც საშუალებას გაძლევთ მოაწყოთ დელიმიტაცია სარეზერვო ტიპში. იქნება ეს თუ არა მაღალი დონის პროგრამირება პასკალის მოედანზე და Cі.
მოდით შევხედოთ პროცედურის დასაკეცი მაგალითს, რომელიც ინახება ფეხების გაძარცვის მიზნით.
- გამოთვალეთ საშუალო ფასი ცხრილში Table_example (გაყოფა "ცხრილების ძირითადი გასაღებები და გენერატორები")
- დალი, რომ კანზე ჩანაწერი ცხრილში ხელახლა დაიწყოს შემოწმება, რადგან ძირითადი ფასი (PRICE) საშუალო ფასზე მაღალია, შემდეგ დააყენეთ ფასი საშუალო ფასის ტოლფასი, პლუს დააყენეთ წყლის ფიქსაცია.
- თუ ფასი საშუალო ფასზე დაბალია ან მეტია, მაშინ დააყენეთ ფასი მთლიანი ფასის ტოლი, პლუს საცალო ფასის ნახევარი ამ საშუალო ფასს შორის.
- ცხრილის ყველა მწკრივის ცვლილების როტაცია.
Cob-ისთვის მნიშვნელოვანია HP-ის დასახელება, შეყვანის და გამომავალი პარამეტრები.ყველაფერი წერია პროცედურის სათაურში, რომელიც შენახულია.
შექმენით პროცედურა გაზარდეთ ფასები (
პროცენტი 2 გაზრდის ორმაგი სიზუსტით)
RETURNs (ID INTEGER, NAME VARCHAR(SO), new_price DOUBLE
PRECISION AS
პროცედურას დაერქმევა IncreasePrices, მას აქვს ერთი შეყვანის პარამეტრი Peiceni21nciease, რომელიც შეიძლება იყოს DOUBLE PRECISION ტიპის და 3 შეყვანის პარამეტრი - ID, NAME და new_pnce. გთხოვთ გაითვალისწინოთ, რომ პირველ ორ პარამეტრს შეიძლება ჰქონდეს იგივე სახელები, როგორც ველებს Table_example ცხრილში, რომლითაც ჩვენ ვირჩევთ ანალიზს. Tse ნებადართულია mov პროცედურების წესებით, რომლებიც შენახულია.
ახლა ჩვენი პასუხისმგებლობაა გავახმოვანოთ ადგილობრივი ცვლილება, რადგან ჩვენ გავიმარჯვებთ საშუალო ღირებულების გულისთვის.
დეკლარირება VARIABLE საშუალო_ფასი DOUBLE PRECISION;
ახლა გადავიდეთ პროცედურის სხეულზე, რომელიც მოვლილია
საკვანძო სიტყვა BEGIN.
ჩვენ უნდა დავთვალოთ პირველად ჩვენი ალგორითმისთვის - გამოვთვალოთ საშუალო ფასი. ვისთვისაც ჩვენ ვაჩქარებთ ასეთი თხოვნით:
აირჩიეთ AVG (ფასი_ლ)
FROM Table_Example
INTO:საშუალო_ფასი,-
ეს აჭმევს AVG ცვლადის აგრეგატის ფუნქციას, ისე, რომ ის დააბრუნებს არჩეული მწკრივების საშუალო PRICE_1 ველის საშუალო მნიშვნელობას - PRICE_1 მნიშვნელობის ჩვენი საშუალო მნიშვნელობა ყველა ცხრილისთვის Table_example. მნიშვნელობა, რომელიც ბრუნავს მოთხოვნით, მოთავსებულია avg_price ცვლილებაში. პატივისცემის აღსადგენად, რომელიც იცვლება avg_pnce ორმაგი ფლაპის წინ, რათა გამოცოცხლდეს თხოვნაში გამარჯვებული წყლები.
ამ მოთხოვნის თავისებურება ისაა, ვინც ყოველთვის მკაცრად ამოწმებს ერთ ჩანაწერს. ასეთ მოთხოვნებს უწოდებენ singleton მოთხოვნას.შენახულ პროცედურებში შესაძლებელია მხოლოდ ასეთი არჩევანის არჩევა. თუ გსურთ ერთზე მეტი მწკრივის როტაცია, მაშინ აუცილებელია მისი დასრულება FOR SELECT...DO სტრუქტურაში, რათა მოაწყოთ ციკლი მობრუნებული კანის მწკრივის დამუშავებისთვის.
სხვათა შორის, ჩვენ მივიღეთ ფასის საშუალო ღირებულება. ახლა აუცილებელია ყველა ცხრილის გავლა, სკინ ჩანაწერში არსებული ფასის შედარება საშუალო ფასთან და ცხოვრება
Cob-ზე ვაწყობთ კანის ჩანაწერის დახარისხებას ცხრილიდან Table_example
FOR
აირჩიეთ ID, NAME, PRICE_1
FROM Table_Example
INTO:ID, :NAME, :new_price
ᲙᲔᲗᲔᲑᲐ
დასაწყისი
/*_აქ ჩვენ ვხსნით კანის ჩანაწერს*/
ᲓᲐᲡᲐᲡᲠᲣᲚᲘ
როდესაც დიზაინი განსხვავდება Table_example ცხრილისგან, კანის მწკრივში მორწყვის მონაცემებსა და მნიშვნელობებს მიენიჭება შეცვლილი ID, NAME და new_pnce. თქვენ, ცხადია, გახსოვთ, რომ თქვენ ცვლით გახმოვანებულ პარამეტრებს ნაგულისხმევი პარამეტრების მსგავსად, მაგრამ ტურბულენტურია, რომ შედეგად ნაჩვენები მონაცემები ბრუნდება და არა ვარტო: ის, რომ გამომავალი პარამეტრები რატომღაც იყო მინიჭებული, არ ნიშნავს, რომ კლიენტმა დააწკაპუნა. HP, რომ , უარყოფითად იღებს tsі ღირებულება! პარამეტრების გადატანა შესაძლებელია მხოლოდ მაშინ, როდესაც SUSPEND ბრძანება გამორთულია, მანამდე კი შეგვიძლია შევცვალოთ ნაგულისხმევი პარამეტრები, როგორც პირველადი ცვლილება - თავად აპლიკაციაში ასევე ვმუშაობთ new_price პარამეტრით.
ასევე BEGIN.. .END ციკლის სხეულის შუაში შეგვიძლია შევცვალოთ კანის რიგის მნიშვნელობა. როგორც გახსოვთ, ჩვენთვის აუცილებელია ვიცოდეთ, როგორც არსებითი ფასი, საშუალოდან ამაღლება და ძველ დროში ცხოვრება. Qiu პროცედურა mi-ს შესატყვისად ხორციელდება IF ოპერატორის დასახმარებლად:
IF (new_price > avg_price) მაშინ /*ასე რომ, მიმდინარე ფასი უფრო მაღალია საშუალო ფასისთვის*/
დასაწყისი
/*მაშინ დავაწესეთ ახალი ფასი, რომელიც უფრო ძვირია, ვიდრე საშუალო ფასი, პლუს ასობით დაფიქსირება */
ახალი_ფასი = (საშუალო_ფასი + საშუალო_ფასი*(პროცენტი2 ზრდა/100));
განაახლეთ ცხრილი_მაგალითი
დააყენეთ PRICE_1 = :new_price
WHERE ID =: ID;
ᲓᲐᲡᲐᲡᲠᲣᲚᲘ
სხვა
დასაწყისი
/* თუ ფაქტობრივი ფასი საშუალო ფასზე ნაკლები ან მეტია, მაშინ ჩვენ დავაყენებთ ფასს მთლიანი ფასის ტოლფასი, პლუს საცალო ფასის ნახევარი ამ საშუალო ფასს შორის */
ახალი_ფასი = (ახალი_პნცე + ((საშუალო_პნც ახალი_ფასი)/2)) ;
განაახლეთ ცხრილი_მაგალითი
დააყენეთ PRICE_1 = :new_price
WHERE ID = .ID;
ᲓᲐᲡᲐᲡᲠᲣᲚᲘ
ბაჩიტის მსგავსად, საჭირო იყო დიდი კონსტრუქციის დასრულება IF, მნიშვნელოვანი იქნებოდა მისი განხილვა, ასე რომ ნუ გააკეთებთ კომენტარს, მოიწონეთ დაწერა სიმბოლოში /**/.
იმისათვის, რომ ფასი იმავე გზით შევცვალოთ გამოთვლილ საცალო ვაჭრობაზე, ვაჩქარებთ UPDATE ოპერატორს, რომელიც საშუალებას გაძლევთ შეცვალოთ რეალური ჩანაწერები - ერთი ან მეტი. იმისათვის, რომ ცალსახად მივუთითოთ, რომელ ჩანაწერში უნდა შეიცვალოს ფასი, ჩვენ ვირჩევთ პირველადი გასაღების ველს გონებაში WHERE, ცვლილების ტოლფასი, რომელშიც ID მნიშვნელობა არის აღებული ნაკადის ჩანაწერისთვის: ID =: ID. დაიჭირეთ პატივი, რომ პირადობის მოწმობა იცვლება დუბლის წინ.
IF...THEN...ELSE კონსტრუქციის შეცვლის შემდეგ, შეცვლილ ID-ს, NAME-ს და new_price-ს აქვს მონაცემები, რადგან ჩვენი პასუხისმგებლობაა კლიენტის გამოძახება პროცედურისთვის. შემდეგი IF-სთვის საჭიროა SUSPEND ბრძანების ჩასმა, რათა მონაცემები იქ გაიგზავნოს, ვარსკვლავებმა HP-ს უწოდეს. SELECT...DO არ იმეორებს თქვენს მოთხოვნაში ყველა ჩანაწერს.
შემდეგი ნაბიჯი არის იმის დაზუსტება, რომ ჩვენ დავურთავთ SUSPEND ბრძანებას, რათა შეინახოთ შენახული პროცედურა, გამოიყენეთ EXIT ბრძანება, რათა შენახვა პროცედურა შეინახოს მწკრივის გადატანის შემდეგ. თუმცა, EXIT ბრძანება იშვიათად უნდა დასრულდეს, ჩიპები საჭიროა ძირითადად იმისათვის, რომ შეწყდეს ციკლი გონების მისაწვდომად.
დაბრუნების შემთხვევაში, თუ პროცედურა გამოიძახეს SELECT განაცხადით და დასრულდა EXIT-ით, დარჩენილი მწკრივი არ შემოტრიალდება. ასე რომ, თუ თქვენ გჭირდებათ პროცედურის შეწყვეტა და მაინც აიღოთ რიგი, თქვენ უნდა დააჩქაროთ თანმიმდევრობა
შეჩერება;
EXIT;
EXIT-ის მთავარი მახასიათებელია მონაცემთა ერთტონიანი ნაკრების შერჩევა, რომლებიც ატრიალებენ პარამეტრებს მალსახმობში EXECUTE PROCEDURE-ის მეშვეობით. ამ შემთხვევაში, დაყენებულია გარე პარამეტრების მნიშვნელობები, მაგრამ SQL მონაცემთა ნაკრები არ არის ჩამოყალიბებული და პროცედურა მთავრდება.
ჩამოვწეროთ ჩვენი პროცედურის ტექსტი, რომელიც უფრო მეტად არის შენახული, რათა დედამ ერთი შეხედვით დაინახოს ლოგიკა:
შექმენით პროცედურა გაზარდეთ ფასები (
პროცენტი 2 გაზრდის ორმაგი სიზუსტით)
RETURNS (ID INTEGER, NAME VARCHAR(80),
new_price DOUBLE PRECISION) AS
დეკლარირება VARIABLE საშუალო_ფასი DOUBLE PRECISION;
დასაწყისი
აირჩიეთ AVG (ფასი_ლ)
FROM Table_Example
INTO: საშუალო_ფასი;
FOR
აირჩიეთ ID, NAME, PRICE_1
FROM Table_Example
INTO:ID, :NAME, :new_price
ᲙᲔᲗᲔᲑᲐ
დასაწყისი
/*აქ ვამუშავებთ კანის ჩანაწერს*/
IF (new_pnce > avg_price) მაშინ /*ასე რომ, მიმდინარე ფასი უფრო მაღალია საშუალო ფასისთვის*/
დასაწყისი
/* დააყენეთ ახალი ფასი, რომელიც არის საშუალო ფასის უფრო მაღალი მნიშვნელობა, პლუს ფიქსირებული ასეულები */
ახალი_ფასი = (საშუალო_ფასი + საშუალო_ფასი*(პროცენტი2 ზრდა/100));
განაახლეთ ცხრილი_მაგალითი
დააყენეთ PRICE_1 = :new_price
WHERE ID =: ID;
ᲓᲐᲡᲐᲡᲠᲣᲚᲘ
სხვა
დასაწყისი
/* თუ ფაქტობრივი ფასი საშუალო ფასზე ნაკლები ან მეტია, მაშინ ფასს ვადგენ მთლიან ფასს, პლუს საცალო ფასის ნახევარი თანხასა და საშუალო ფასს შორის */
ახალი_ფასი = (ახალი_ფასი + ((საშუალო_ფასი - ახალი_ფასი)/2));
განაახლეთ ცხრილი_მაგალითი
დააყენეთ PRICE_1 = :new_price
WHERE ID =: ID;
ᲓᲐᲡᲐᲡᲠᲣᲚᲘ
შეჩერება;
ᲓᲐᲡᲐᲡᲠᲣᲚᲘ
ᲓᲐᲡᲐᲡᲠᲣᲚᲘ
შენახული პროცედურის დანიური მაგალითი, რომელიც ასახავს მოვის დაზოგვის პროცედურების და ტრიგერების ძირითადი კონსტრუქციების განვითარებას. მოდით გადავხედოთ პროცედურების გამოსწორების გზებს, რომლებიც შენახულია ზოგიერთი ხშირად დადანაშაულებული ამოცანის შესასრულებლად.
რეკურსიული პროცედურები, რომლებიც შენახულია
Save InterBase პროცედურები შეიძლება იყოს რეკურსიული. Tse ნიშნავს, რომ პროცედურები, რომლებიც შენახულია, შეგიძლიათ დარეკოთ საკუთარ თავს. ნებადართულია 1000 რუბლამდე დეპონირებული პროცედურები, რომლებიც ინახება, გახსოვდეთ, რომ სერვერზე არსებული რესურსები შეიძლება ადრე ამოიწუროს, HP-ის მაქსიმალური დეპოზიტის დაწევა მიიღწევა.
შენახული პროცედურების ერთ-ერთი ყველაზე ფართო სპექტრი არის მონაცემთა ბაზაში შენახული ხის მსგავსი სტრუქტურების დამუშავება. ხეები ხშირად იკრიფება საწყობის მენეჯერებში, საწყობებში, პერსონალში და სხვა ფართო დანამატებში.
მოდით შევხედოთ იმ პროცედურის მაგალითს, რომელიც აღებულია, როგორ ავირჩიოთ ერთი და იგივე ტიპის ყველა საქონელი პირველი თანაბარი ინვესტიციიდან დაწყებული.
ნება მომეცით მიხვიდე ამოცანის განცხადებამდე: შემიძლია შემოვიტანო საქონელი ამ ტიპის იერარქიული სტრუქტურით:
საქონელი
- პობუტოვას ტექნიკა
- მაცივრები
- სამი პალატა
- ორკამერიანი
- ერთი პალატა
- დასუფთავების მანქანები
- ვერტიკალური
- ფრონტალური
- კლასიკური
- ვუზკი
- Კომპიუტერული ტექნოლოგია
....
Tsya სტრუქტურა dovіdnika categorіy varіv_v მაისი დედა g_lki raznoї glibini. და ასევე გროვდება დროთა განმავლობაში. ჩვენი მისიაა უზრუნველყოთ დღის ბოლოს ყველა ელემენტის შერჩევა „საერთო სახელის წარმოთქმიდან“, დაწყებული ნებისმიერი ვუზლადან. მაგალითად, თუ ჩვენ ვირჩევთ "Palny cars", მაშინ უნდა გავითვალისწინოთ შემდეგი კატეგორიები:
მტვერი მანქანები - ვერტიკალური
ფრონტალური მანქანები - ფრონტალური კლასიკა
ფრონტალური მანქანები - ფრონტალური ვუზკი
ცხრილების სტრუქტურა მნიშვნელოვანია საქონლის პროგრესის შესახებ ინფორმაციის შეგროვებისთვის. მე გავამარტივე ხის ორგანიზების სქემა ერთ ცხრილში:
შექმენით მაგიდა GoodsTree
(ID_GOOD მთელი რიცხვი NOT NULL,
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)
ცხრილი არის თვითმმართველი და იგივე ძველი გასაღები უნდა მოჰყვეს მას. schob მაგიდაზე buv posilan უცნობი მამების შესახებ, і navіt reshkodzhaє სცადეთ ნახოთ საქონლის კატეგორია, yakі mayut nashchadki.
მოდით მივიყვანოთ ეს მონაცემები ჩვენს ცხრილში:
| ID_GOOD 1
|
ID_PARENT_GOOD 0
|
ᲙᲐᲠᲒᲘ ᲡᲐᲮᲔᲚᲘ საქონელი |
ახლა, თუ ჩვენ გვექნება მონაცემთა შენახვის ადგილი, შეგვიძლია გადავიდეთ შენახული პროცედურის შექმნაზე, ასე რომ, ჩვენ ამოვიღებთ ყველა "ნარჩენი" კატეგორიის საქონელს "გათავისუფლებულიდან" - მაგალითად, კატეგორიისთვის " სამკამერიანი" კატეგორიის მიღმა გამოვიყურები " აღჭურვილობა მაცივრები "სამკამერები".
პროცედურებმა, რომლებიც ზრუნავენ, აყალიბებენ ხის მსგავს სტრუქტურებს, შეიმუშავეს საკუთარი ტერმინოლოგია. ხის კანის ელემენტს კვანძი ეწოდება; ხოლო ბლუზებს კვანძებს შორის, რომლებიც ერთი-ერთზეა ჩაყრილი, მოხუცის ჩექმებს უწოდებენ. ვუზლებს, რომლებიც ხის წვერზეა განლაგებული და ნაშადკივს არ აკეთებენ, ფოთლებს უწოდებენ.
თითოეული შესანახი პროცედურისთვის, შეყვანის პარამეტრი იქნება კატეგორიის იდენტიფიკატორი, რატომღაც დავიწყებთ დახარისხებას. დროებითი პროცედურა შენახულია ასე:
GETFULLNAME-ის პროცედურის შექმნა (ID_GOOD2SHOW INTEGER)
RETURNS (FULL_GOODS_NAME VARCHAR(1000),
ID_CHILD_GOOD INTEGER)
ას
გამოაცხადეთ ცვალებადი CURR_CHILD_NAME VARCHAR(80);
დასაწყისი
/*0rgan_zuєmo zovnіshnіy ციკლი FOR SELECT for bezporednіmi პროდუქტის ეტიკეტები ID_GOOD=ID_GOOD2SHOW */
SELECT 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 არ აქვს მალსახმობები, მაშინ ის არის ხის "ფოთოლი" და შედეგად მოიხმარს მას. */
თუ (არ არსებობს (
აირჩიეთ * GoodsTree-დან
WHERE GoodsTree.id_parent_good=:id_child_good))
მაშინ
დასაწყისი
/* გადაიტანეთ ხის რკალი შედეგზე */
შეჩერება;
ᲓᲐᲡᲐᲡᲠᲣᲚᲘ
სხვა
/* კვანძებისთვის, როგორიცაა მაქმანების გაკეთება */
დასაწყისი
//
CURR_CHILD_NAME=სრული_საქონლის_სახელი;
/* გაუშვით ჩემი პროცედურა რეკურსიულად */
FOR
აირჩიეთ ID_CHILD_GOOD,full_goods_name
FROM GETFULLNAME (:ID_CHILD_GOOD)
INTO:ID_CHILD_GOOD, :full_goods_name
დაიწყე
/*dodaёmo lmya vozla-მამა ცნობილს. */
full_goods_name=CURR_CHILD_NAME| "" | f ull_goods_name,-
შეჩერება; /* გადააბრუნე საქონელი*/
ᲓᲐᲡᲐᲡᲠᲣᲚᲘ
ᲓᲐᲡᲐᲡᲠᲣᲚᲘ
ᲓᲐᲡᲐᲡᲠᲣᲚᲘ
ᲓᲐᲡᲐᲡᲠᲣᲚᲘ
თუ ამ პროცედურას გამოვიყენებთ ID_GOOD2SHOW=1 შეყვანის პარამეტრით, მაშინ ვიღებთ შემდეგს:
ბაჩიტის მსგავსად, რეკურსიული პროცედურის დასახმარებლად, რომელიც შენახულია, გავიარეთ კატეგორიების მთელი ხე და გამოვიტანეთ კატეგორიების სახელები - "ფოთლები", თითქოს ისინი თავად ფოთლების წვერებზე იყო ნაპოვნი.
ვისნოვოკი
ამ ეტაპზე, ჩვენ ვასრულებთ მიმოხილვას ჩემი პროცედურების ძირითადი შესაძლებლობების შესახებ, რომლებიც შენახულია. ცხადია, იმ პროცედურების დაყოფის ათვისების მიზნით, რომლებიც შენახულია, როდესაც ერთი განყოფილების წაკითხვა შეუძლებელია, შევეცადეთ გამოგვევლინა და ავხსნათ შენახვის პროცედურებთან დაკავშირებული ძირითადი ცნებები. HP-ის დიზაინისა და დიზაინის აღწერილობები შეგიძლიათ იხილოთ მონაცემთა ბაზების უმეტესობაში
შენახული პროცედურების ღირებულებასთან დაკავშირებული მნიშვნელოვანი კერძების ნაწილი გამოქვეყნდება მომავალ განყოფილებაში - "საბაზო პროცედურების დაზოგვის შესაძლებლობის გაფართოება", რადგან ეს დაკავშირებულია პროცედურებში შეწყალების სიტუაციების ზოგად ბრალდებასთან. შენახულია რობოტების მიერ.
შენახული გაფართოებული პროცედურების დასაპროგრამებლად, Microsoft უზრუნველყოფს ODS (Open Data Service) API მაკროებისა და ფუნქციების ნაკრებისთვის, რომელიც შეიძლება გამოყენებულ იქნას სერვერის დანამატების წახალისებისთვის, რათა გაზარდოს MS SQL Server 2000-ის ფუნქციონირება.
გაფართოებული პროცედურები, რომლებიც შენახულია - ეს ძირითადი ფუნქციები იწერება C / C ++ ODS API და WIN32 API შეცდომების გამო, შექმნილია დინამიური ბმულის ბიბლიოთეკის სახით (dll) და დააწკაპუნეთ, როგორც უკვე ვთქვი, გააფართოვეთ ფუნქციონირება. SQL სერვერის. ODS API საცალო ვაჭრობას აძლევს ფუნქციების მდიდარ კომპლექტს, რაც საშუალებას აძლევს კლიენტს გადაიტანოს მონაცემები, მოიძიოს ნებისმიერი არსებული მონაცემთა წყარო (მონაცემთა წყარო), როგორც დიდი ჩანაწერი. ასევე, გაფართოებულ შენახულ პროცედურას შეუძლია მნიშვნელობების როტაცია OUTPUT პარამეტრის გადასვლის გზით.
როგორ ვივარჯიშოთ შენახული გაფართოებული პროცედურები.
- როდესაც კლიენტის პროგრამა ითხოვს გაფართოებული პროცედურის შენახვას, მოთხოვნა გადადის TDS ფორმატში Net-Libraries და Open Data Service ბიბლიოთეკის მეშვეობით MS SQL SERVER ბირთვში.
- SQL Sever dll ბიბლიოთეკის შესაცნობად ასოცირდება გაფართოებული პროცედურების შენახვის პროცედურასთან და მის კონტექსტში დაკავებასთან, რადგან აქ ადრე არ იყო ჩამორთმეული და გაფართოებული შენახვის პროცედურის გამოძახება, რომელიც განხორციელებულია როგორც ფუნქცია dll-ის შუაში.
- გაფართოვდა სერვერზე შენახვის, აკრეფის და კლიენტის დანამატზე კომპლექტის შედეგების გადაცემის პროცედურა, ვიკორისტის სერვისი, რომლის იმედიც აქვს ODS API, გაფართოვდა.
გაფართოებული პროცედურების მახასიათებლები, რომლებზეც ზრუნავენ.
- გაფართოებული პროცედურები, რომლებიც შენახულია - ეს ფუნქციები განლაგებულია MS SQL Server-ის მისამართის სივრცეში და დაკვირვებადი ჩანაწერის უსაფრთხოების კონტექსტში, რომლის მიხედვითაც იწყება MS SQL Server სერვისი;
- გარდა ამისა, როგორც dll ბიბლიოთეკა გაფართოებული პროცედურებით, რომლებიც შენახულია, bula არის ზავანტაჟენური მეხსიერებაში, ის რჩება იქ, სანამ არ გაჩუმდება, სანამ SQL სერვერი აღარ ჟღერს, ან სანამ ადმინისტრატორი არ გამოიმუშავებს primus, vikoristovuyuchi ბრძანებას. :
DBCC DLL_name (უფასო). - შენახული პროცედურა გაფართოვდა, ის გაშვებულია სკრინინგზე, ისევე როგორც ჩვეულებრივი პროცედურა, რომელიც შენახულია:
EXECUTE xp_extendedProcName @param1, @param2 OUTPUT
@param1 შეყვანის პარამეტრი
@param2 შეყვანის/გამოსვლის პარამეტრი
ზოგიერთი შენახული გაფართოებული პროცედურები ინახება MS SQL Server სერვისის პროცესის მისამართების სივრცეში, იქნება ეს კრიტიკული შეწყალება, რომელსაც ისინი აბრალებენ თავიანთ რობოტებს, მათ შეუძლიათ გააფუჭონ სერვერის ბირთვი, რეკომენდებულია მკაცრად გააპროტესტოთ თქვენი DLL. სამუშაო სერვერზე დაყენებამდე.
გაფართოებული პროცედურების შექმნა, რომლებიც შენახულია.
გაფართოვდა ამ ფუნქციის შენახვის პროცედურა შემდეგ პროტოტიპზე:
SRVRETCODE xp_extendedProcName(SRVPROC * pSrvProc);
Პარამეტრი pSrvProc SRVPROC სტრუქტურის ინდიკატორი, როგორც კანის სპეციფიკური კლიენტის კავშირის აღწერა (სახელური). ამ სტრუქტურის ველები არადოკუმენტირებულია და შეიცავს ინფორმაციას, როგორიცაა ODS ბიბლიოთეკა სერვერის დანამატს (Open Data Services სერვერის აპლიკაცია) და კლიენტს შორის კომუნიკაციისა და მონაცემების სამართავად. როგორიც არ უნდა იყოს თქვენი გემოვნება, თქვენ არ გჭირდებათ იმავე სტრუქტურაზე გადასვლა და აღარ შეგიძლიათ მისი შეცვლა. ეს პარამეტრი უნდა იყოს მითითებული ერთი საათის განმავლობაში, იქნება ეს ODS API-ს ფუნქცია, ჯერჯერობით, არ ვიცი ამ აღწერილობის შესახებ.
xp_ პრეფიქსის ვარიაცია არ არის საჭირო, თუმცა, თუ გსურს გაფართოებული პროცედურის დაწყება, შესაძლებელია მისი შენახვა თავად, რათა ორიგინალ შენახულ პროცედურას დაამატო სახელი, მათი სახელები, როგორც შენ. ვიცი, მიღებულია sp_z პრეფიქსის დაწყება.
ასევე, გაითვალისწინეთ, რომ გაფართოებული პროცედურების სახელები, რომლებიც შენახულია, რეგისტრირებულია. ნუ დაგავიწყდებათ, თუ გააფართოვებთ შენახულ პროცედურას, წინააღმდეგ შემთხვევაში ჩაანაცვლებთ ქულის შედეგს, თქვენ ამოიღებთ შეხსენებას შეწყალების შესახებ.
თუ გჭირდებათ dll ინიციალიზაციის/დეინიციალიზაციის კოდის დაწერა, გამოიყენეთ სტანდარტული DllMain() ფუნქცია. თუ არ გაქვთ ეს საჭიროებები და არ გსურთ დაწეროთ DLLMain(), მაშინ შემდგენელი აირჩევს DLLMain() ფუნქციის საკუთარ ვერსიას, ასე რომ არაფერი გააკეთოთ, უბრალოდ გადააქციეთ TRUE. ყველა ფუნქცია, რომელიც გამოიძახება dll-დან (დაზოგვის პროცედურების გასაგრძელებლად) გამოწვეულია ექსპორტირებული სახით. თუ თქვენ წერთ MS Visual C++-ში, გამოიყენეთ დირექტივა __declspec (dllexport). თუ შემდგენელი არ იცავს ამ დირექტივას, აღწერეთ ექსპორტირებული ფუნქცია DEF ფაილის EXPORTS განყოფილებაში.
ასე რომ, პროექტის შესაქმნელად, ჩვენ გვჭირდება შემდეგი ფაილები:
- Srv.h სათაურის ფაილი, ჩაწერეთ ODS API-ის ფუნქციების და მაკროების აღწერილობები;
- Opends60.lib ფაილი Opends60.dll ბიბლიოთეკის იმპორტისთვის, რომელიც ახორციელებს ODS API-ით მოსალოდნელ ყველა სერვისს.
Declspec(dllexport) ULONG __GetXpVersion()
{
დაბრუნება ODS_VERSION;
}
თუ MS SQL Server იჭერს DLL-ს გაფართოებული შენახული პროცედურის საშუალებით, ის გამოიძახებს ამ ფუნქციას ბიბლიოთეკის ვერსიის შესახებ ინფორმაციის მოსაპოვებლად.
თქვენი პირველი გაფართოებული შენახული პროცედურის დასაწერად, თქვენ უნდა დააინსტალიროთ თქვენს კომპიუტერში:
MS SQL Server 2000, იქნება ეს გამოცემა (შეიძლება მქონდეს პერსონალური გამოცემა). კოდის დაყენების პროცესში გადაიტანეთ წყაროს ნიმუშის ვარიანტი
- MS Visual C++ (გამოვიყენე ვერსია 7.0), მაგრამ ზუსტად ვიცი 6.0 ვერსია
SQL Server -a-ს ინსტალაცია საჭიროა თქვენი DLL-ის შესამოწმებლად და შესწორებისთვის. შესაძლებელია ქსელის საშუალებით გაუმჯობესება, მაგრამ მე არანაირად არ მოვერიე და ყველაფერი დავაინსტალირე ჩემს ადგილობრივ დისკზე. Microsoft Visual C++ 7.0 Interprise Edition მოიცავს გაფართოებული შენახული პროცედურის DLL ოსტატს. პრინციპში, არაფრის გატეხვა არ არის საჭირო ბუნებით, არამედ მხოლოდ შენახული გაფართოებული პროცედურისთვის შაბლონის შექმნა. თუ მოგწონთ fakhіvtsі, შეგიძლიათ მოიგოთ იოგა. ისე, მე მაქვს ნება, ყველაფერი ხელით ვიმუშაო და ამ რხევას ვერ ვხედავ.
ახლა დასახმარებლად:
- გაუშვით Visual C++ და შექმენით ახალი პროექტი - Win32 Dynamic Link Library.
- ჩართეთ პროექტის სათაურის ფაილი - #include
- გადადით მენიუში Tools => Options და დაამატეთ გზა მოიცავს და ბიბლიოთეკის ფაილების ძიებას. თუ არაფერი შეგიცვლიათ MS SQL Server-ის ინსტალაციის დროს, დააყენეთ:
C:Program FilesMicrosoft SQL Server80ToolsDevToolsInclude სათაურის ფაილებისთვის;
- C:Program FilesMicrosoft SQL Server80ToolsDevToolsLib ბიბლიოთეკის ფაილებისთვის.
- მიუთითეთ opends60.lib ბიბლიოთეკის ფაილის სახელი ლინკერის ვარიანტებში.
თუ მოსამზადებელი ეტაპი დასრულდა, შეგიძლიათ დაწეროთ თქვენი პირველი გაფართოებული შენახული პროცედურა.
პრობლემის დაყენება.
პირველი ნაბიჯი არის პროგრამირების გაგრძელება, აუცილებელია მკაფიოდ ჩამოყალიბდეს რა უნდა დაიწყოს, რა შეიძლება იყოს საბოლოო შედეგი და რა გზით მივაღწიოთ მას. ოტჟე, ჩვენთვის ტექნიკური ამოცანების ღერძი:
მოდით გავაფართოვოთ პროცედურა MS SQL Server 2000-ისთვის, რომ წავშალოთ დომენში არსებული რეგისტრაციების უახლესი სია და გადავაბრუნოთ კლიენტს, რომ ნახოს სტანდარტული ჩანაწერების ნაკრები. როგორც პირველი შეყვანის პარამეტრი, ფუნქცია იღებს სერვერის სახელს მონაცემთა ბაზის დირექტორიაში (Active Directory), ანუ დომენის კონტროლერის სახელს. თუ ეს პარამეტრი დაყენებულია NULL-ზე, აუცილებელია კლიენტს გადასცეს ლოკალური ჯგუფების სია. კიდევ ერთი პარამეტრი შემოწმდება გაფართოებული შენახული პროცედურის საშუალებით წარმატებული/წარუმატებელი ოპერაციის შედეგის მნიშვნელობის დასაბრუნებლად (OUTPUT პარამეტრი). თუ პროცედურა გაფართოვდა, რომელიც შენახულია, წარმატებულია, მაშინ საჭიროა კლიენტის ჩანაწერების კომპლექტში ქცეული ჩანაწერების რაოდენობის გადატანა, რათა სამუშაოს პროცესში შეუძლებელი იყოს საჭირო ინფორმაციის მიღება, სხვა პარამეტრის მნიშვნელობა დაყენებული უნდა იყოს -1-ზე, მარცხის ნიშნად.
შეტევების თავიდან აცილების გაფართოებული პროცედურის გონებრივი პროტოტიპი:
xp_GetUserList(@NameServer varchar, @CountRec int OUTPUT);
ხოლო ღერძი არის გაფართოებული პროცედურის შაბლონი, რომელიც აღებულია, რომელიც უნდა შევახსენოთ:
#შეიცავს
#შეიცავს
#define XP_NOERROR 0
#define XP_ERROR -1
__declspec(dllexport) SERVRETCODE xp_GetGroupList(SRVPROC* pSrvProc)
{
//გავლილი პარამეტრების რაოდენობის შემოწმება
//გავლილი პარამეტრების ტიპის შემოწმება
//Check, რომელიც არის პარამეტრი 2 OUTPUT პარამეტრი
//შეამოწმეთ, აქვს თუ არა პარამეტრ 2-ს საკმარისი დრო მნიშვნელობის შესანახად
//შეყვანის პარამეტრების ამოღება
//კორესპონდენტების სიის ამოღება
// მონაცემთა გაგზავნა კლიენტისთვის, როგორც ჩანაწერების სტანდარტული ნაკრები (ჩანაწერების ნაკრები)
//OUTPUT პარამეტრის მნიშვნელობის დაყენება
დაბრუნება (XP_NOERROR);
}
რობოტი შეყვანის პარამეტრებით
მე არ მსურს თქვენი პატივისცემის გაზრდა მესამე მხარის გამოსვლებში, მაგრამ მსურს რობოტებზე იოგას შთაგონება გაფართოებულ პროცედურაზე გადატანილი პროცედურით, რომელიც შერჩეულია პარამეტრებით. ამ მიზეზით, ჩვენი ტექნიკური ამოცანა ადვილი გასაგებია და შესაძლებელია მხოლოდ ამ ნაწილის გაფართოება, რადგან ის მუშაობს შეყვანის პარამეტრებთან. ალე, ზურგი უკან, არ არის ბევრი თეორია
პირველ დღეს, yaku maє vykonati ჩვენი გაფართოებული შენახული პროცედურა - აიღეთ პარამეტრები, რომლებიც გადაცემული იყო vyklik-ის დროს. ალგორითმის მიერ გამოწვეული დორიმიუჩის მიხედვით, ჩვენ უნდა მივყვეთ ამ ნაბიჯებს:
გადაცემული პარამეტრების რაოდენობის განსაზღვრა;
- შეცვალეთ, რომ გადაცემული პარამეტრები შეიძლება იყოს სწორი ტიპის მონაცემები;
- გადახედეთ, რომ OUTPUT პარამეტრს შეიძლება ჰქონდეს საკმარისი მნიშვნელობა, რომ შეინახოთ იგი ახალ მნიშვნელობაზე, ის ბრუნავს ჩვენი გაფართოებული შენახული პროცედურის საშუალებით.
- otrimati გადაცემული პარამეტრები;
- დააყენეთ გამომავალი პარამეტრის მნიშვნელობა გაფართოებული შენახული პროცედურის წარმატებით/წარუმატებლად დასრულების შედეგად.
ახლა ჩვენ ნათლად ვხედავთ ტყავის ნივთს:
გაფართოებულ პროცედურაზე გადარიცხვების რაოდენობის გადაწყვეტა, რომელიც შენახულია, პარამეტრები
გადაცემული პარამეტრების რაოდენობის მოსაშორებლად აუცილებელია ფუნქციის არჩევა:
int srv_rpcparams(SRV_PROC * srvproc);
ფუნქციის წარმატებით დასრულების შემდეგ შეიცვლება გადარიცხვების რაოდენობა და შეინახება პარამეტრის პროცედურა. ასევე, Wiklikana boolean-ის გაფართოებული შენახული პროცედურა პარამეტრების გარეშე - srv_rpcparams დაყენებულია -1-ზე. პარამეტრების გადაცემა შესაძლებელია სახელით ან პოზიციით (უსახელო). ამავდროულად, შეუძლებელია ორი გზით შეცვლა. შეყვანის პარამეტრების ერთდროულად გადაცემის მცდელობა ფუნქციისთვის პოზიციის სახელის მიხედვით - მიიყვანეთ პატიება ბოლომდე და srv_rpcparams ჩართოთ 0 .
დამოკიდებულია მონაცემთა ტიპზე და გავლილი პარამეტრების მნიშვნელობაზე
გავლილი პარამეტრების ტიპისა და რაოდენობის შესახებ ინფორმაციის მისაღებად, Microsoft გირჩევთ გამოიყენოთ srv_paramifo ფუნქცია. ეს უნივერსალური ფუნქცია ცვლის ვიკის srv_paramtype, srv_paramlen, srv_parammaxlen, რადგან ისინი მოძველებულად ითვლება. Axis її პროტოტიპი:
int srv_paraminfo(
SRV_PROC * srvproc,
intn,
BYTE*pbType,
ULONG* pcbMaxLen,
ULONG*pcbActualLen,
BYTE*pbData,
bool*pfNull);
pbTypeმიუთითეთ პარამეტრის რიგითი ნომერი. პირველი პარამეტრის რიცხვი იწყება პირველიდან.
pcbMaxLenჩეინჯერი შესაცვლელად, რომელ ფუნქციაზე უნდა შეიყვანოთ პარამეტრის მაქსიმალური მნიშვნელობა. მნიშვნელობა განისაზღვრება გადაცემული პარამეტრის კონკრეტული მონაცემთა ტიპის მიხედვით, ასე რომ, ჩვენ შეგვიძლია შევცვალოთ ის ისე, რომ OUTPUT პარამეტრს ჰქონდეს საკმარისი მნიშვნელობა გადაცემული მონაცემების შესანახად.
pcbActualLenპარამეტრის რეალური მნიშვნელობის ინდიკატორი გადაცემულია გაფართოებულ პროცედურაზე, რომელიც ინახება დარეკვისას. თუ გადაცემულ პარამეტრს აქვს ნულის მნიშვნელობა და pfNull დაყენებულია FALSE-ზე, მაშინ (* pcbActualLen) ==0.
pbData- შეიტანეთ ბუფერში, რომლის მეხსიერება შეიძლება ნახოთ srv_paraminfo ტვიტამდე. რომელ ბუფერს აქვს შეყვანის პარამეტრების განკარგვის ფუნქცია გაფართოებულ თანმიმდევრულ პროცედურაში. ბუფერის ზომა ბაიტებში არის pcbMaxLen-ის უფრო ძველი მნიშვნელობა. თუ ჩასმის პარამეტრი არის NULL, ბუფერში მონაცემები არ იწერება, მაგრამ ფუნქცია სწორად აბრუნებს *pbType, *pcbMaxLen, *pcbActualLen, *pfNull მნიშვნელობებს. მაშასადამე, srv_paraminfo-ს გამოძახებას ორი გასაღები სჭირდება: დარეკეთ pbData=NULL, შემდეგ, მეხსიერების საჭირო ზომისა და თანაბარი pcbActualLen ბუფერის დანახვის შემდეგ, გამოიძახოთ srv_paraminfo სხვა, გადასცეთ pbData მეხსიერების ბლოკის სანახავად.
pfNull vkaz_vnik NULL ნიშანზე. srv_paraminfo აყენებს მას TRUE-ზე, რაც ნიშნავს, რომ შეყვანის პარამეტრის მნიშვნელობა არის null.
გადაამოწმეთ, რაც კიდევ ერთი OUTPUT პარამეტრია.
srv_paramstatus() ფუნქცია ენიჭება გავლილი პარამეტრის სტატუსს:
int srv_paramstatus(
SRV_PROC * srvproc,
intn
);
n არის პარამეტრის რაოდენობა, რომელიც გადაცემულია გაფართოებულ შენახვის პროცედურაზე სამუშაო დღისთვის. ვფიქრობ: პარამეტრები ყოველთვის დანომრილია 1-დან.
srv_paramstatus-ის მნიშვნელობის დასატრიალებლად დააყენეთ ნულოვანი ბიტი. მაშინაც კი, თუ პარამეტრი დაყენებულია 1-ზე, პარამეტრი გადაეცემა OUTPUT პარამეტრად, ხოლო თუ დაყენებულია 0-ზე, ყველაზე მნიშვნელოვან პარამეტრზე, ჩვენ გადავცემთ მნიშვნელობას. ანალოგიურად, ლოგიკის გაფართოებული შენახული პროცედურა პარამეტრების გარეშე, ბრუნვის ფუნქცია არის -1.
დააყენეთ გამომავალი პარამეტრის მნიშვნელობა.
გაფართოებულ შემნახველზე გადაცემული გამომავალი პარამეტრი შეიძლება გადაეცეს მნიშვნელობა srv_paramsetoutput ფუნქციის გამოყენებით. ეს ახალი ფუნქცია ცვლის srv_paramset ფუნქციის მალსახმობს, როგორც ახლა პატივს სცემს ძველს, რადგან არ უჭერს მხარს ODS API-ში შეტანილ ახალ ტიპებს და ნულოვანი მნიშვნელობის მონაცემებს.
int srv_paramsetoutput(
SRV_PROC *srvproc,
intn,
BYTE *pbData,
ULONG cbLen,
BOOL fNull
);
pbDataინდიკატორი ბუფერში მონაცემებით, რომლებიც გაეგზავნება კლიენტს გამომავალი პარამეტრის მნიშვნელობის დასაყენებლად.
cbLen dovzhina buffer danikh, scho posilayutsya. თუ გადასული OUTPUT პარამეტრის მონაცემთა ტიპი დაყენებულია მუდმივად მოქმედად და არ იძლევა NULL მნიშვნელობების შენახვას (მაგალითად, SRVBIT ან SRVINT1), მაშინ ფუნქცია უგულებელყოფს cbLen პარამეტრს. მნიშვნელობა cbLen=0 მითითებულია ნულოვანი პერიოდის საფუძველზე, რომლითაც fNull პარამეტრი შეიძლება დაყენდეს FALSE-ზე.
fNullდააყენეთ ეს მნიშვნელობა TRUE-ზე, წინააღმდეგ შემთხვევაში შესაბრუნებელ პარამეტრს უნდა მიენიჭოს მნიშვნელობა NULL, ამ შემთხვევაში cbLen-ის მნიშვნელობა შეიძლება იყოს 0-ის ტოლი, წინააღმდეგ შემთხვევაში ფუნქცია დასრულდება წყალობით. იყიდება reshti vipadkіv fNull=FALSE.
წარმატებით დასრულების დროს ფუნქცია ირთვება SUCCEED. როგორც მნიშვნელობის, რომ ის თურმე, კარი არის FAIL, ეს ნიშნავს, რომ კვირა არ არის შორს. ყველაფერი მარტივი და გასაგებია
ახლა ჩვენ საკმარისად ვიცით, რომ დავწეროთ თქვენი პირველი გაფართოებული პროცედურა, რომელიც შენახულია, თითქოს მნიშვნელობას ატრიალებთ th პარამეტრის გადაცემის გზით. მოდი, ტრადიციისთვის, იქნება Hello World-ის რიგი! აქ შეგიძლიათ მიიღოთ აქციების მორგებული ვერსია.
#შეიცავს
#define XP_NOERROR 0
#define XP_ERROR 1
#define MAX_SERVER_ERROR 20000
#define XP_HELLO_ERROR MAX_SERVER_ERROR+1
void printError (SRV_PROC*, CHAR*);
#ifdef __cplusplus
გარე "C" (
#დაასრულე თუ
SRVRETCODE __declspec(dllexport) xp_helloworld(SRV_PROC* pSrvProc);
#ifdef __cplusplus
}
#დაასრულე თუ
SRVRETCODE xp_helloworld(SRV_PROC* pSrvProc)
{
char szText = "გამარჯობა სამყარო!";
BYTE bType;
ULONG cbMaxLen;
ULONG cbActualLen;
BOOL fNull;
/* გაფართოებულ დანაზოგზე გადარიცხვების რაოდენობის განსაზღვრა
პარამეტრის პროცედურა */
თუ (srv_rpcparams(pSrvProc) != 1)
{
printError(pSrvProc, "პარამეტრების არასწორი რაოდენობა!");
დაბრუნება (XP_ERROR);
}
/* ინფორმაციის მოძიება მონაცემთა ტიპისა და გადაცემული პარამეტრების სიგრძის შესახებ */
if (srv_paraminfo(pSrvProc, 1, &bType, &cbMaxLen,
&cbActualLen, NULL, &fNull) == ვერ)
{
printError (pSrvProc,
„არ შეეცადოთ მიიღოთ ინფორმაცია შეყვანის პარამეტრების შესახებ...“);
დაბრუნება (XP_ERROR);
}
/* გადაამოწმეთ, რომ გადასვლების რაოდენობა არის OUTPUT პარამეტრი */
თუ ((srv_paramstatus(pSrvProc, 1) & SRV_PARAMRETURN) == ვერ)
{
printError (pSrvProc,
"გადაცემის პარამეტრი არ არის OUTPUT პარამეტრი!");
დაბრუნება (XP_ERROR);
}
/* შეამოწმეთ გავლილი პარამეტრის მონაცემთა ტიპი */
თუ (bType != SRVBIGVARCHAR && bType != SRVBIGCHAR)
{
printError(pSrvProc, "პარამეტრის არასწორი ტიპი გავიდა!");
დაბრუნება (XP_ERROR);
}
/* ჩვენ ვცვლით, რომ გადაცემის პარამეტრი შეიძლება იყოს საკმარისი იმ მწკრივის შესანახად, რომელიც ბრუნავს */
თუ (cbMaxLen< strlen(szText))
{
printError (pSrvProc,
"არასაკმარისი დროის პარამეტრი გავიდა n მწკრივის შესანახად, რა უნდა გადახვიდე!");
დაბრუნება (XP_ERROR);
}
/* დააყენეთ OUTPUT პარამეტრის მნიშვნელობა */
თუ (FIL == srv_paramsetoutput(pSrvProc, 1, (BYTE*)szText, 13, FALSE))
{
printError (pSrvProc,
"არ შემიძლია OUTPUT პარამეტრის მნიშვნელობის დაყენება...");
დაბრუნება (XP_ERROR);
}
srv_senddone(pSrvProc, (SRV_DONE_COUNT | SRV_DONE_MORE), 0, 1);
დაბრუნება (XP_NOERROR);
}
void printError (SRV_PROC *pSrvProc, CHAR* szErrorMsg)
{
srv_sendmsg(pSrvProc, SRV_MSG_ERROR, XP_HELLO_ERROR, SRV_INFO, 1,
NULL, 0, 0, szErrorMsg,SRV_NULLTERM);
Srv_senddone(pSrvProc, (SRV_DONE_ERROR | SRV_DONE_MORE), 0, 0);
}
srv_sendmsg და srv_senddone ფუნქციები მხედველობიდან დარჩა. srv_sendmsg ფუნქცია გამართლებულია კლიენტის დასახმარებლად. Axis її პროტოტიპი:
int srv_sendmsg(
SRV_PROC * srvproc,
intmsgtype,
dbint msgnum,
DBTINYINT კლასი,
DBTINYINT სახელმწიფო,
dbchar*rpcname,
int rpcnamelen,
DBUSMALLINT თეთრეული,
dbchar * შეტყობინება,
int msglen
);
msgnum შეტყობინების ნომერი;
კლასი- შეწყალების სიმძიმე, scho vinyl. საინფორმაციო ინფორმაციას შეიძლება ჰქონდეს სიმძიმის დონე 10-ზე ნაკლები ან მეტი;
სახელმწიფონომერი გახდება შიდა დახმარების შეწყალება. ეს პარამეტრი იძლევა ინფორმაციას შეწყალების კონტექსტის შესახებ. დასაშვები მნიშვნელობები დევს 0-დან 127-მდე დიაპაზონში;
rpcname არ არის გამარჯვებული ამ დროის განმავლობაში;
rpcnamelen - არ გაიმარჯვო ამ საათში;
თეთრეულიაქ შეგიძლიათ შეიყვანოთ გამომავალი კოდის რიგის ნომერი. ამ მნიშვნელობებისთვის ადვილი იქნება de vinicla-ის შეწყალების დაყენება. თუ არ გსურთ შესაძლებლობა მოიგოთ, დააყენეთ linenum 0;
შეტყობინებების ინდიკატორი რიგისთვის, რა შეიძლება გაკეთდეს კლიენტისთვის;
msglenმიანიჭეთ მნიშვნელობა ინფორმაციის რიგის ბაიტებს. თუ ეს მწკრივი მთავრდება null სიმბოლოთი, ამ პარამეტრის მნიშვნელობა შეიძლება დაყენდეს SRV_NULLTERM-ის ტოლი.
მნიშვნელობები, რომლებიც ბრუნავს:
- ზოგჯერ წარმატებას მიაღწევს
- წარუმატებლობის შემთხვევაში FAIL.
მუშაობის პროცესმა გააფართოვა შენახული პროცედურა, პასუხისმგებელია კლიენტის დამატების რეგულარულად ინფორმირება მათი სტატუსის შესახებ, tobto. nadsilati podomlennya შესახებ vikonanі diї. რისთვისაც i აღიარებულია srv_senddone ფუნქცია:
int srv_senddone(
SRV_PROC * srvproc,
DBUSMALLINT სტატუსი,
DBUSMALLINT ინფორმაცია,
DBINT რაოდენობა
);
სტატუსის ნიშანი. ამ პარამეტრის მნიშვნელობა შეიძლება დაყენდეს დამატებითი ლოგიკური AND და OR ოპერატორებისთვის, რათა დააკავშირონ მითითების მუდმივები ცხრილში:
სტატუსის დროშის აღწერა
SRV_DONE_FINAL შედეგების უწყვეტი შეგროვება ნარჩენია;
SRV_DONE_MORE შედეგების ზუსტი შეგროვება არ არის ნარჩენი კვალი მონაცემების შავ ნაწილზე გატანისთვის;
SRV_DONE_COUNT count პარამეტრს უნდა ჰქონდეს სწორი მნიშვნელობა
SRV_DONE_ERROR Vikoristovuetsya შეტყობინებისთვის შეწყალების შესახებ, რომელიც დასრულდა.
შევიდადაჯავშნა, თქვენ უნდა დააყენოთ 0.
count მონაცემების შედეგების ნაკრების რაოდენობა, რომლებიც მოთხოვნილია კლიენტს. ფაქტიურად, სტატუსი დაყენებულია SRV_DONE_COUNT, შემდეგ count პასუხისმგებელია კომპლექტების სწორი რაოდენობის ამოღებაზე, რომელსაც კლიენტი ითხოვს ჩანაწერებში.
მნიშვნელობები, რომლებიც ბრუნავს:
- ზოგჯერ წარმატებას მიაღწევს
- წარუმატებლობის შემთხვევაში FAIL.
გაფართოების პროცედურების ინსტალაცია, რომლებიც შენახულია MS SQL Server 2000-ზე
1. დააკოპირეთ dll ბიბლიოთეკა გაფართოებული შენახვის პროცედურის საშუალებით binn დირექტორიაში მანქანაზე, სადაც დაინსტალირებულია MS SQL Server. ნაკლები პრობლემა მაქვს: C:Program FilesMicrosoft SQL ServerMSSQLBinn;
2. დაარეგისტრირეთ სერვერზე შენახული გაფართოებული პროცედურა შემდეგი სკრიპტის დაწერით:
აშშ ოსტატი
შეასრულეთ SP_ADDEXTENDEDPROC xp_helloworld, xp_helloworld.dll
შეამოწმეთ xp_helloworld რობოტი შემდეგი სკრიპტის გაშვებით:
გამოაცხადე @Param varchar(33)
EXECUTE xp_helloworld @Param OUTPUT
აირჩიეთ @Param AS OUTPUT_Param
ვისნოვოკი
ამ სტატიის პირველი ნაწილი დასრულებულია. ახლა დავრწმუნდი, მზად ხართ 100%-ით ჩაერთოთ ჩვენს ტექნიკურ ამოცანებში. შემდეგ სტატიაში თქვენ აღიარებთ:
- Tipi მონაცემები, დანიშნული ODS API-ში;
- დანაზოგის პროცედურების გაფართოების განსაკუთრებული შეღავათები;
- როგორ ჩამოაყალიბოთ ჩანაწერების ნაკრები და გადაიტანოთ იგი თქვენი კლიენტის დამატებაში;
- ხშირად განხილული Active Directory Network Manegment API ფუნქციები, რომლებიც საჭიროა დომენური სახელების სიის სამართავად;
- ჩვენ ვქმნით მზა პროექტს (ვახორციელებთ ჩვენს ტექნიკურ პროექტს)
დაბლა ჩავდივარ - შვედურ ზუსტრიხში!
PS: განაცხადის ფაილები სტატისტიკისთვის სტუდია 7.0-ისთვის