1. ศึกษาตัวดำเนินการที่อธิบายขั้นตอนการจัดเก็บและหลักการในการส่งผ่านพารามิเตอร์อินพุตและเอาต์พุต
2. เรียนรู้วิธีสร้างและแก้ไขขั้นตอนการจัดเก็บบน MS SQL Server 2000
3. พัฒนาขั้นตอนการจัดเก็บพื้นฐานห้าขั้นตอนสำหรับฐานข้อมูลการฝึกอบรมห้องสมุด
4. จัดทำรายงานผลงานที่ทำในรูปแบบอิเล็กทรอนิกส์

1. ทำความเข้าใจขั้นตอนการจัดเก็บ

ขั้นตอนการจัดเก็บนี่คือชุดคำสั่งที่จัดเก็บไว้ในเซิร์ฟเวอร์และดำเนินการเป็นหน่วยเดียว ขั้นตอนที่เก็บไว้เป็นกลไกที่คุณสามารถสร้างรูทีนที่ทำงานบนเซิร์ฟเวอร์และถูกควบคุมโดยกระบวนการต่างๆ แอปพลิเคชันที่เรียกใช้รูทีนดังกล่าวสามารถเรียกใช้ได้ นอกจากนี้ยังอาจเกิดจากกฎหรือทริกเกอร์ความสมบูรณ์ของข้อมูลอีกด้วย

ขั้นตอนที่เก็บไว้สามารถส่งคืนค่าได้ ขั้นตอนสามารถเปรียบเทียบค่าที่ผู้ใช้ป้อนกับข้อมูลที่ตั้งค่าไว้ล่วงหน้าในระบบ ขั้นตอนการจัดเก็บใช้ประโยชน์จากโซลูชันฮาร์ดแวร์ SQL Server ที่มีประสิทธิภาพ พวกเขาเป็นศูนย์กลางฐานข้อมูลและทำงานอย่างใกล้ชิดกับเครื่องมือเพิ่มประสิทธิภาพ SQL Server สิ่งนี้ช่วยให้คุณได้รับประสิทธิภาพสูงเมื่อประมวลผลข้อมูล

คุณสามารถส่งผ่านค่าไปยังกระบวนงานที่เก็บไว้และรับผลลัพธ์โดยไม่จำเป็นต้องเกี่ยวข้องกับแผ่นงาน กระบวนงานที่เก็บไว้สามารถคำนวณผลลัพธ์ในขณะที่ทำงาน

กระบวนการจัดเก็บมีสองประเภท: สามัญและ ขยาย- ขั้นตอนการจัดเก็บแบบปกติคือชุดของคำสั่ง Transact-SQL ในขณะที่ขั้นตอนการจัดเก็บแบบขยายจะแสดงเป็นไลบรารีลิงก์แบบไดนามิก (DLL) ขั้นตอนดังกล่าวมีคำนำหน้า xp_ ซึ่งแตกต่างจากขั้นตอนทั่วไป เซิร์ฟเวอร์มีชุดขั้นตอนเพิ่มเติมมาตรฐาน แต่ผู้ใช้สามารถเขียนขั้นตอนของตนเองในภาษาการเขียนโปรแกรมใดก็ได้ สิ่งสำคัญคือการใช้อินเทอร์เฟซการเขียนโปรแกรม API บริการข้อมูลเปิดของเซิร์ฟเวอร์ SQL- ขั้นตอนการจัดเก็บแบบขยายสามารถอยู่ในฐานข้อมูลหลักเท่านั้น

ขั้นตอนการจัดเก็บแบบปกติยังสามารถแบ่งออกได้เป็น 2 ประเภท: เป็นระบบและ กำหนดเอง- ขั้นตอนของระบบเหล่านี้เป็นขั้นตอนมาตรฐานที่ใช้ในการดำเนินงานเซิร์ฟเวอร์ กำหนดขั้นตอนใด ๆ ที่สร้างโดยผู้ใช้

1.1. ประโยชน์ของขั้นตอนการจัดเก็บ

ในกรณีทั่วไปส่วนใหญ่ กระบวนการจัดเก็บมีข้อดีดังต่อไปนี้:

• ประสิทธิภาพสูงเป็นผลมาจากตำแหน่งของขั้นตอนการจัดเก็บบนเซิร์ฟเวอร์ ตามกฎแล้วเซิร์ฟเวอร์เป็นเครื่องที่ทรงพลังกว่าดังนั้นเวลาดำเนินการของขั้นตอนบนเซิร์ฟเวอร์จึงน้อยกว่าบนเวิร์กสเตชันอย่างมาก นอกจากนี้ ข้อมูลฐานข้อมูลและขั้นตอนการจัดเก็บยังอยู่ในระบบเดียวกัน ดังนั้นจึงใช้เวลาเพียงเล็กน้อยในการถ่ายโอนบันทึกผ่านเครือข่าย ขั้นตอนการจัดเก็บสามารถเข้าถึงฐานข้อมูลได้โดยตรง ซึ่งทำให้การทำงานกับข้อมูลรวดเร็วมาก
• ข้อดีของการพัฒนาระบบในสถาปัตยกรรมไคลเอ็นต์-เซิร์ฟเวอร์ประกอบด้วยความเป็นไปได้ในการสร้างซอฟต์แวร์ไคลเอนต์และเซิร์ฟเวอร์แยกกัน ข้อได้เปรียบนี้เป็นกุญแจสำคัญในการพัฒนาและสามารถลดเวลาที่ต้องใช้ในการดำเนินโครงการให้เสร็จสิ้นได้อย่างมาก รหัสที่ทำงานบนเซิร์ฟเวอร์สามารถพัฒนาแยกจากรหัสฝั่งไคลเอ็นต์ได้ ในกรณีนี้ ส่วนประกอบฝั่งเซิร์ฟเวอร์สามารถแชร์กับส่วนประกอบฝั่งไคลเอ็นต์ได้
• ระดับความปลอดภัยขั้นตอนที่เก็บไว้สามารถทำหน้าที่เป็นเครื่องมือเพิ่มประสิทธิภาพการรักษาความปลอดภัยได้ คุณสามารถสร้างขั้นตอนการจัดเก็บที่ดำเนินการเพิ่ม แก้ไข ลบ และแสดงรายการ ทำให้คุณสามารถควบคุมการเข้าถึงข้อมูลได้ทุกด้าน
• เสริมสร้างกฎเซิร์ฟเวอร์ที่ทำงานกับข้อมูลนี่เป็นหนึ่งในเหตุผลที่สำคัญที่สุดในการใช้กลไกฐานข้อมูลอัจฉริยะ ขั้นตอนที่เก็บไว้ช่วยให้คุณสามารถใช้กฎและตรรกะอื่น ๆ ที่ช่วยควบคุมข้อมูลที่ป้อนเข้าสู่ระบบ

แม้ว่า SQL จะถูกกำหนดให้เป็นภาษาที่ไม่ใช่ขั้นตอน แต่ SQL Server จะใช้คำสำคัญที่เกี่ยวข้องกับการจัดการโฟลว์ของโพรซีเดอร์ คำสำคัญดังกล่าวใช้เพื่อสร้างขั้นตอนที่สามารถบันทึกไว้สำหรับการดำเนินการในภายหลัง Stored Procedure สามารถใช้แทนโปรแกรมที่เขียนด้วยภาษาโปรแกรมมาตรฐาน (เช่น C หรือ Visual Basic) ที่ดำเนินการกับฐานข้อมูล SQL Server

ขั้นตอนที่เก็บไว้จะถูกคอมไพล์ในครั้งแรกที่ดำเนินการและจัดเก็บไว้ในตารางระบบในฐานข้อมูลปัจจุบัน ได้รับการปรับให้เหมาะสมเมื่อคอมไพล์ นี่เป็นการเลือกวิธีที่ดีที่สุดในการเข้าถึงข้อมูลตาราง การเพิ่มประสิทธิภาพนี้จะคำนึงถึงตำแหน่งที่แท้จริงของข้อมูลในตาราง ดัชนีที่มีอยู่ โหลดตาราง ฯลฯ

ขั้นตอนการจัดเก็บที่คอมไพล์สามารถปรับปรุงประสิทธิภาพของระบบได้อย่างมาก อย่างไรก็ตาม เป็นที่น่าสังเกตว่าสถิติข้อมูลตั้งแต่เวลาที่สร้างขั้นตอนจนถึงเวลาที่ดำเนินการอาจล้าสมัย และดัชนีอาจไม่มีประสิทธิภาพ แม้ว่าคุณจะสามารถอัปเดตสถิติและเพิ่มดัชนีใหม่ที่มีประสิทธิภาพมากขึ้นได้ แต่แผนการดำเนินการสำหรับขั้นตอนดังกล่าวได้ถูกเขียนไว้แล้ว กล่าวคือ ขั้นตอนได้รับการรวบรวมแล้ว และด้วยเหตุนี้ วิธีที่คุณเข้าถึงข้อมูลอาจไม่มีประสิทธิภาพอีกต่อไป ดังนั้นจึงเป็นไปได้ที่จะคอมไพล์ขั้นตอนใหม่ทุกครั้งที่มีการเรียก

ในทางกลับกัน การคอมไพล์ใหม่จะใช้เวลาในแต่ละครั้ง ดังนั้นคำถามเกี่ยวกับประสิทธิผลของการคอมไพล์ขั้นตอนใหม่หรือการวางแผนสำหรับการดำเนินการในคราวเดียวจึงค่อนข้างละเอียดอ่อนและควรพิจารณาสำหรับแต่ละกรณีแยกกัน

ขั้นตอนที่เก็บไว้สามารถดำเนินการได้ทั้งบนเครื่องภายในหรือบนระบบ SQL Server ระยะไกล ทำให้สามารถเปิดใช้งานกระบวนการบนเครื่องอื่นได้ และไม่เพียงแต่ทำงานกับฐานข้อมูลท้องถิ่นเท่านั้น แต่ยังรวมถึงข้อมูลบนเซิร์ฟเวอร์หลายเครื่องด้วย

แอปพลิเคชันที่เขียนด้วยภาษาระดับสูง เช่น C หรือ Visual Basic .NET ยังสามารถเรียกกระบวนงานที่เก็บไว้ได้ โดยให้สมดุลโหลดที่เหมาะสมที่สุดระหว่างซอฟต์แวร์ฝั่งไคลเอ็นต์และซอฟต์แวร์เซิร์ฟเวอร์ SQL

1.2. การสร้างขั้นตอนการจัดเก็บ

เมื่อต้องการสร้างกระบวนงานที่เก็บไว้ ให้ใช้คำสั่ง Create Procedure ชื่อขั้นตอนการจัดเก็บสามารถมีความยาวได้สูงสุด 128 อักขระ รวมทั้งอักขระ # และ ## ไวยากรณ์คำจำกัดความของขั้นตอน:

สร้าง PROC Procedure_name [; ตัวเลข]
[(@data_type พารามิเตอร์) [= default_value] ] [,...n]

เช่น
<Инструкции_SQL>

ลองดูพารามิเตอร์ของคำสั่งนี้:

• Procedure_name ชื่อขั้นตอน; ต้องเป็นไปตามกฎสำหรับตัวระบุ: ความยาวต้องไม่เกิน 128 อักขระ สำหรับขั้นตอนชั่วคราวในท้องถิ่น เครื่องหมาย # จะถูกใช้หน้าชื่อ และสำหรับขั้นตอนชั่วคราวแบบโกลบอล ##;
• Number จำนวนเต็มเผื่อเลือกที่ใช้จัดกลุ่มหลายขั้นตอนภายใต้ชื่อเดียว
• @พารามิเตอร์ data_typeรายการชื่อพารามิเตอร์ของขั้นตอนที่ระบุประเภทข้อมูลที่สอดคล้องกันสำหรับแต่ละรายการ สามารถส่งพารามิเตอร์ดังกล่าวได้สูงสุด 2100 รายการเป็นค่าพารามิเตอร์ สามารถใช้ข้อมูลได้ทุกประเภท ยกเว้นประเภทข้อความ ข้อความ และรูปภาพ คุณสามารถใช้ชนิดข้อมูลเคอร์เซอร์เป็นพารามิเตอร์เอาต์พุตได้ (คีย์เวิร์ด OUTPUT หรือ VARYING) พารามิเตอร์ที่มีชนิดข้อมูลเคอร์เซอร์สามารถเป็นพารามิเตอร์เอาต์พุตเท่านั้น
• คีย์เวิร์ด VARYING ที่ระบุว่าชุดผลลัพธ์ถูกใช้เป็นพารามิเตอร์เอาต์พุต (ใช้สำหรับประเภทเคอร์เซอร์เท่านั้น)
• OUTPUT บ่งชี้ว่าพารามิเตอร์ที่ระบุสามารถใช้เป็นเอาต์พุตได้
• default_valueใช้เมื่อละเว้นพารามิเตอร์เมื่อเรียกขั้นตอน ต้องเป็นค่าคงที่และสามารถรวมอักขระไวด์การ์ด (%, _, [, ], ^) และค่า NULL
• ด้วยคีย์เวิร์ด RECOMPILE ที่ระบุว่า SQL Server จะไม่เขียนแผนขั้นตอนลงในแคช แต่จะสร้างมันขึ้นมาทุกครั้งที่ดำเนินการ
• คีย์เวิร์ดที่มีการเข้ารหัสระบุว่า SQL Server จะเข้ารหัสขั้นตอนก่อนที่จะเขียนลงในตารางระบบ Syscomments เพื่อทำให้ข้อความของโพรซีเดอร์ที่เข้ารหัสไม่สามารถกู้คืนได้ จำเป็นต้องลบ tuples ที่เกี่ยวข้องออกจากตารางข้อคิดเห็นระบบหลังจากการเข้ารหัส
• คีย์เวิร์ด FOR REPLICATION ระบุว่าขั้นตอนนี้ถูกสร้างขึ้นสำหรับการจำลองเท่านั้น ตัวเลือกนี้เข้ากันไม่ได้กับคีย์เวิร์ด WITH RECOMPILE
• เป็น จุดเริ่มต้นของคำจำกัดความของข้อความขั้นตอน;
• <Инструкции_SQL>ชุดคำสั่ง SQL ที่ถูกต้อง จำกัดด้วยขนาดสูงสุดของขั้นตอนการจัดเก็บ 128 KB เท่านั้น ข้อความต่อไปนี้ไม่ถูกต้อง: แก้ไขฐานข้อมูล, แก้ไขขั้นตอน, แก้ไขตาราง, สร้างค่าเริ่มต้น, สร้างขั้นตอน, เปลี่ยนทริกเกอร์, เปลี่ยนมุมมอง, สร้างฐานข้อมูล, สร้างกฎ, สร้าง SCHEMA, สร้างทริกเกอร์, สร้างมุมมอง, DISK INIT, ปรับขนาดดิสก์, วางข้อมูล ค่าเริ่มต้นการดรอปฐาน, ขั้นตอนการดรอป, กฎการดรอป, ทริกเกอร์ดรอป, มุมมองดรอป, ฐานข้อมูลรีซอร์ส, บันทึกการกู้คืน, กำหนดค่าใหม่, อัปเดตสถิติ

ลองดูตัวอย่างของขั้นตอนการจัดเก็บ มาพัฒนาขั้นตอนการจัดเก็บที่นับและแสดงจำนวนสำเนาหนังสือที่อยู่ในห้องสมุดในปัจจุบัน:

สร้างขั้นตอน Count_Ex1
- ขั้นตอนการนับจำนวนสำเนาหนังสือ
- ขณะนี้อยู่ในห้องสมุด
- และไม่อยู่ในมือของผู้อ่าน
เช่น
-- ตั้งค่าตัวแปรท้องถิ่นชั่วคราว
ประกาศ @N int
เลือก @N = count(*) จากตัวอย่าง โดยที่ Yes_No = "1"
เลือก @N
ไป

เนื่องจากกระบวนงานที่เก็บไว้เป็นส่วนประกอบที่สมบูรณ์ของฐานข้อมูล ดังนั้นตามที่คุณเข้าใจแล้ว คุณสามารถสร้างขั้นตอนใหม่สำหรับฐานข้อมูลปัจจุบันเท่านั้น เมื่อทำงานใน SQL Server Query Analyzer การตั้งค่าฐานข้อมูลปัจจุบันจะเสร็จสิ้นด้วยคำสั่ง Use ตามด้วยชื่อของฐานข้อมูลที่จะสร้างกระบวนงานที่เก็บไว้ คุณยังสามารถเลือกฐานข้อมูลปัจจุบันโดยใช้รายการแบบเลื่อนลง

หลังจากสร้างกระบวนงานที่เก็บไว้บนระบบแล้ว SQL Server จะคอมไพล์และตรวจสอบรูทีนที่ดำเนินการ หากมีปัญหาใดๆ เกิดขึ้น ขั้นตอนจะถูกปฏิเสธ ข้อผิดพลาดจะต้องได้รับการแก้ไขก่อนที่จะส่งอีกครั้ง

SQL Server 2000 ใช้การจำแนกชื่อที่ล่าช้า ดังนั้นหากกระบวนงานที่เก็บไว้ประกอบด้วยการเรียกไปยังขั้นตอนอื่นที่ยังไม่ได้ถูกนำมาใช้ คำเตือนจะถูกพิมพ์ แต่การเรียกไปยังขั้นตอนที่ไม่มีอยู่จะถูกรักษาไว้

ถ้าคุณออกจากการเรียกไปยังขั้นตอนการจัดเก็บที่ถอนการติดตั้งบนระบบ ผู้ใช้จะได้รับข้อความแสดงข้อผิดพลาดเมื่อพยายามดำเนินการ

คุณยังสามารถสร้างขั้นตอนการจัดเก็บโดยใช้ SQL Server Enterprise Manager:

ในการตรวจสอบการทำงานของขั้นตอนการจัดเก็บที่สร้างขึ้น คุณต้องไปที่ Query Analyzer และเรียกใช้ขั้นตอนสำหรับการดำเนินการโดยผู้ดำเนินการ EXEC<имя процедуры> - ผลลัพธ์ของการดำเนินการตามขั้นตอนที่เราสร้างขึ้นจะแสดงไว้ในรูปที่ 1 4.

ข้าว. 4. การเรียกใช้กระบวนงานที่เก็บไว้ใน Query Analyzer

ข้าว. 5. ผลลัพธ์ของการดำเนินการตามขั้นตอนโดยไม่มีตัวดำเนินการแสดงผล

1.3. พารามิเตอร์ขั้นตอนการจัดเก็บ

ขั้นตอนการจัดเก็บเป็นเครื่องมือที่ทรงพลังมาก แต่ประสิทธิภาพสูงสุดสามารถทำได้โดยการทำให้เป็นแบบไดนามิกเท่านั้น นักพัฒนาจะต้องสามารถส่งค่าขั้นตอนการจัดเก็บที่จะใช้งานได้นั่นคือพารามิเตอร์ ด้านล่างนี้เป็นหลักการพื้นฐานสำหรับการใช้พารามิเตอร์ในขั้นตอนการจัดเก็บ

• คุณสามารถกำหนดพารามิเตอร์ตั้งแต่หนึ่งตัวขึ้นไปสำหรับขั้นตอนได้
• พารามิเตอร์ถูกใช้เป็นสถานที่ที่มีชื่อในการจัดเก็บข้อมูล เช่นเดียวกับตัวแปรในภาษาการเขียนโปรแกรม เช่น C, Visual Basic .NET
• ชื่อพารามิเตอร์ต้องนำหน้าด้วยสัญลักษณ์ @
• ชื่อพารามิเตอร์อยู่ในเครื่องของขั้นตอนที่กำหนดไว้
• พารามิเตอร์ใช้ในการส่งข้อมูลไปยังขั้นตอนเมื่อมีการดำเนินการ จะปรากฏบนบรรทัดคำสั่งหลังชื่อขั้นตอน
• หากโพรซีเดอร์มีหลายพารามิเตอร์ จะถูกคั่นด้วยเครื่องหมายจุลภาค
• ในการกำหนดประเภทของข้อมูลที่ส่งผ่านเป็นพารามิเตอร์ จะใช้ประเภทข้อมูลของระบบหรือผู้ใช้

ด้านล่างนี้คือคำจำกัดความของขั้นตอนที่มีพารามิเตอร์อินพุตหนึ่งตัว มาเปลี่ยนงานก่อนหน้าและนับไม่ใช่สำเนาหนังสือทั้งหมด แต่นับเฉพาะสำเนาของหนังสือเล่มใดเล่มหนึ่งเท่านั้น หนังสือของเรามีการระบุ ISBN ที่ไม่ซ้ำกัน ดังนั้นเราจะส่งพารามิเตอร์นี้ไปยังขั้นตอน ในกรณีนี้ ข้อความของ Stored Procedure จะเปลี่ยนไปและจะมีลักษณะดังนี้:

สร้างขั้นตอน Count_Ex(@ISBN varchar(14))
เช่น
ประกาศ @N int
เลือก @N
ไป

เมื่อเราเรียกใช้ขั้นตอนนี้เพื่อดำเนินการ เราต้องส่งผ่านค่าของพารามิเตอร์อินพุต (รูปที่ 6)

ข้าว. 6. การเริ่มขั้นตอนโดยส่งพารามิเตอร์

เมื่อต้องการสร้างขั้นตอนเดียวกันหลายเวอร์ชันที่มีชื่อเดียวกัน ให้ทำตามชื่อฐานด้วยเครื่องหมายอัฒภาคและจำนวนเต็ม วิธีการทำเช่นนี้จะแสดงอยู่ในตัวอย่างต่อไปนี้ ซึ่งอธิบายวิธีการสร้างสองขั้นตอนที่มีชื่อเดียวกัน แต่มีหมายเลขเวอร์ชันที่แตกต่างกัน (1 และ 2) หมายเลขนี้ใช้เพื่อควบคุมเวอร์ชันของขั้นตอนนี้ที่กำลังดำเนินการ หากไม่มีการระบุหมายเลขเวอร์ชัน ระบบจะดำเนินการขั้นตอนเวอร์ชันแรก ตัวเลือกนี้ไม่แสดงในตัวอย่างก่อนหน้านี้ แต่ยังคงมีให้ใช้งานสำหรับแอปพลิเคชันของคุณ

ทั้งสองขั้นตอนใช้คำสั่งพิมพ์เพื่อพิมพ์ข้อความระบุเวอร์ชัน เวอร์ชันแรกนับจำนวนสำเนาที่แจกฟรี และเวอร์ชันที่สองคือจำนวนสำเนาที่มีอยู่ในหนังสือแต่ละเล่ม

ข้อความของขั้นตอนทั้งสองเวอร์ชันมีดังต่อไปนี้:

สร้างขั้นตอน Count_Ex_all; 1
(@ISBN วาชาร์(14))
-- ขั้นตอนการนับสำเนาหนังสือที่แจกฟรี
เช่น
ประกาศ @N int
เลือก @N = count(*) จากตัวอย่าง โดยที่ ISBN = @ISBN และ Yes_No = "1"
เลือก @N
--
ไป
--
สร้างขั้นตอน Count_Ex_all; 2
(@ISBN วาชาร์(14))
-- ขั้นตอนการนับสำเนาหนังสือที่แจกฟรี
เช่น
ประกาศ @N1 int
เลือก @N1 = count(*) จากตัวอย่าง โดยที่ ISBN = @ISBN และ Yes_No = "0"
เลือก @N1
ไป

ผลลัพธ์ของการดำเนินการตามขั้นตอนในเวอร์ชันต่างๆ จะแสดงในรูป 7.

ข้าว. 7. ผลลัพธ์ของการรันโพรซีเดอร์ที่เก็บไว้เดียวกันในเวอร์ชันที่แตกต่างกัน

เมื่อเขียนหลายเวอร์ชัน โปรดคำนึงถึงข้อจำกัดต่อไปนี้: เนื่องจากเวอร์ชันของโพรซีเดอร์ทั้งหมดถูกคอมไพล์ไว้ด้วยกัน ตัวแปรโลคัลทั้งหมดจึงถือว่าใช้ร่วมกัน ดังนั้น หากอัลกอริธึมการประมวลผลต้องการสิ่งนี้ ก็จำเป็นต้องใช้ชื่อตัวแปรภายในที่แตกต่างกัน ซึ่งเป็นสิ่งที่เราทำโดยการเรียกตัวแปร @N ในขั้นตอนที่สองด้วยชื่อ @N1

ขั้นตอนที่เราเขียนไม่ได้ส่งคืนพารามิเตอร์เพียงตัวเดียว แต่เพียงแสดงหมายเลขผลลัพธ์บนหน้าจอ อย่างไรก็ตาม บ่อยครั้งเราจำเป็นต้องได้รับพารามิเตอร์สำหรับการประมวลผลต่อไป มีหลายวิธีในการส่งคืนพารามิเตอร์จากกระบวนงานที่เก็บไว้ วิธีที่ง่ายที่สุดคือการใช้ตัวดำเนินการ RETURN โอเปอเรเตอร์นี้จะส่งคืนค่าตัวเลขเดียว แต่เราต้องระบุชื่อตัวแปรหรือนิพจน์ที่กำหนดให้กับพารามิเตอร์ส่งคืน ต่อไปนี้เป็นค่าที่ส่งคืนโดยคำสั่ง RETURN และสงวนไว้โดยระบบ:

รหัส	ความหมาย
0	ทุกอย่างเรียบร้อยดี
1	ไม่พบวัตถุ
2	ข้อผิดพลาดประเภทข้อมูล
3	กระบวนการนี้ตกเป็นเหยื่อของการหยุดชะงัก
4	ข้อผิดพลาดในการเข้าถึง
5	ข้อผิดพลาดทางไวยากรณ์
6	มีข้อผิดพลาดบางประการ
7	เกิดข้อผิดพลาดกับทรัพยากร (ไม่มีที่ว่าง)
8	เกิดข้อผิดพลาดภายในที่สามารถกู้คืนได้
9	ถึงขีดจำกัดของระบบแล้ว
10	การละเมิดความสมบูรณ์ภายในที่แก้ไขไม่ได้
11	เหมือนกัน
12	การทำลายตารางหรือดัชนี
13	การทำลายฐานข้อมูล
14	ข้อผิดพลาดของฮาร์ดแวร์

ดังนั้น เพื่อไม่ให้ขัดแย้งกับระบบ เราสามารถคืนค่าจำนวนเต็มบวกผ่านพารามิเตอร์นี้เท่านั้น

ตัวอย่างเช่น เราสามารถเปลี่ยนข้อความของขั้นตอนการจัดเก็บที่เขียนไว้ก่อนหน้านี้ Count_ex ได้ดังนี้:

สร้างขั้นตอน Count_Ex2(@ISBN varchar(14))
เช่น
ประกาศ @N int
เลือก @N = count(*) จาก Exemplar
โดยที่ ISBN = @ISBN และ YES_NO = "1"
-- ส่งกลับค่าของตัวแปร @N
-- หากไม่ได้กำหนดค่าของตัวแปร ให้ส่งคืน 0
ส่งคืน Coalesce(@N, 0)
ไป

ตอนนี้เราสามารถรับค่าของตัวแปร @N และใช้สำหรับการประมวลผลต่อไป ในกรณีนี้ ค่าที่ส่งคืนถูกกำหนดให้กับกระบวนงานที่เก็บไว้ และเพื่อที่จะแยกวิเคราะห์ คุณสามารถใช้รูปแบบคำสั่งการเรียกกระบวนงานที่เก็บไว้ต่อไปนี้:

ผู้บริหาร<переменная> = <имя_процедуры> <значение_входных_параметров>

ตัวอย่างการเรียกขั้นตอนของเราแสดงไว้ในรูปที่ 1 8.

ข้าว. 8. การส่งคืนค่าส่งคืนของกระบวนงานที่เก็บไว้ไปยังตัวแปรท้องถิ่น

พารามิเตอร์อินพุตขั้นตอนที่เก็บไว้สามารถใช้ค่าเริ่มต้นได้ ค่านี้จะถูกนำมาใช้หากไม่ได้ระบุค่าพารามิเตอร์เมื่อเรียกใช้ขั้นตอน

ค่าเริ่มต้นจะถูกระบุโดยใช้เครื่องหมายเท่ากับหลังคำอธิบายของพารามิเตอร์อินพุตและประเภทของพารามิเตอร์ พิจารณาขั้นตอนการจัดเก็บที่นับจำนวนสำเนาหนังสือในปีที่จัดพิมพ์ ปีที่วางจำหน่ายเริ่มต้นคือปี 2549

สร้างขั้นตอน ex_books_now(@year int = 2006)
- การนับจำนวนเล่มในแต่ละปีที่พิมพ์
เช่น
ประกาศ @N_books int
เลือก @N_books = count(*) จากหนังสือ ตัวอย่าง
โดยที่ Books.ISBN = exemplar.ISBN และ YEARIZD = @year
ส่งคืนการรวมตัว(@N_books, 0)
ไป

ในรูป รูปที่ 9 แสดงตัวอย่างการเรียกโพรซีเดอร์นี้โดยมีและไม่มีการระบุพารามิเตอร์อินพุต

ข้าว. 9. การเรียกกระบวนงานที่เก็บไว้โดยมีและไม่มีพารามิเตอร์

ตัวอย่างข้างต้นทั้งหมดของการใช้พารามิเตอร์ในขั้นตอนการจัดเก็บที่ให้มาเฉพาะพารามิเตอร์อินพุตเท่านั้น อย่างไรก็ตาม พารามิเตอร์อาจถูกส่งออกด้วย ซึ่งหมายความว่าค่าของพารามิเตอร์หลังจากขั้นตอนเสร็จสมบูรณ์จะถูกส่งผ่านไปยังบุคคลที่เรียกใช้ขั้นตอนนี้ (ขั้นตอนอื่น ทริกเกอร์ ชุดคำสั่ง ฯลฯ) โดยปกติแล้ว ในการรับพารามิเตอร์เอาต์พุต เมื่อทำการเรียก คุณควรระบุไม่ใช่ค่าคงที่ แต่ให้ระบุตัวแปรเป็นพารามิเตอร์จริง

โปรดทราบว่าการกำหนดพารามิเตอร์เป็นพารามิเตอร์เอาต์พุตในโพรซีเดอร์ไม่ได้บังคับให้คุณใช้พารามิเตอร์ดังกล่าว นั่นคือ หากคุณระบุค่าคงที่เป็นพารามิเตอร์จริง ก็จะไม่มีข้อผิดพลาดเกิดขึ้น และจะใช้เป็นพารามิเตอร์อินพุตปกติ

เพื่อระบุว่าพารามิเตอร์เป็นเอาต์พุต จะใช้คำสั่ง OUTPUT คีย์เวิร์ดนี้เขียนไว้หลังคำอธิบายพารามิเตอร์ เมื่ออธิบายพารามิเตอร์ของกระบวนงานที่เก็บไว้แนะนำให้ระบุค่าของพารามิเตอร์เอาต์พุตหลังค่าอินพุต

ลองดูตัวอย่างการใช้พารามิเตอร์เอาต์พุต เรามาเขียนขั้นตอนการจัดเก็บที่นับจำนวนสำเนาทั้งหมดในห้องสมุดและจำนวนสำเนาที่แจกฟรีสำหรับหนังสือเล่มหนึ่งๆ เราจะไม่สามารถใช้คำสั่ง RETURN ที่นี่ได้เนื่องจากจะส่งคืนค่าเพียงค่าเดียว ดังนั้นเราจึงจำเป็นต้องกำหนดพารามิเตอร์เอาต์พุตที่นี่ ข้อความขั้นตอนการจัดเก็บอาจมีลักษณะดังนี้:

สร้างขั้นตอน Count_books_all
(@ISBN varchar(14), @all int เอาท์พุต, @free int เอาท์พุต)
--ขั้นตอนการนับจำนวนสำเนาของหนังสือเล่มหนึ่งๆ
-- และจำนวนสำเนาที่แจกฟรี
เช่น
-- การนับจำนวนสำเนาทั้งหมด
เลือก @all = count(*) จากตัวอย่าง โดยที่ ISBN = @ISBN
เลือก @free = count(*) จากตัวอย่าง โดยที่ ISBN = @ISBN และ Yes_No = "1"
ไป

ตัวอย่างของขั้นตอนนี้แสดงไว้ในรูปที่ 1 10.

ข้าว. 10. การทดสอบขั้นตอนการจัดเก็บด้วยพารามิเตอร์เอาท์พุต

ดังที่ได้กล่าวไว้ก่อนหน้านี้ เพื่อให้ได้ค่าของพารามิเตอร์เอาต์พุตสำหรับการวิเคราะห์ เราต้องตั้งค่าให้เป็นตัวแปร และตัวแปรเหล่านี้จะต้องอธิบายโดยตัวดำเนินการ Declare คำสั่งเอาต์พุตสุดท้ายช่วยให้เราสามารถพิมพ์ค่าผลลัพธ์ลงบนหน้าจอได้

พารามิเตอร์ขั้นตอนสามารถเป็นตัวแปรประเภท Cursor ได้ เมื่อต้องการทำเช่นนี้ ตัวแปรต้องได้รับการอธิบายว่าเป็นประเภทข้อมูลพิเศษ VARYING โดยไม่มีการเชื่อมโยงกับประเภทข้อมูลระบบมาตรฐาน นอกจากนี้ จะต้องระบุว่านี่คือตัวแปรประเภท Cursor

เรามาเขียนขั้นตอนง่ายๆ เพื่อแสดงรายการหนังสือในห้องสมุดของเรากัน ยิ่งไปกว่านั้น หากมีหนังสือไม่เกินสามเล่ม เราจะแสดงชื่อหนังสือเหล่านั้นภายในขั้นตอนนั้นเอง และหากรายชื่อหนังสือเกินจำนวนที่ระบุ เราก็จะส่งผ่านเป็นเคอร์เซอร์ไปยังโปรแกรมหรือโมดูลที่เรียก

ข้อความของขั้นตอนมีลักษณะดังนี้:

สร้างขั้นตอน GET3TITLES
(@MYCURSOR เคอร์เซอร์ที่แตกต่างกันออกไป)
-- ขั้นตอนการพิมพ์ชื่อหนังสือด้วยเคอร์เซอร์
เช่น
-- กำหนดตัวแปรท้องถิ่นประเภทเคอร์เซอร์ในขั้นตอน
SET @MYCURSOR = เคอร์เซอร์
สำหรับเลือกชื่อที่แตกต่าง
จากหนังสือ
-- เปิดเคอร์เซอร์
เปิด @MYCURSOR
-- อธิบายตัวแปรท้องถิ่นภายใน
ประกาศ @TITLE VARCHAR (80), @CNT INT
--- กำหนดสถานะเริ่มต้นของตัวนับหนังสือ
SET @CNT = 0
-- ไปที่บรรทัดแรกของเคอร์เซอร์
-- ขณะที่มีเส้นเคอร์เซอร์
-- นั่นคือ ตราบใดที่การเปลี่ยนไปใช้บรรทัดใหม่นั้นถูกต้อง
ในขณะที่ (@@FETCH_STATUS = 0) และ (@CNT<= 2) BEGIN
พิมพ์ @TITLE
ดึงข้อมูลถัดไปจาก @MYCURSOR เข้าสู่ @TITLE
-- เปลี่ยนสถานะของตัวนับหนังสือ
SET @CNT = @CNT + 1
จบ
ถ้า @CNT = 0 พิมพ์ "ไม่มีหนังสือที่ตรงกัน"
ไป

ตัวอย่างการเรียก Stored Procedure ดังแสดงในรูป 11.

ในขั้นตอนการเรียก เคอร์เซอร์ต้องถูกประกาศเป็นตัวแปรภายในเครื่อง จากนั้นเราเรียกโพรซีเดอร์ของเราและส่งผ่านชื่อของตัวแปรชนิดเคอร์เซอร์ในเครื่อง ขั้นตอนเริ่มทำงานและแสดงชื่อสามชื่อแรกบนหน้าจอ จากนั้นโอนการควบคุมไปยังขั้นตอนการเรียก และดำเนินการประมวลผลเคอร์เซอร์ต่อไป ในการดำเนินการนี้ เธอได้จัดลูป While โดยใช้ตัวแปรโกลบอล @@FETCH_STATUS ซึ่งจะตรวจสอบสถานะของเคอร์เซอร์ จากนั้นในลูปจะแสดงบรรทัดอื่นๆ ทั้งหมดของเคอร์เซอร์

ในหน้าต่างผลลัพธ์ เราเห็นระยะห่างเพิ่มขึ้นระหว่างสามบรรทัดแรกและชื่อที่ตามมา ช่วงเวลานี้แสดงให้เห็นว่าการควบคุมได้ถูกถ่ายโอนไปยังโปรแกรมภายนอกแล้ว

โปรดทราบว่าตัวแปร @TITLE ซึ่งอยู่ในโพรซีเดอร์นั้น จะถูกทำลายเมื่อสิ้นสุด ดังนั้นจึงมีการประกาศอีกครั้งในบล็อกที่เรียกใช้โพรซีเดอร์ การสร้างและการเปิดเคอร์เซอร์ในตัวอย่างนี้เกิดขึ้นในโพรซีเดอร์ และการปิด การทำลาย และการประมวลผลเพิ่มเติมจะดำเนินการในบล็อกคำสั่งที่มีการเรียกใช้โพรซีเดอร์

วิธีที่ง่ายที่สุดในการดูข้อความของขั้นตอน เปลี่ยนแปลงหรือลบคือการใช้อินเทอร์เฟซแบบกราฟิกของ Enterprise Manager แต่คุณสามารถทำได้โดยใช้ขั้นตอนการจัดเก็บระบบ Transact-SQL พิเศษ ใน Transact-SQL คุณสามารถดูข้อกำหนดของขั้นตอนได้โดยใช้ขั้นตอนของระบบ sp_helptext และคุณสามารถใช้ขั้นตอนของระบบ sp_help เพื่อแสดงข้อมูลการควบคุมเกี่ยวกับขั้นตอนดังกล่าวได้ กระบวนการของระบบsp_helptextและsp_helpยังใช้เพื่อดูวัตถุฐานข้อมูล เช่น ตาราง กฎ และการตั้งค่าเริ่มต้น

ข้อมูลเกี่ยวกับทุกเวอร์ชันของขั้นตอนเดียว โดยไม่คำนึงถึงหมายเลข จะปรากฏขึ้นทันที การลบขั้นตอนการจัดเก็บเดียวกันเวอร์ชันต่างๆ จะเกิดขึ้นพร้อมๆ กันด้วย ตัวอย่างต่อไปนี้แสดงวิธีการพิมพ์คำจำกัดความเวอร์ชัน 1 และเวอร์ชัน 2 ของ Count_Ex_all เมื่อมีการระบุชื่อเป็นพารามิเตอร์ในขั้นตอนของระบบ sp_helptext (รูปที่ 12)

ข้าว. 12. การดูข้อความขั้นตอนการจัดเก็บโดยใช้ขั้นตอนการจัดเก็บของระบบ

ขั้นตอนของระบบ SP_HELP จะแสดงคุณสมบัติและพารามิเตอร์ของขั้นตอนที่สร้างขึ้นในรูปแบบต่อไปนี้:

ชื่อ เจ้าของ พิมพ์	สร้าง_วันที่และเวลา
นับ_หนังสือ_ทั้งหมด ดีบีโอ ขั้นตอนการจัดเก็บ	2006-12-06 23:15:01.217
พารามิเตอร์_ชื่อ พิมพ์ ความยาว	มาตราส่วน	การจัดเรียง Param_order
@ISBN วาร์ชาร์ 14 14	โมฆะ	1	ซีริลลิก_ทั่วไป_CI_AS
@ทั้งหมด ภายใน 4 10	0	2	โมฆะ
@ฟรี ภายใน 4 10	0	3	โมฆะ

ลองถอดรหัสพารามิเตอร์เหล่านี้ด้วยตัวเอง พวกเขากำลังพูดถึงเรื่องอะไร?

1.4. การรวบรวมขั้นตอนการจัดเก็บ

ข้อดีของการใช้ขั้นตอนการจัดเก็บเพื่อดำเนินการชุดคำสั่ง Transact-SQL คือ จะมีการคอมไพล์ในครั้งแรกที่ดำเนินการ กระบวนการคอมไพล์จะแปลงคำสั่ง Transact-SQL จากการแสดงสัญลักษณ์ดั้งเดิมเป็นรูปแบบที่ปฏิบัติการได้ ออบเจ็กต์ใดๆ ที่เข้าถึงในขั้นตอนนี้จะถูกแปลงเป็นตัวแทนสำรองด้วย ตัวอย่างเช่น ชื่อตารางจะถูกแปลงเป็นตัวระบุออบเจ็กต์ และชื่อคอลัมน์จะถูกแปลงเป็นตัวระบุคอลัมน์

แผนการดำเนินการถูกสร้างขึ้นในลักษณะเดียวกับการดำเนินการคำสั่ง Transact-SQL เดียว แผนนี้ประกอบด้วยดัชนีที่ใช้ในการอ่านแถวจากตารางที่เข้าถึงได้โดยขั้นตอน แผนการดำเนินการของขั้นตอนถูกจัดเก็บไว้ในแคชและใช้ทุกครั้งที่มีการเรียก

หมายเหตุ: แคชของโพรซีเดอร์สามารถปรับขนาดเพื่อให้มีโพรซีเดอร์ส่วนใหญ่หรือทั้งหมดที่พร้อมสำหรับการดำเนินการ ซึ่งจะช่วยประหยัดเวลาที่จำเป็นในการสร้างแผนขั้นตอนใหม่

1.5. การคอมไพล์ใหม่อัตโนมัติ

โดยทั่วไปแล้ว แผนการดำเนินการจะพบได้ในแคชของขั้นตอน สิ่งนี้ช่วยให้คุณเพิ่มประสิทธิภาพของการดำเนินการได้ อย่างไรก็ตาม ภายใต้สถานการณ์บางอย่าง ขั้นตอนจะถูกคอมไพล์ใหม่โดยอัตโนมัติ

• ขั้นตอนนี้จะถูกคอมไพล์ใหม่เสมอเมื่อ SQL Server เริ่มทำงาน ซึ่งมักเกิดขึ้นหลังจากรีสตาร์ทระบบปฏิบัติการและเป็นครั้งแรกที่ดำเนินการตามขั้นตอนหลังการสร้าง
• แผนการดำเนินการของโพรซีเดอร์จะถูกคอมไพล์ใหม่โดยอัตโนมัติเสมอ หากดัชนีบนตารางที่โพรซีเดอร์เข้าถึงถูกละทิ้ง เนื่องจากแผนปัจจุบันเข้าถึงดัชนีที่ไม่มีอยู่แล้วเพื่ออ่านแถวของตาราง จึงต้องสร้างแผนการดำเนินการใหม่ แบบสอบถามขั้นตอนจะถูกดำเนินการเมื่อมีการอัพเดตเท่านั้น
• การรวบรวมแผนการดำเนินการยังเกิดขึ้นหากผู้ใช้รายอื่นกำลังทำงานกับแผนนี้ซึ่งอยู่ในแคช สำเนาแผนปฏิบัติการแต่ละฉบับจะถูกสร้างขึ้นสำหรับผู้ใช้คนที่สอง หากสำเนาแรกของแผนไม่ยุ่ง ก็ไม่จำเป็นต้องสร้างสำเนาที่สอง เมื่อผู้ใช้เสร็จสิ้นขั้นตอน แผนการดำเนินการจะพร้อมใช้งานในแคชสำหรับผู้ใช้รายอื่นที่มีสิทธิ์การเข้าถึงที่เหมาะสม
• ขั้นตอนจะถูกคอมไพล์ใหม่โดยอัตโนมัติหากถูกลบและสร้างใหม่ เนื่องจากขั้นตอนใหม่อาจแตกต่างจากเวอร์ชันเก่า สำเนาของแผนการดำเนินการในแคชจะถูกเอาออก และแผนจะถูกคอมไพล์ใหม่

SQL Server มุ่งมั่นที่จะปรับขั้นตอนการจัดเก็บให้เหมาะสมโดยการแคชขั้นตอนที่ใช้งานหนักที่สุด ดังนั้น สามารถใช้แผนการดำเนินการเก่าที่โหลดลงในแคชแทนแผนใหม่ได้ เพื่อป้องกันปัญหานี้ คุณควรลบและสร้างกระบวนงานที่เก็บไว้ใหม่ หรือหยุดและรีสตาร์ท SQL Server วิธีนี้จะล้างแคชของขั้นตอนและลดความเป็นไปได้ในการทำงานกับแผนการดำเนินการแบบเก่า

ขั้นตอนนี้ยังสามารถสร้างได้ด้วยตัวเลือก WITH RECOMPILE ในกรณีนี้ มันจะถูกคอมไพล์ใหม่โดยอัตโนมัติทุกครั้งที่มีการดำเนินการ ตัวเลือก WITH RECOMPILE ควรใช้ในกรณีที่ขั้นตอนเข้าถึงตารางแบบไดนามิกสูงซึ่งมีการเพิ่ม ลบ หรืออัปเดตแถวบ่อยครั้ง เนื่องจากทำให้เกิดการเปลี่ยนแปลงที่สำคัญกับดัชนีที่กำหนดไว้ในตาราง

หากขั้นตอนไม่ได้รับการคอมไพล์ใหม่โดยอัตโนมัติ คุณสามารถบังคับให้ดำเนินการดังกล่าวได้ ตัวอย่างเช่น หากสถิติที่ใช้ในการพิจารณาว่าสามารถใช้ดัชนีในการสืบค้นที่กำหนดได้หรือไม่ หรือหากมีการสร้างดัชนีใหม่ จะต้องดำเนินการบังคับการคอมไพล์ใหม่ หากต้องการบังคับให้คอมไพล์ใหม่ ให้ใช้คำสั่งย่อย WITH RECOMPILE ในคำสั่ง EXECUTE:

ดำเนินการตามขั้นตอน_ชื่อ;
เช่น
<инструкции Transact-SQL>
ด้วยการคอมไพล์ใหม่

หากขั้นตอนดำเนินการโดยใช้พารามิเตอร์ที่ควบคุมลำดับการดำเนินการ คุณควรใช้ตัวเลือก WITH RECOMPILE หากพารามิเตอร์ของกระบวนงานที่เก็บไว้สามารถกำหนดเส้นทางที่ดีที่สุดสำหรับการดำเนินการได้ ขอแนะนำให้คุณสร้างแผนการดำเนินการในขณะที่คุณเรียกใช้งาน แทนที่จะสร้างแผนในครั้งแรกที่คุณเรียกใช้ขั้นตอนเพื่อใช้ในการเรียกครั้งต่อๆ ไปทั้งหมด

หมายเหตุ: บางครั้งอาจเป็นเรื่องยากที่จะพิจารณาว่าจะใช้ตัวเลือก WITH RECOMPILE เมื่อสร้างขั้นตอนหรือไม่ หากมีข้อสงสัย จะเป็นการดีที่สุดที่จะไม่ใช้ตัวเลือกนี้ เนื่องจากการคอมไพล์ขั้นตอนใหม่ทุกครั้งที่ดำเนินการจะทำให้เสียเวลา CPU อันมีค่ามาก หากคุณต้องการคอมไพล์กระบวนงานที่เก็บไว้ใหม่ในอนาคต คุณสามารถทำได้โดยเพิ่มคำสั่งย่อย WITH RECOMPILE ให้กับคำสั่ง EXECUTE

คุณไม่สามารถใช้ตัวเลือก WITH RECOMPILE ในคำสั่ง CREATE PROCEDURE ที่มีตัวเลือก FOR REPLICATION ใช้ตัวเลือกนี้เพื่อสร้างขั้นตอนที่ทำงานในระหว่างกระบวนการจำลองแบบ

1.6. การซ้อนขั้นตอนการจัดเก็บ

Stored Procedures สามารถเรียก Stored Procedure อื่นๆ ได้ แต่มีข้อจำกัดเกี่ยวกับระดับของการซ้อน ระดับการซ้อนสูงสุดคือ 32 ระดับการซ้อนปัจจุบันสามารถกำหนดได้โดยใช้ตัวแปรโกลบอล @@NESTLEVEL

2. ฟังก์ชั่นที่ผู้ใช้กำหนด (UDF)

MS SQL SERVER 2000 มีฟังก์ชันที่กำหนดไว้ล่วงหน้ามากมายที่ช่วยให้คุณสามารถดำเนินการต่างๆ ได้ อย่างไรก็ตาม อาจจำเป็นต้องใช้ฟังก์ชันเฉพาะบางอย่างเสมอ ในการดำเนินการนี้ เริ่มตั้งแต่เวอร์ชัน 8.0 (2000) เป็นต้นไป จึงเป็นไปได้ที่จะอธิบายฟังก์ชันที่ผู้ใช้กำหนด (UDF) และจัดเก็บฟังก์ชันเหล่านี้เป็นออบเจ็กต์ฐานข้อมูลเต็มรูปแบบ พร้อมด้วยขั้นตอนการจัดเก็บ มุมมอง ฯลฯ

ความสะดวกในการใช้ฟังก์ชันที่ผู้ใช้กำหนดนั้นชัดเจน ต่างจากกระบวนงานที่เก็บไว้ตรงที่ฟังก์ชันสามารถฝังลงในคำสั่ง SELECT ได้โดยตรง และสามารถใช้เพื่อดึงค่าเฉพาะ (ในส่วนคำสั่ง SELECT) และเป็นแหล่งข้อมูล (ในส่วนคำสั่ง FROM)

เมื่อใช้ UDF เป็นแหล่งข้อมูล ข้อดีของ UDF เหนือมุมมองคือ UDF ต่างจากมุมมองตรงที่สามารถมีพารามิเตอร์อินพุตที่สามารถใช้เพื่อกำหนดผลลัพธ์ของฟังก์ชันได้

ฟังก์ชันที่ผู้ใช้กำหนดมีสามประเภท: ฟังก์ชันสเกลาร์, ฟังก์ชันอินไลน์และ ฟังก์ชันหลายคำสั่งที่ส่งคืนผลลัพธ์ตาราง- มาดูฟังก์ชันประเภทนี้ทั้งหมดให้ละเอียดยิ่งขึ้น

2.1. ฟังก์ชันสเกลาร์

ฟังก์ชันสเกลาร์ส่งกลับผลลัพธ์สเกลาร์เดียว ผลลัพธ์นี้สามารถเป็นประเภทใดก็ได้ที่อธิบายไว้ข้างต้น ยกเว้นประเภทข้อความ ntext รูปภาพ และการประทับเวลา นี่คือฟังก์ชันประเภทที่ง่ายที่สุด ไวยากรณ์ของมันมีดังนี้:

ส่งคืน scalar_data_type

เริ่ม
body_function
กลับสเกลาร์_การแสดงออก
จบ

• พารามิเตอร์ ENCRYPTION ได้รับการอธิบายไว้แล้วในส่วนเกี่ยวกับขั้นตอนการจัดเก็บ
• SCHEMABINDING ผูกฟังก์ชันเข้ากับสคีมา ซึ่งหมายความว่าคุณไม่สามารถลบตารางหรือมุมมองที่ฟังก์ชันนั้นใช้อยู่ได้โดยไม่ต้องลบหรือปรับเปลี่ยนฟังก์ชันนั้นเอง คุณไม่สามารถเปลี่ยนโครงสร้างของตารางเหล่านี้ได้หากฟังก์ชันใช้ส่วนที่เปลี่ยนแปลง ดังนั้นตัวเลือกนี้ช่วยให้คุณสามารถกำจัดสถานการณ์ที่ฟังก์ชันใช้ตารางหรือมุมมองบางส่วนและบางคนลบหรือเปลี่ยนแปลงพวกเขาโดยไม่รู้ตัว
• ส่งคืน scalar_data_typeอธิบายชนิดข้อมูลที่ฟังก์ชันส่งคืน
• สเกลาร์_เอ็กซ์เพรสชันนิพจน์ที่ส่งคืนผลลัพธ์ของฟังก์ชันโดยตรง จะต้องเป็นประเภทเดียวกันกับที่อธิบายไว้หลังการส่งคืน
• function_body ชุดคำสั่ง Transact-SQL

ลองดูตัวอย่างการใช้ฟังก์ชันสเกลาร์

สร้างฟังก์ชันที่จะเลือกจำนวนเต็มที่น้อยที่สุดจากจำนวนเต็มสองตัวที่ระบุเป็นอินพุตเป็นพารามิเตอร์

ให้ฟังก์ชันมีลักษณะดังนี้:

สร้างฟังก์ชั่น min_num(@a INT, @b INT)
ส่งคืน INT
เริ่ม
ประกาศ @c INT
ถ้า@ก< @b SET @c = @a
ตั้งค่าอื่น @c = @b
รีเทิร์น @c
จบ

ตอนนี้เรามารันฟังก์ชันนี้กัน:

เลือก dbo.min_num (4, 7)

เป็นผลให้เราได้รับค่า 4

คุณสามารถใช้ฟังก์ชันนี้เพื่อค้นหาค่าคอลัมน์ในตารางที่น้อยที่สุด:

เลือก min_lvl, max_lvl, min_num (min_lvl, max_lvl)
จากงาน

มาสร้างฟังก์ชันที่จะรับพารามิเตอร์ประเภท datetime เป็นอินพุตและส่งคืนวันที่และเวลาที่สอดคล้องกับจุดเริ่มต้นของวันที่ระบุ ตัวอย่างเช่น หากพารามิเตอร์อินพุตคือ 09.20.03 13:31 ผลลัพธ์จะเป็น 09.20.03 00:00

สร้างฟังก์ชัน dbo.daybegin(@dat DATETIME)
ส่งกลับวันเวลาขนาดเล็ก AS
เริ่ม
RETURN CONVERT (วันที่และเวลา, ชั้น (แปลง (FLOAT, @dat)))
จบ

ที่นี่ฟังก์ชัน CONVERT จะทำการแปลงประเภท ขั้นแรก ประเภทวันที่และเวลาจะถูกแปลงเป็น FLOAT ด้วยการลดลงนี้ ส่วนจำนวนเต็มคือจำนวนวัน นับตั้งแต่วันที่ 1 มกราคม 1900 และส่วนที่เป็นเศษส่วนคือเวลา จากนั้น จะปัดเศษให้เป็นจำนวนเต็มที่น้อยลงโดยใช้ฟังก์ชัน FLOOR และแปลงเป็นประเภทวันที่-เวลา

มาตรวจสอบฟังก์ชั่นกัน:

เลือก dbo.daybegin(GETDATE())

ในที่นี้ GETDATE() เป็นฟังก์ชันที่ส่งคืนวันที่และเวลาปัจจุบัน

ฟังก์ชันก่อนหน้านี้ใช้เฉพาะพารามิเตอร์อินพุตในการคำนวณเท่านั้น อย่างไรก็ตาม คุณยังสามารถใช้ข้อมูลที่จัดเก็บไว้ในฐานข้อมูลได้

มาสร้างฟังก์ชันที่จะรับวันที่สองวันเป็นพารามิเตอร์: จุดเริ่มต้นและจุดสิ้นสุดของช่วงเวลา และคำนวณรายได้จากการขายรวมสำหรับช่วงเวลานี้ วันที่และปริมาณการขายจะถูกนำมาจากตารางการขาย และราคาสำหรับหนังสือที่ขายจะถูกนำมาจากตารางชื่อเรื่อง

สร้างฟังก์ชัน dbo.SumSales(@datebegin DATETIME, @dateend DATETIME)
คืนเงิน
เช่น
เริ่ม
ประกาศ @Sum Money
SELECT @Sum = sum(t.price * s.qty)

กลับ @Sum
จบ

2.2. ฟังก์ชันอินไลน์

ฟังก์ชันประเภทนี้จะส่งกลับผลลัพธ์ไม่ใช่ค่าสเกลาร์ แต่เป็นตารางหรือชุดข้อมูล ซึ่งสะดวกมากในกรณีที่แบบสอบถามย่อยประเภทเดียวกันมักถูกดำเนินการในขั้นตอน ทริกเกอร์ ฯลฯ ที่ต่างกัน จากนั้น แทนที่จะเขียนแบบสอบถามนี้ทุกที่ คุณสามารถสร้างฟังก์ชันและใช้งานในอนาคตได้

ฟังก์ชันประเภทนี้มีประโยชน์มากยิ่งขึ้นในกรณีที่คุณต้องการให้ตารางที่ส่งคืนขึ้นอยู่กับพารามิเตอร์อินพุต ดังที่คุณทราบ มุมมองไม่สามารถมีพารามิเตอร์ได้ ดังนั้นเฉพาะฟังก์ชันอินไลน์เท่านั้นที่สามารถแก้ไขปัญหาประเภทนี้ได้

ลักษณะเฉพาะของฟังก์ชันอินไลน์คือสามารถมีคำขอได้เพียงคำขอเดียวในร่างกาย ดังนั้นฟังก์ชันประเภทนี้จึงคล้ายกับมุมมองมาก แต่สามารถมีพารามิเตอร์อินพุตเพิ่มเติมได้ ไวยากรณ์ของฟังก์ชันอินไลน์:

สร้างฟังก์ชัน [เจ้าของ]function_name
([(@parameter_name scalar_data_type [= default_value]) [, n]])
ตารางการส่งคืน

กลับ [(<запрос>)]

คำจำกัดความของฟังก์ชันระบุว่าจะส่งคืนตาราง<запрос>นี่คือคำขอ ผลลัพธ์จะเป็นผลลัพธ์ของฟังก์ชัน

เรามาเขียนฟังก์ชันที่คล้ายกับฟังก์ชันสเกลาร์จากตัวอย่างที่แล้ว แต่ไม่เพียงแต่ส่งคืนผลสรุปเท่านั้น แต่ยังส่งคืนแถวยอดขาย รวมถึงวันที่ขาย ชื่อหนังสือ ราคา จำนวนชิ้น และจำนวนการขาย ควรเลือกเฉพาะยอดขายที่อยู่ในช่วงเวลาที่กำหนดเท่านั้น มาเข้ารหัสข้อความของฟังก์ชันเพื่อให้ผู้ใช้รายอื่นสามารถใช้งานได้ แต่ไม่สามารถอ่านและแก้ไขได้:

สร้างฟังก์ชัน Sales_Period (@datebegin DATETIME, @dateend DATETIME)
ตารางการส่งคืน
ด้วยการเข้ารหัส
เช่น
กลับ (
SELECT t.title, t.price, s.qty, ord_date, t.price * s.qty เป็น stoim
จาก Titles t เข้าร่วมการขาย s ON t.title_Id = s.Title_ID
โดยที่ ord_date ระหว่าง @datebegin และ @dateend
)

ทีนี้ลองเรียกฟังก์ชันนี้กัน ดังที่กล่าวไปแล้ว สามารถเรียกได้เฉพาะในส่วนคำสั่ง FROM ของคำสั่ง SELECT เท่านั้น:

SELECT * จากระยะเวลาการขาย("09/01/94", "09/13/94")

2.3. ฟังก์ชันหลายคำสั่งที่ส่งคืนผลลัพธ์ของตาราง

ฟังก์ชันประเภทแรกที่พิจารณาอนุญาตให้ใช้คำสั่ง Transact-SQL ได้มากเท่าที่ต้องการ แต่ส่งคืนเฉพาะผลลัพธ์แบบสเกลาร์เท่านั้น ฟังก์ชันประเภทที่สองสามารถส่งคืนตารางได้ แต่เนื้อความของฟังก์ชันแสดงเพียงคิวรีเดียวเท่านั้น ฟังก์ชันหลายคำสั่งที่ส่งคืนผลลัพธ์ของตารางช่วยให้คุณสามารถรวมคุณสมบัติของสองฟังก์ชันแรกได้ กล่าวคือ ฟังก์ชันเหล่านี้สามารถมีคำสั่ง Transact-SQL จำนวนมากในร่างกายและส่งคืนตารางเป็นผลลัพธ์ได้ ไวยากรณ์ของฟังก์ชันหลายคำสั่ง:

สร้างฟังก์ชัน [เจ้าของ]function_name
([(@parameter_name scalar_data_type [= default_value]) [,... n]])
ส่งคืน @result ตัวแปร_ชื่อตาราง
<описание_таблицы>

เริ่ม
<тело_функции>
กลับ
จบ

• โต๊ะ<описание_таблицы> อธิบายโครงสร้างของตารางที่ส่งคืน
• <описание_таблицы> ประกอบด้วยรายการคอลัมน์และข้อจำกัด

ตอนนี้เรามาดูตัวอย่างที่สามารถทำได้โดยใช้ฟังก์ชันประเภทนี้เท่านั้น

ให้มีแผนผังไดเร็กทอรีและไฟล์ต่างๆ อยู่ในนั้น ให้อธิบายโครงสร้างทั้งหมดนี้ในฐานข้อมูลในรูปแบบของตาราง (รูปที่ 13) โดยพื้นฐานแล้ว ที่นี่เรามีโครงสร้างแบบลำดับชั้นสำหรับไดเร็กทอรี ดังนั้นไดอะแกรมจึงแสดงความสัมพันธ์ของตารางโฟลเดอร์กับตัวมันเอง

ข้าว. 13. โครงสร้างฐานข้อมูลเพื่ออธิบายลำดับชั้นของไฟล์และไดเร็กทอรี

ตอนนี้เรามาเขียนฟังก์ชันที่จะใช้ตัวระบุไดเร็กทอรีเป็นอินพุตและเอาต์พุตไฟล์ทั้งหมดที่เก็บอยู่ในนั้นและในไดเร็กทอรีทั้งหมดตามลำดับชั้น ตัวอย่างเช่น หากไดเร็กทอรี Faculty1, Faculty2 ฯลฯ ถูกสร้างขึ้นในไดเร็กทอรี Institute ไดเร็กทอรีเหล่านั้นจะมีไดเร็กทอรีของแผนก และแต่ละไดเร็กทอรีจะมีไฟล์ เมื่อเราระบุตัวระบุไดเร็กทอรี Institute เป็นพารามิเตอร์สำหรับฟังก์ชันของเรา รายการของไฟล์ทั้งหมด สำหรับไดเร็กทอรีทั้งหมดเหล่านี้ สำหรับแต่ละไฟล์ ควรแสดงชื่อ ขนาด และวันที่สร้าง

ปัญหาไม่สามารถแก้ไขได้โดยใช้ฟังก์ชันอินไลน์ เนื่องจาก SQL ไม่ได้ออกแบบมาเพื่อทำการสืบค้นแบบลำดับชั้น ดังนั้นการสืบค้น SQL เพียงรายการเดียวจึงไม่เพียงพอ ไม่สามารถใช้ฟังก์ชันสเกลาร์ได้ เนื่องจากผลลัพธ์ต้องเป็นตาราง นี่คือจุดที่ฟังก์ชันหลายคำสั่งที่ส่งคืนตารางจะมาช่วยเรา:

สร้างฟังก์ชั่น dbo.GetFiles(@Folder_ID int)
ส่งคืน @files ตาราง (ชื่อ VARCHAR (100), Date_Create DATETIME, FileSize INT) AS
เริ่ม
ประกาศ @tmp TABLE (Folder_Id int)
ประกาศ @Cnt INT
แทรกลงในค่า @tmp(@Folder_ID)
SET @Cnt = 1
ในขณะที่ @Cnt<>0 เริ่มต้น
แทรกลงใน @tmp เลือก Folder_Id
จากโฟลเดอร์ f เข้าร่วม @tmp t ON f.parent=t.Folder_ID
โดยที่ F.id ไม่อยู่ใน (เลือก Folder_ID จาก @tmp)
SET @Cnt = @@ROWCOUNT
จบ
แทรกลงใน @Files (ชื่อ, Date_Create, ขนาดไฟล์)
เลือก F.Name, F.Date_Create, F.FileSize
จากไฟล์ f เข้าร่วมโฟลเดอร์ Fl บน f.Folder_id = Fl.id
เข้าร่วม @tmp t บน Fl.id = t.Folder_Id
กลับ
จบ

ที่นี่ ลูปจะเพิ่มไดเร็กทอรีย่อยทั้งหมดในทุกระดับการซ้อนให้กับตัวแปร @tmp จนกระทั่งไม่มีไดเร็กทอรีย่อยเหลืออยู่ จากนั้นตัวแปรผลลัพธ์ @Files จะบันทึกคุณลักษณะที่จำเป็นทั้งหมดของไฟล์ที่อยู่ในไดเร็กทอรีที่แสดงอยู่ในตัวแปร @tmp

งานสำหรับงานอิสระ

คุณต้องสร้างและตรวจแก้จุดบกพร่องห้าขั้นตอนการจัดเก็บจากรายการที่จำเป็นต่อไปนี้:

ขั้นตอนที่ 1. เพิ่มกำหนดเวลาในการส่งสำเนาหนังสือภายในหนึ่งสัปดาห์หากวันที่ครบกำหนดปัจจุบันอยู่ภายในช่วงจากสามวันก่อนวันที่ปัจจุบันเป็นสามวันหลังจากวันที่ปัจจุบัน

ขั้นตอนที่ 2. การนับจำนวนสำเนาแจกฟรีของหนังสือที่กำหนด

ขั้นตอนที่ 3 ตรวจสอบการมีอยู่ของผู้อ่านโดยระบุนามสกุลและวันเดือนปีเกิด

ขั้นตอนที่ 4 เข้าสู่ผู้อ่านรายใหม่ ตรวจสอบการมีอยู่ของฐานข้อมูล และกำหนดหมายเลขบัตรห้องสมุดใหม่

ขั้นตอนที่ 5 การคำนวณค่าปรับเป็นเงื่อนไขทางการเงินสำหรับผู้อ่านลูกหนี้

คำอธิบายโดยย่อของขั้นตอน

ขั้นตอนที่ 1. เพิ่มกำหนดเวลาในการส่งมอบหนังสือ

สำหรับแต่ละเรกคอร์ดในตารางตัวอย่าง จะมีการตรวจสอบว่าวันครบกำหนดของหนังสืออยู่ภายในช่วงเวลาที่ระบุหรือไม่ หากเป็นเช่นนั้น วันที่ส่งคืนหนังสือจะขยายออกไปอีกหนึ่งสัปดาห์ เมื่อดำเนินการตามขั้นตอนคุณต้องใช้ฟังก์ชันเพื่อทำงานกับวันที่:

วันที่เพิ่ม(วัน,<число добавляемых дней>, <начальная дата>)

ขั้นตอนที่ 2. การนับจำนวนสำเนาแจกฟรีของหนังสือที่กำหนด

พารามิเตอร์อินพุตของขั้นตอนคือ ISBN ซึ่งเป็นรหัสเฉพาะของหนังสือ ขั้นตอนจะส่งกลับ 0 (ศูนย์) หากสำเนาทั้งหมดของหนังสือเล่มนี้อยู่ในมือของผู้อ่าน ขั้นตอนนี้จะคืนค่า N ซึ่งเท่ากับจำนวนสำเนาของหนังสือที่อยู่ในมือของผู้อ่านในปัจจุบัน

หากหนังสือที่มี ISBN ที่ระบุไม่อยู่ในห้องสมุด ขั้นตอนจะส่งคืน 100 (ลบหนึ่งร้อย)

ขั้นตอนที่ 3 ตรวจสอบการมีอยู่ของผู้อ่านโดยระบุนามสกุลและวันเดือนปีเกิด

ขั้นตอนนี้จะส่งคืนหมายเลขบัตรห้องสมุดหากมีเครื่องอ่านที่มีข้อมูลดังกล่าวอยู่ และมิฉะนั้นจะเป็น 0 (ศูนย์)

เมื่อเปรียบเทียบวันเกิด คุณต้องใช้ฟังก์ชันการแปลง Convert() เพื่อแปลงวันเกิด ซึ่งเป็นตัวแปรอักขระ Varchar(8) ที่ใช้เป็นพารามิเตอร์อินพุตของโพรซีเดอร์เป็นเวลาข้อมูล ซึ่งใช้ในตาราง Readers มิฉะนั้นการดำเนินการเปรียบเทียบเมื่อค้นหาเครื่องอ่านที่ระบุจะไม่ทำงาน

ขั้นตอนที่ 4: เข้าสู่ Reader ใหม่

ขั้นตอนนี้มีพารามิเตอร์อินพุต 5 รายการและพารามิเตอร์เอาต์พุต 3 รายการ

พารามิเตอร์อินพุต:

• ชื่อเต็มพร้อมอักษรย่อ
• ที่อยู่;
• วันเดือนปีเกิด;
• โทรศัพท์บ้าน;
• โทรศัพท์กำลังทำงาน

พารามิเตอร์ขาออก:

• หมายเลขบัตรห้องสมุด
• ข้อบ่งชี้ว่าผู้อ่านเคยลงทะเบียนในห้องสมุดมาก่อนหรือไม่ (ไม่ใช่ 0, 1 เป็น)
• จำนวนหนังสือที่ผู้อ่านเป็นเจ้าของ

ขั้นตอนที่ 5 การคำนวณค่าปรับในรูปเงินสำหรับผู้อ่านลูกหนี้

ขั้นตอนนี้จะทำงานร่วมกับเคอร์เซอร์ที่มีรายการหมายเลขบัตรห้องสมุดของลูกหนี้ทั้งหมด ในระหว่างขั้นตอนการทำงาน ควรสร้างตารางชั่วคราวทั่วโลก ##DOLG ซึ่งสำหรับลูกหนี้แต่ละราย หนี้ทั้งหมดของเขาในรูปตัวเงินสำหรับหนังสือทุกเล่มที่เขาถือครองนานกว่าระยะเวลาคืนสินค้าจะถูกป้อนเข้าไป การชดเชยเงินสดจะคำนวณอยู่ที่ 0.5% ของราคาต่อเล่มต่อวันที่ล่าช้า

สั่งงาน

• สำเนาหน้าจอ (ภาพหน้าจอ) ยืนยันการเปลี่ยนแปลงฐานข้อมูล
• เนื้อหาของตารางฐานข้อมูลที่จำเป็นในการตรวจสอบการทำงานที่ถูกต้อง
• ข้อความของขั้นตอนการจัดเก็บพร้อมความคิดเห็น
• กระบวนการรันโพรซีเดอร์ที่เก็บไว้และส่งออกผลลัพธ์ของงาน

งานเพิ่มเติม

ขั้นตอนการจัดเก็บเพิ่มเติมต่อไปนี้มีไว้สำหรับงานแต่ละงาน

ขั้นตอนที่ 6 การนับจำนวนหนังสือตามสาขาวิชาที่กำหนดที่มีอยู่ในห้องสมุดในปัจจุบันอย่างน้อยหนึ่งเล่ม หัวเรื่องถูกส่งผ่านเป็นพารามิเตอร์อินพุต

ขั้นตอนที่ 7. ลงหนังสือเล่มใหม่ระบุจำนวนเล่ม เมื่อป้อนสำเนาหนังสือเล่มใหม่ ต้องแน่ใจว่าได้ป้อนหมายเลขภาคยานุวัติที่ถูกต้อง ลองคิดดูว่าคุณจะทำเช่นนี้ได้อย่างไร โปรดทราบว่าคุณมีฟังก์ชัน Max และ Min ซึ่งช่วยให้คุณค้นหาค่าสูงสุดหรือต่ำสุดของแอตทริบิวต์ตัวเลขใดๆ ได้โดยใช้คิวรี Select

ขั้นตอนที่ 8. จัดทำตารางรายชื่อผู้อ่านลูกหนี้ ได้แก่ ผู้ที่ควรจะคืนหนังสือเข้าห้องสมุดแต่ยังไม่ได้คืน ในตารางผลลัพธ์ ผู้อ่านลูกหนี้แต่ละคนควรปรากฏเพียงครั้งเดียว ไม่ว่าเขาจะเป็นหนี้หนังสือกี่เล่มก็ตาม นอกจากชื่อนามสกุลและหมายเลขบัตรห้องสมุดแล้ว คุณต้องระบุที่อยู่และหมายเลขโทรศัพท์ของคุณในตารางผลลัพธ์

ขั้นตอนที่ 9 ค้นหาหนังสือฟรีโดยใช้ชื่อหนังสือที่กำหนด หากมีสำเนาฟรี ขั้นตอนจะส่งคืนหมายเลขสินค้าคงคลังของสำเนา ถ้าไม่เช่นนั้น กระบวนการจะส่งคืนรายชื่อผู้อ่านที่มีหนังสือเล่มนี้ โดยระบุวันที่คืนหนังสือและหมายเลขโทรศัพท์ของผู้อ่าน

ขั้นตอนที่ 10 แสดงรายชื่อผู้อ่านที่ไม่มีหนังสืออยู่ในมือ กรุณาระบุชื่อและหมายเลขโทรศัพท์ของคุณในรายการ

ขั้นตอนที่ 11 การแสดงรายการหนังสือที่ระบุจำนวนเล่มของหนังสือที่กำหนดในห้องสมุดและจำนวนเล่มที่แจกฟรีในขณะนั้น

ฉบับพิมพ์

โพรซีเดอร์ที่เก็บไว้ของ SQL คือโมดูลโปรแกรมที่ปฏิบัติการได้ซึ่งสามารถจัดเก็บในรูปแบบของอ็อบเจ็กต์ต่างๆ กล่าวอีกนัยหนึ่ง มันเป็นวัตถุที่มีคำสั่ง SQL ขั้นตอนการจัดเก็บเหล่านี้สามารถดำเนินการได้ในแอปพลิเคชันไคลเอนต์เพื่อให้ได้ประสิทธิภาพที่ดี นอกจากนี้ ออบเจ็กต์ดังกล่าวมักถูกเรียกจากสคริปต์อื่น หรือแม้แต่จากส่วนอื่นด้วยซ้ำ

การแนะนำ

หลายๆ คนเชื่อว่ากระบวนการเหล่านี้คล้ายคลึงกับขั้นตอนต่างๆ (ตามลำดับ ยกเว้น MS SQL) บางทีนี่อาจเป็นเรื่องจริง พวกเขามีพารามิเตอร์ที่คล้ายกันและสามารถสร้างค่าที่คล้ายกันได้ ยิ่งไปกว่านั้นในบางกรณีก็สัมผัสกัน ตัวอย่างเช่น จะรวมกับฐานข้อมูล DDL และ DML รวมถึงฟังก์ชันผู้ใช้ (ชื่อรหัส UDF)

ในความเป็นจริง ขั้นตอนการจัดเก็บ SQL มีข้อดีมากมายที่ทำให้กระบวนการเหล่านี้แตกต่างจากกระบวนการที่คล้ายคลึงกัน ความปลอดภัย ความยืดหยุ่นในการเขียนโปรแกรม ประสิทธิภาพการทำงาน - ทั้งหมดนี้ดึงดูดผู้ใช้ที่ทำงานกับฐานข้อมูลเพิ่มมากขึ้นเรื่อยๆ ความนิยมสูงสุดของขั้นตอนเกิดขึ้นในปี 2548-2553 เมื่อมีการเปิดตัวโปรแกรมจาก Microsoft ชื่อ "SQL Server Management Studio" ด้วยความช่วยเหลือนี้ ทำให้การทำงานกับฐานข้อมูลกลายเป็นเรื่องง่าย ใช้งานได้จริง และสะดวกยิ่งขึ้น ในแต่ละปีสิ่งนี้ได้รับความนิยมในหมู่โปรแกรมเมอร์ วันนี้มันเป็นโปรแกรมที่คุ้นเคยอย่างยิ่งซึ่งสำหรับผู้ใช้ที่ "สื่อสาร" กับฐานข้อมูลนั้นเทียบเท่ากับ Excel

เมื่อกระบวนการถูกเรียก เซิร์ฟเวอร์จะประมวลผลทันทีโดยไม่มีกระบวนการที่ไม่จำเป็นหรือการแทรกแซงของผู้ใช้ หลังจากนี้ คุณสามารถดำเนินการลบ ดำเนินการ หรือแก้ไขใดๆ ได้ ตัวดำเนินการ DDL มีหน้าที่รับผิดชอบทั้งหมดนี้ โดยเป็นผู้ดำเนินการที่ซับซ้อนที่สุดในการประมวลผลอ็อบเจ็กต์เพียงผู้เดียว ยิ่งไปกว่านั้น ทั้งหมดนี้เกิดขึ้นเร็วมากและเซิร์ฟเวอร์ไม่ได้โหลดจริง ๆ ความเร็วและประสิทธิภาพนี้ช่วยให้คุณสามารถถ่ายโอนข้อมูลจำนวนมากจากผู้ใช้ไปยังเซิร์ฟเวอร์ได้อย่างรวดเร็วและในทางกลับกัน

ในการใช้เทคโนโลยีนี้ในการทำงานกับข้อมูล มีภาษาการเขียนโปรแกรมหลายภาษา ซึ่งรวมถึง ตัวอย่างเช่น PL/SQL จาก Oracle, PSQL ในระบบ InterBase และ Firebird รวมถึง Microsoft Transact-SQL แบบคลาสสิก ทั้งหมดนี้ได้รับการออกแบบสำหรับการสร้างและดำเนินการขั้นตอนการจัดเก็บซึ่งช่วยให้โปรเซสเซอร์ฐานข้อมูลขนาดใหญ่สามารถใช้อัลกอริธึมของตนเองได้ นี่เป็นสิ่งจำเป็นเช่นกันเพื่อให้ผู้ที่จัดการข้อมูลดังกล่าวสามารถปกป้องวัตถุทั้งหมดจากการเข้าถึงโดยไม่ได้รับอนุญาตโดยบุคคลที่สาม และด้วยเหตุนี้ การสร้าง การแก้ไข หรือการลบข้อมูลบางอย่าง

ผลผลิต

ออบเจ็กต์ฐานข้อมูลเหล่านี้สามารถตั้งโปรแกรมได้หลายวิธี ทำให้ผู้ใช้สามารถเลือกประเภทของวิธีการใช้ที่เหมาะสมที่สุด ประหยัดแรงและเวลา นอกจากนี้ กระบวนการยังได้รับการประมวลผลด้วยตัวมันเอง ซึ่งช่วยหลีกเลี่ยงค่าใช้จ่ายจำนวนมากในการสื่อสารระหว่างเซิร์ฟเวอร์และผู้ใช้ นอกจากนี้ โมดูลยังสามารถตั้งโปรแกรมใหม่และเปลี่ยนแปลงไปในทิศทางที่ต้องการได้ตลอดเวลา เป็นเรื่องที่น่าสังเกตว่าความเร็วที่เปิดตัวโพรซีเดอร์ SQL ที่เก็บไว้: กระบวนการนี้เกิดขึ้นเร็วกว่ากระบวนการอื่นที่คล้ายคลึงกันซึ่งทำให้สะดวกและเป็นสากล

ความปลอดภัย

การประมวลผลข้อมูลประเภทนี้แตกต่างจากกระบวนการที่คล้ายกันตรงที่รับประกันความปลอดภัยที่เพิ่มขึ้น สิ่งนี้รับประกันได้ว่าการเข้าถึงขั้นตอนโดยผู้ใช้รายอื่นสามารถยกเว้นได้อย่างสมบูรณ์ ซึ่งจะช่วยให้ผู้ดูแลระบบสามารถดำเนินการกับพวกเขาได้อย่างอิสระโดยไม่ต้องกลัวว่าจะถูกดักข้อมูลหรือเข้าถึงฐานข้อมูลโดยไม่ได้รับอนุญาต

การถ่ายโอนข้อมูล

ความสัมพันธ์ระหว่างขั้นตอนการจัดเก็บ SQL และแอปพลิเคชันไคลเอ็นต์คือการใช้พารามิเตอร์และค่าที่ส่งคืน หลังไม่จำเป็นต้องส่งข้อมูลไปยังขั้นตอนการจัดเก็บ แต่ข้อมูลนี้ (ส่วนใหญ่ตามคำขอของผู้ใช้) ได้รับการประมวลผลสำหรับ SQL หลังจากที่กระบวนงานที่เก็บไว้เสร็จสิ้นการทำงาน มันจะส่งแพ็กเก็ตข้อมูลกลับ (แต่เป็นทางเลือกอีกครั้ง) ไปยังแอปพลิเคชันที่เรียกมัน โดยใช้วิธีต่างๆ ที่สามารถใช้เพื่อเรียกขั้นตอนที่เก็บไว้ของ SQL หรือส่งคืน เช่น:

การถ่ายโอนข้อมูลโดยใช้พารามิเตอร์ประเภทเอาต์พุต

การส่งผ่านข้อมูลโดยใช้ตัวดำเนินการส่งคืน

การส่งผ่านข้อมูลโดยใช้โอเปอเรเตอร์ที่เลือก

ตอนนี้เรามาดูกันว่ากระบวนการนี้มีลักษณะอย่างไรจากภายใน

1. สร้างขั้นตอนการจัดเก็บ EXEC ใน SQL

คุณสามารถสร้างขั้นตอนใน MS SQL (Managment Studio) หลังจากสร้างขั้นตอนแล้ว ขั้นตอนดังกล่าวจะแสดงอยู่ในโหนดที่ตั้งโปรแกรมได้ของฐานข้อมูล ซึ่งขั้นตอนการสร้างจะดำเนินการโดยผู้ปฏิบัติงาน ในการดำเนินการ ขั้นตอนการจัดเก็บ SQL จะใช้กระบวนการ EXEC ที่มีชื่อของออบเจ็กต์นั้นเอง

เมื่อคุณสร้างขั้นตอน ชื่อขั้นตอนนั้นจะปรากฏขึ้นก่อน ตามด้วยพารามิเตอร์อย่างน้อยหนึ่งรายการที่กำหนดให้กับขั้นตอนนั้น พารามิเตอร์อาจเป็นทางเลือก หลังจากเขียนพารามิเตอร์ซึ่งก็คือเนื้อความของขั้นตอนแล้ว จำเป็นต้องดำเนินการบางอย่างที่จำเป็น

ประเด็นก็คือเนื้อความสามารถมีตัวแปรภายในเครื่องได้ และตัวแปรเหล่านี้ก็อยู่ในตัวที่เกี่ยวข้องกับกระบวนการด้วย กล่าวอีกนัยหนึ่งสามารถดูได้ภายในเนื้อความของขั้นตอน Microsoft SQL Server เท่านั้น ขั้นตอนการจัดเก็บในกรณีนี้จะถือว่าอยู่ในเครื่อง

ดังนั้น ในการสร้างโพรซีเดอร์ เราจำเป็นต้องมีชื่อของโพรซีเดอร์และพารามิเตอร์อย่างน้อยหนึ่งตัวเป็นเนื้อหาของโพรซีเดอร์ โปรดทราบว่าตัวเลือกที่ดีในกรณีนี้คือการสร้างและดำเนินการตามขั้นตอนด้วยชื่อสคีมาในตัวแยกประเภท

เนื้อความของโพรซีเดอร์สามารถเป็นได้ทุกชนิด เช่น การสร้างตาราง การแทรกแถวของตารางตั้งแต่หนึ่งแถวขึ้นไป การสร้างประเภทและลักษณะของฐานข้อมูล และอื่นๆ อย่างไรก็ตาม เนื้อหาของขั้นตอนจะจำกัดการดำเนินการบางอย่างภายในนั้น ข้อจำกัดที่สำคัญบางประการมีการระบุไว้ด้านล่าง:

ร่างกายไม่ควรสร้างขั้นตอนการจัดเก็บอื่นใด

ร่างกายไม่ควรสร้างความประทับใจที่ผิดพลาดต่อวัตถุ

ร่างกายไม่ควรสร้างสิ่งกระตุ้นใดๆ

2. การตั้งค่าตัวแปรในเนื้อหาของโพรซีเดอร์

คุณสามารถสร้างตัวแปรเฉพาะที่ภายในเนื้อความของกระบวนงานได้ จากนั้นตัวแปรจะอยู่เฉพาะภายในเนื้อความของกระบวนงานเท่านั้น แนวปฏิบัติที่ดีคือการสร้างตัวแปรที่จุดเริ่มต้นของเนื้อหาของกระบวนงานที่เก็บไว้ แต่คุณยังสามารถตั้งค่าตัวแปรได้ทุกที่ในเนื้อความของวัตถุที่กำหนดได้

บางครั้งคุณอาจสังเกตเห็นว่ามีการตั้งค่าตัวแปรหลายตัวไว้ในบรรทัดเดียว และพารามิเตอร์ตัวแปรแต่ละตัวจะถูกคั่นด้วยเครื่องหมายจุลภาค โปรดทราบว่าตัวแปรนำหน้าด้วย @ ในเนื้อความของโพรซีเดอร์ คุณสามารถตั้งค่าตัวแปรไปที่ใดก็ได้ที่คุณต้องการ ตัวอย่างเช่น ตัวแปร @NAME1 อาจถูกประกาศใกล้กับจุดสิ้นสุดของเนื้อหาของโพรซีเดอร์ ในการกำหนดค่าให้กับตัวแปรที่ประกาศ จะใช้ชุดข้อมูลส่วนบุคคล ต่างจากสถานการณ์ที่มีการประกาศตัวแปรมากกว่าหนึ่งตัวในบรรทัดเดียวกัน ในสถานการณ์นี้จะใช้ข้อมูลส่วนบุคคลเพียงชุดเดียวเท่านั้น

ผู้ใช้มักถามคำถาม: “จะกำหนดค่าหลายค่าในคำสั่งเดียวในเนื้อหาของโพรซีเดอร์ได้อย่างไร” ดี. เป็นคำถามที่น่าสนใจ แต่ทำได้ง่ายกว่าที่คุณคิดมาก คำตอบ: การใช้คู่เช่น "Select Var = value" คุณสามารถใช้คู่เหล่านี้ได้โดยคั่นด้วยเครื่องหมายจุลภาค

ตัวอย่างที่หลากหลายแสดงให้ผู้คนสร้างขั้นตอนการจัดเก็บแบบง่ายและดำเนินการ อย่างไรก็ตามขั้นตอนสามารถรับพารามิเตอร์ที่กระบวนการที่เรียกจะมีค่าใกล้เคียงกัน (แต่ไม่เสมอไป) หากเกิดขึ้นพร้อมกัน กระบวนการที่เกี่ยวข้องจะเริ่มขึ้นภายในร่างกาย ตัวอย่างเช่น หากคุณสร้างขั้นตอนที่จะยอมรับเมืองและภูมิภาคจากผู้โทร และส่งกลับข้อมูลเกี่ยวกับจำนวนผู้เขียนที่อยู่ในเมืองและภูมิภาคที่เกี่ยวข้อง ขั้นตอนจะสอบถามตารางผู้เขียนของฐานข้อมูล เช่น Pubs เพื่อดำเนินการนับจำนวนผู้เขียนนี้ ตัวอย่างเช่น หากต้องการรับฐานข้อมูลเหล่านี้ Google จะดาวน์โหลดสคริปต์ SQL จากหน้า SQL2005

ในตัวอย่างก่อนหน้านี้ กระบวนการใช้พารามิเตอร์สองตัว ซึ่งในภาษาอังกฤษจะเรียกว่า @State และ @City ตามอัตภาพ ประเภทข้อมูลตรงกับประเภทที่กำหนดไว้ในแอปพลิเคชัน เนื้อความของโพรซีเดอร์มีตัวแปรภายใน @TotalAuthors และตัวแปรนี้ใช้เพื่อแสดงจำนวนผู้เขียน ถัดไปคือส่วนการเลือกข้อความค้นหาซึ่งจะคำนวณทุกอย่าง สุดท้าย ค่าที่คำนวณได้จะถูกพิมพ์ในหน้าต่างเอาท์พุตโดยใช้คำสั่งการพิมพ์

วิธีดำเนินการขั้นตอนการจัดเก็บใน SQL

มีสองวิธีในการดำเนินการตามขั้นตอน วิธีแรกจะแสดงวิธีการดำเนินการรายการที่คั่นด้วยเครื่องหมายจุลภาคหลังชื่อขั้นตอน โดยการส่งพารามิเตอร์ สมมติว่าเรามีสองค่า (ดังตัวอย่างก่อนหน้านี้) ค่าเหล่านี้ถูกรวบรวมโดยใช้ตัวแปรพารามิเตอร์ขั้นตอน @State และ @City ในวิธีการส่งพารามิเตอร์นี้ ลำดับเป็นสิ่งสำคัญ วิธีการนี้เรียกว่าการส่งผ่านอาร์กิวเมนต์ลำดับ ในวิธีที่สอง พารามิเตอร์ได้รับการกำหนดโดยตรงแล้ว และในกรณีนี้ลำดับไม่สำคัญ วิธีที่สองนี้เรียกว่าการส่งผ่านอาร์กิวเมนต์ที่มีชื่อ

ขั้นตอนอาจเบี่ยงเบนไปจากปกติเล็กน้อย ทุกอย่างเหมือนกับในตัวอย่างก่อนหน้า แต่เฉพาะพารามิเตอร์เท่านั้นที่จะถูกเลื่อน นั่นคือ @City จะถูกเก็บไว้ก่อน และ @State จะถูกเก็บไว้ถัดจากค่าเริ่มต้น โดยปกติพารามิเตอร์เริ่มต้นจะถูกเน้นแยกกัน ขั้นตอนการจัดเก็บ SQL จะถูกส่งผ่านเป็นเพียงพารามิเตอร์ ในกรณีนี้ พารามิเตอร์ "UT" จะแทนที่ค่าเริ่มต้น "CA" ในการดำเนินการครั้งที่สอง จะมีการส่งผ่านค่าอาร์กิวเมนต์เพียงค่าเดียวสำหรับพารามิเตอร์ @City และพารามิเตอร์ @State จะใช้ค่าเริ่มต้นเป็น "CA" โปรแกรมเมอร์ที่มีประสบการณ์แนะนำว่าตัวแปรทั้งหมดควรอยู่ที่ส่วนท้ายของรายการพารามิเตอร์ตามค่าเริ่มต้น มิฉะนั้น การดำเนินการจะไม่สามารถทำได้ จากนั้นคุณจะต้องดำเนินการโดยส่งผ่านอาร์กิวเมนต์ที่มีชื่อ ซึ่งมีความยาวและซับซ้อนมากขึ้น

4. ขั้นตอนการจัดเก็บเซิร์ฟเวอร์ SQL: วิธีการส่งคืน

มีสามวิธีที่สำคัญในการส่งข้อมูลในขั้นตอนการจัดเก็บที่เรียกว่า พวกเขาอยู่ด้านล่าง:

ส่งกลับค่าของกระบวนงานที่เก็บไว้

เอาต์พุตพารามิเตอร์ขั้นตอนการจัดเก็บ;

การเลือกหนึ่งในขั้นตอนการจัดเก็บ

4.1 การส่งคืนค่าจาก SQL Stored Procedure

ในเทคนิคนี้ ขั้นตอนจะกำหนดค่าให้กับตัวแปรภายในเครื่องและส่งกลับค่านั้น ขั้นตอนยังสามารถส่งกลับค่าคงที่ได้โดยตรง ในตัวอย่างต่อไปนี้ เราได้สร้างขั้นตอนที่ส่งคืนจำนวนผู้เขียนทั้งหมด หากคุณเปรียบเทียบขั้นตอนนี้กับขั้นตอนก่อนหน้า คุณจะเห็นว่าค่าการพิมพ์กลับด้าน

ตอนนี้เรามาดูวิธีการดำเนินการตามขั้นตอนและพิมพ์ค่าที่ส่งคืน การดำเนินการตามขั้นตอนจำเป็นต้องมีการตั้งค่าตัวแปรและการพิมพ์ ซึ่งจะดำเนินการหลังจากกระบวนการทั้งหมดนี้ โปรดทราบว่าแทนที่จะใช้คำสั่งพิมพ์ คุณสามารถใช้คำสั่ง Select เช่น Select @RetValue และ OutputValue ได้

4.2 เอาต์พุตพารามิเตอร์ SQL Stored Procedure

ค่าตอบสนองสามารถใช้เพื่อส่งคืนตัวแปรตัวเดียว ซึ่งเป็นสิ่งที่เราเห็นในตัวอย่างก่อนหน้านี้ การใช้พารามิเตอร์ Output ช่วยให้ขั้นตอนสามารถส่งค่าตัวแปรตั้งแต่หนึ่งค่าขึ้นไปไปยังผู้เรียกได้ พารามิเตอร์เอาต์พุตถูกกำหนดอย่างแม่นยำโดยคำสำคัญนี้ "เอาต์พุต" เมื่อสร้างขั้นตอน หากกำหนดพารามิเตอร์เป็นพารามิเตอร์เอาท์พุต อ็อบเจ็กต์โพรซีเดอร์จะต้องกำหนดค่าให้กับพารามิเตอร์นั้น ขั้นตอนการจัดเก็บ SQL ตัวอย่างสามารถดูได้ด้านล่าง ในกรณีนี้จะส่งคืนพร้อมข้อมูลสรุป

ในตัวอย่างของเรา จะมีชื่อเอาต์พุตสองชื่อ: @TotalAuthors และ @TotalNoContract มีการระบุไว้ในรายการพารามิเตอร์ ตัวแปรเหล่านี้จะกำหนดค่าภายในเนื้อหาของโพรซีเดอร์ เมื่อเราใช้พารามิเตอร์เอาต์พุต ผู้เรียกสามารถเห็นค่าที่ตั้งไว้ภายในเนื้อหาของโพรซีเดอร์

นอกจากนี้ ในสถานการณ์ก่อนหน้านี้ มีการประกาศตัวแปรสองตัวเพื่อดูค่าที่ MS SQL Server จัดเก็บโพรซีเดอร์ที่ตั้งค่าไว้ในพารามิเตอร์เอาต์พุต จากนั้นดำเนินการตามขั้นตอนโดยระบุค่าปกติของพารามิเตอร์ “CA” พารามิเตอร์ต่อไปนี้เป็นพารามิเตอร์เอาต์พุต ดังนั้นตัวแปรที่ประกาศจะถูกส่งไปตามลำดับที่ระบุ โปรดทราบว่าเมื่อส่งผ่านตัวแปร คีย์เวิร์ดเอาต์พุตจะถูกตั้งค่าไว้ที่นี่ด้วย หลังจากขั้นตอนเสร็จสมบูรณ์ ค่าที่ส่งคืนโดยพารามิเตอร์เอาต์พุตจะแสดงในกล่องข้อความ

4.3 การเลือกหนึ่งในขั้นตอนการจัดเก็บ SQL

เทคนิคนี้ใช้เพื่อส่งคืนชุดค่าเป็นตารางข้อมูล (RecordSet) ไปยังขั้นตอนการเรียกที่เก็บไว้ ในตัวอย่างนี้ ขั้นตอนการจัดเก็บ SQL ที่มีพารามิเตอร์ @AuthID จะสอบถามตาราง Authors โดยการกรองระเบียนที่ส่งคืนโดยใช้พารามิเตอร์ @AuthId นั้น คำสั่ง Select ตัดสินใจว่าควรส่งคืนอะไรให้กับผู้เรียกกระบวนงานที่เก็บไว้ เมื่อดำเนินการขั้นตอนที่เก็บไว้ AuthId จะถูกส่งกลับ ขั้นตอนนี้จะส่งกลับเพียงระเบียนเดียวหรือไม่มีเลยเสมอ แต่ขั้นตอนการจัดเก็บไม่มีข้อจำกัดใดๆ ในการส่งคืนระเบียนมากกว่าหนึ่งรายการ ไม่ใช่เรื่องแปลกที่จะเห็นตัวอย่างที่มีการส่งคืนข้อมูลโดยใช้พารามิเตอร์ที่เลือกซึ่งเกี่ยวข้องกับตัวแปรที่คำนวณโดยการให้ผลรวมหลายรายการ

สรุปแล้ว

โพรซีเดอร์ที่เก็บไว้เป็นโมดูลโปรแกรมที่ค่อนข้างจริงจังซึ่งส่งคืนหรือผ่าน และยังตั้งค่าตัวแปรที่จำเป็นด้วยแอปพลิเคชันไคลเอนต์ เนื่องจากขั้นตอนการจัดเก็บรันตัวเองบนเซิร์ฟเวอร์ จึงสามารถหลีกเลี่ยงการแลกเปลี่ยนข้อมูลจำนวนมากระหว่างเซิร์ฟเวอร์และแอปพลิเคชันไคลเอ็นต์ (สำหรับการคำนวณบางอย่าง) ได้ สิ่งนี้ช่วยให้คุณลดภาระบนเซิร์ฟเวอร์ SQL ซึ่งแน่นอนว่าจะเป็นประโยชน์ต่อเจ้าของเซิร์ฟเวอร์ หนึ่งในประเภทย่อยคือขั้นตอนการจัดเก็บ T SQL แต่การศึกษามีความจำเป็นสำหรับผู้ที่สร้างฐานข้อมูลที่น่าประทับใจ นอกจากนี้ยังมีความแตกต่างจำนวนมากที่อาจมีประโยชน์เมื่อศึกษาขั้นตอนการจัดเก็บ แต่นี่เป็นสิ่งจำเป็นสำหรับผู้ที่วางแผนจะมีส่วนร่วมในการเขียนโปรแกรมรวมถึงมืออาชีพด้วย

ขั้นตอนการจัดเก็บเป็นแพ็คเกจคำสั่ง Transact-SQL ชนิดพิเศษที่สร้างขึ้นโดยใช้ภาษา SQL และส่วนขยายขั้นตอน ข้อแตกต่างที่สำคัญระหว่างแพ็คเกจและขั้นตอนการจัดเก็บก็คือขั้นตอนหลังถูกจัดเก็บเป็นวัตถุฐานข้อมูล กล่าวอีกนัยหนึ่ง กระบวนการจัดเก็บจะถูกจัดเก็บไว้ในฝั่งเซิร์ฟเวอร์เพื่อปรับปรุงประสิทธิภาพและความสม่ำเสมอของงานที่ทำซ้ำได้

โปรแกรมฐานข้อมูลรองรับขั้นตอนการจัดเก็บและขั้นตอนของระบบ Stored Procedures ถูกสร้างขึ้นในลักษณะเดียวกับออบเจ็กต์ฐานข้อมูลอื่นๆ ทั้งหมด เช่น โดยใช้ภาษา DDL ขั้นตอนของระบบจัดทำโดย Database Engine และสามารถใช้เพื่อเข้าถึงและแก้ไขข้อมูลในแค็ตตาล็อกระบบ

เมื่อคุณสร้างขั้นตอนการจัดเก็บ คุณสามารถกำหนดรายการพารามิเตอร์เพิ่มเติมได้ ด้วยวิธีนี้ ขั้นตอนจะยอมรับข้อโต้แย้งที่เหมาะสมทุกครั้งที่มีการเรียก กระบวนงานที่เก็บไว้สามารถส่งคืนค่าที่มีข้อมูลที่ผู้ใช้กำหนด หรือในกรณีที่เกิดข้อผิดพลาด อาจแสดงข้อความแสดงข้อผิดพลาดที่เหมาะสม

ขั้นตอนการจัดเก็บจะถูกคอมไพล์ล่วงหน้าก่อนที่จะจัดเก็บเป็นอ็อบเจ็กต์ในฐานข้อมูล รูปแบบพรีคอมไพล์ของโพรซีเดอร์จะถูกเก็บไว้ในฐานข้อมูลและใช้ทุกครั้งที่มีการเรียก คุณสมบัติของกระบวนงานที่เก็บไว้นี้ให้ประโยชน์ที่สำคัญในการกำจัด (ในเกือบทุกกรณี) การคอมไพล์ขั้นตอนที่ทำซ้ำ และบรรลุการปรับปรุงประสิทธิภาพที่สอดคล้องกัน คุณสมบัติของขั้นตอนการจัดเก็บนี้ยังมีผลดีต่อปริมาณข้อมูลที่แลกเปลี่ยนระหว่างระบบฐานข้อมูลและแอปพลิเคชันอีกด้วย โดยเฉพาะอย่างยิ่ง การเรียกขั้นตอนการจัดเก็บที่มีขนาดหลายพันไบต์อาจต้องใช้น้อยกว่า 50 ไบต์ เมื่อผู้ใช้หลายคนทำงานซ้ำๆ โดยใช้ขั้นตอนการจัดเก็บ ผลสะสมของการประหยัดเหล่านี้อาจมีนัยสำคัญมาก

ขั้นตอนการจัดเก็บสามารถใช้เพื่อวัตถุประสงค์ดังต่อไปนี้:

เพื่อสร้างบันทึกการดำเนินการกับตารางฐานข้อมูล

การใช้ขั้นตอนการจัดเก็บจะให้ระดับการควบคุมความปลอดภัยที่เหนือกว่าการรักษาความปลอดภัยที่ได้รับจากการใช้คำสั่ง GRANT และ REVOKE ซึ่งให้สิทธิ์การเข้าถึงที่แตกต่างกันแก่ผู้ใช้ สิ่งนี้เป็นไปได้เนื่องจากการอนุญาตในการดำเนินการขั้นตอนการจัดเก็บนั้นไม่ขึ้นอยู่กับการอนุญาตในการแก้ไขออบเจ็กต์ที่มีอยู่ในขั้นตอนการจัดเก็บ ดังที่อธิบายไว้ในส่วนถัดไป

ขั้นตอนการจัดเก็บที่สร้างบันทึกของการดำเนินการเขียนและ/หรืออ่านตารางให้ตัวเลือกเพิ่มเติมสำหรับการรักษาความปลอดภัยฐานข้อมูล เมื่อใช้ขั้นตอนดังกล่าว ผู้ดูแลระบบฐานข้อมูลสามารถตรวจสอบการแก้ไขฐานข้อมูลโดยผู้ใช้หรือโปรแกรมแอปพลิเคชัน

การสร้างและดำเนินการขั้นตอนการจัดเก็บ

ขั้นตอนที่เก็บไว้ถูกสร้างขึ้นโดยใช้คำสั่ง สร้างขั้นตอนซึ่งมีรูปแบบดังนี้:

สร้าง PROC proc_name [((@param1) type1 [ แปรผัน] [= default1] )] (, ...) AS แบทช์ | ชื่อภายนอก method_name แบบแผนไวยากรณ์

พารามิเตอร์ schema_name ระบุชื่อของสคีมาที่กำหนดโดยเจ้าของกระบวนงานที่เก็บไว้ที่สร้างขึ้น พารามิเตอร์ proc_name ระบุชื่อของกระบวนงานที่เก็บไว้ พารามิเตอร์ @param1 เป็นพารามิเตอร์ของขั้นตอน (อาร์กิวเมนต์ที่เป็นทางการ) ซึ่งประเภทข้อมูลถูกกำหนดโดยพารามิเตอร์ type1 พารามิเตอร์ของโพรซีเดอร์เป็นแบบโลคัลภายในโพรซีเดอร์ เช่นเดียวกับตัวแปรโลคัลที่อยู่ในแพ็กเกจ พารามิเตอร์ขั้นตอนคือค่าที่ผู้เรียกส่งผ่านไปยังขั้นตอนการใช้งาน พารามิเตอร์ default1 ระบุค่าเริ่มต้นสำหรับพารามิเตอร์ขั้นตอนที่เกี่ยวข้อง (ค่าเริ่มต้นสามารถเป็น NULL ได้)

ตัวเลือกเอาท์พุทบ่งชี้ว่าพารามิเตอร์ขั้นตอนคือพารามิเตอร์ส่งคืน และสามารถใช้เพื่อส่งคืนค่าจากขั้นตอนที่เก็บไว้ไปยังขั้นตอนการเรียกหรือระบบ

ดังที่ได้กล่าวไว้ก่อนหน้านี้ รูปแบบพรีคอมไพล์ของโพรซีเดอร์จะถูกเก็บไว้ในฐานข้อมูลและใช้งานทุกครั้งที่มีการเรียก หากจำเป็นต้องรวบรวมโพรซีเดอร์ที่เก็บไว้ทุกครั้งที่มีการเรียกด้วยเหตุผลบางประการ ให้ใช้เมื่อประกาศโพรซีเดอร์ พร้อมตัวเลือกการคอมไพล์- การใช้ตัวเลือก WITH RECOMPILE จะลบล้างข้อดีที่สำคัญที่สุดประการหนึ่งของกระบวนงานที่เก็บไว้ นั่นคือ การปรับปรุงประสิทธิภาพเนื่องจากการคอมไพล์ครั้งเดียว ดังนั้น ตัวเลือก WITH RECOMPILE ควรใช้เฉพาะเมื่อมีการปรับเปลี่ยนวัตถุฐานข้อมูลที่ใช้โดยกระบวนงานที่เก็บไว้บ่อยครั้งเท่านั้น

ดำเนินการตามข้อกำหนดบริบทความปลอดภัยที่กระบวนงานที่เก็บไว้ควรดำเนินการหลังจากถูกเรียก ด้วยการตั้งค่าบริบทนี้ โปรแกรมฐานข้อมูลสามารถควบคุมการเลือกบัญชีผู้ใช้เพื่อตรวจสอบสิทธิ์การเข้าถึงออบเจ็กต์ที่อ้างอิงโดยขั้นตอนการจัดเก็บ

ตามค่าเริ่มต้น เฉพาะสมาชิกของบทบาทเซิร์ฟเวอร์คงที่ของ sysadmin และบทบาทฐานข้อมูลคงที่ db_owner หรือ db_ddladmin เท่านั้นที่สามารถใช้คำสั่ง CREATE PROCEDURE ได้ แต่สมาชิกของบทบาทเหล่านี้สามารถมอบหมายสิทธิ์นี้ให้กับผู้ใช้รายอื่นได้โดยใช้คำสั่ง ขั้นตอนการสร้างทุน.

ตัวอย่างด้านล่างแสดงวิธีการสร้างขั้นตอนการจัดเก็บอย่างง่ายเพื่อทำงานกับตารางโครงการ:

ใช้ SampleDb; ไปสร้างขั้นตอน เพิ่มงบประมาณ (@percent INT=5) AS อัปเดต งบประมาณชุดโครงการ = งบประมาณ + งบประมาณ * @percent/100;

ตามที่ระบุไว้ก่อนหน้านี้ หากต้องการแยกสองแพ็กเก็ต ให้ใช้ ไปคำแนะนำ- คำสั่ง CREATE PROCEDURE ไม่สามารถรวมกับคำสั่ง Transact-SQL อื่น ๆ ในชุดเดียวกันได้ กระบวนการจัดเก็บ เพิ่มงบประมาณ จะเพิ่มงบประมาณสำหรับโครงการทั้งหมดตามเปอร์เซ็นต์ที่กำหนด ซึ่งกำหนดโดยพารามิเตอร์ @percent ขั้นตอนนี้ยังกำหนดค่าเปอร์เซ็นต์เริ่มต้น (5) ที่ใช้ถ้าไม่มีอาร์กิวเมนต์นี้เมื่อกระบวนการทำงาน

ขั้นตอนที่เก็บไว้สามารถเข้าถึงตารางที่ไม่มีอยู่ได้ คุณสมบัตินี้ช่วยให้คุณสามารถดีบักโค้ดขั้นตอนได้โดยไม่ต้องสร้างตารางที่เหมาะสมหรือแม้แต่เชื่อมต่อกับเซิร์ฟเวอร์ปลายทางก่อน

แตกต่างจากขั้นตอนการจัดเก็บหลักซึ่งจะถูกเก็บไว้ในฐานข้อมูลปัจจุบันเสมอ คุณสามารถสร้างขั้นตอนการจัดเก็บชั่วคราวที่เก็บไว้ในฐานข้อมูลระบบชั่วคราว tempdb เสมอ เหตุผลหนึ่งในการสร้างขั้นตอนการจัดเก็บชั่วคราวอาจเป็นเพื่อหลีกเลี่ยงการดำเนินการซ้ำกลุ่มคำสั่งเฉพาะเมื่อเชื่อมต่อกับฐานข้อมูล คุณสามารถสร้างขั้นตอนชั่วคราวระดับท้องถิ่นหรือระดับโลกได้ เมื่อต้องการทำเช่นนี้ ชื่อของขั้นตอนภายในเครื่องจะถูกระบุด้วยอักขระ # ตัวเดียว (#proc_name) และชื่อของขั้นตอนส่วนกลางจะถูกระบุด้วยอักขระสองตัว (##proc_name)

กระบวนการจัดเก็บชั่วคราวในเครื่องสามารถดำเนินการได้โดยผู้ใช้ที่สร้างมันขึ้นมา และเฉพาะในขณะที่เชื่อมต่อกับฐานข้อมูลที่มันถูกสร้างขึ้นเท่านั้น ผู้ใช้ทุกคนสามารถดำเนินการขั้นตอนชั่วคราวส่วนกลางได้ แต่จนกว่าการเชื่อมต่อสุดท้ายที่จะดำเนินการ (โดยปกติคือการเชื่อมต่อของผู้สร้างขั้นตอน) จะสิ้นสุดลง

วงจรชีวิตของกระบวนงานที่เก็บไว้ประกอบด้วยสองขั้นตอน: การสร้างและการดำเนินการ แต่ละขั้นตอนจะถูกสร้างขึ้นเพียงครั้งเดียวและดำเนินการหลายครั้ง ขั้นตอนการจัดเก็บจะดำเนินการโดยใช้ ดำเนินการตามคำแนะนำผู้ใช้ที่เป็นเจ้าของขั้นตอนหรือมีสิทธิ์ดำเนินการในการเข้าถึงขั้นตอนนั้น คำสั่ง EXECUTE มีไวยากรณ์ดังต่อไปนี้:

[] [@return_status =] (proc_name | @proc_name_var) ([[@parameter1 =] value | [@parameter1=] @variable ] | DEFAULT).. แบบแผนไวยากรณ์

ด้วยข้อยกเว้นของพารามิเตอร์ return_status พารามิเตอร์ทั้งหมดของคำสั่ง EXECUTE มีความหมายเชิงตรรกะเดียวกันกับพารามิเตอร์เดียวกันของคำสั่ง CREATE PROCEDURE พารามิเตอร์ return_status ระบุตัวแปรจำนวนเต็มที่เก็บสถานะการส่งคืนของขั้นตอน สามารถกำหนดค่าให้กับพารามิเตอร์โดยใช้ค่าคงที่ (ค่า) หรือตัวแปรเฉพาะที่ (@variable) ลำดับของค่าของพารามิเตอร์ที่มีชื่อนั้นไม่สำคัญ แต่ต้องระบุค่าของพารามิเตอร์ที่ไม่มีชื่อตามลำดับที่กำหนดไว้ในคำสั่ง CREATE PROCEDURE

ข้อเริ่มต้นจัดเตรียมค่าเริ่มต้นสำหรับพารามิเตอร์ขั้นตอนที่ระบุไว้ในข้อกำหนดของขั้นตอน เมื่อขั้นตอนคาดหวังค่าสำหรับพารามิเตอร์ที่ไม่ได้กำหนดค่าเริ่มต้นไว้ และพารามิเตอร์หายไปหรือระบุคำสำคัญ DEFAULT ข้อผิดพลาดจะเกิดขึ้น

เมื่อคำสั่ง EXECUTE เป็นคำสั่งแรกของแบตช์ คุณสามารถละเว้นคีย์เวิร์ด EXECUTE ได้ อย่างไรก็ตาม จะปลอดภัยกว่าถ้ารวมคำนี้ไว้ในทุกแพ็กเก็ต การใช้คำสั่ง EXECUTE แสดงในตัวอย่างด้านล่าง:

ใช้ SampleDb; ดำเนินการ เพิ่มงบประมาณ 10;

คำสั่ง EXECUTE ในตัวอย่างนี้ดำเนินการขั้นตอนการจัดเก็บ เพิ่มงบประมาณ ซึ่งจะเพิ่มงบประมาณของโครงการทั้งหมด 10%

ตัวอย่างด้านล่างแสดงวิธีการสร้างขั้นตอนการจัดเก็บเพื่อประมวลผลข้อมูลในตาราง Employee และ Works_on:

ขั้นตอนตัวอย่าง ModifyEmpId แสดงให้เห็นถึงการใช้ขั้นตอนการจัดเก็บเป็นส่วนหนึ่งของกระบวนการรักษาความสมบูรณ์ของการอ้างอิง (ในกรณีนี้คือระหว่างตาราง Employee และ Works_on) ขั้นตอนการจัดเก็บที่คล้ายกันสามารถนำมาใช้ภายในคำจำกัดความของทริกเกอร์ ซึ่งจริงๆ แล้วให้ความสมบูรณ์ในการอ้างอิง

ตัวอย่างต่อไปนี้แสดงการใช้ส่วนคำสั่ง OUTPUT ในกระบวนงานที่เก็บไว้:

ขั้นตอนที่เก็บไว้นี้สามารถดำเนินการได้โดยใช้คำแนะนำต่อไปนี้:

ประกาศ @quantityDeleteEmployee INT; ดำเนินการ DeleteEmployee @empId=18316, @OUTPUT; PRINT N"พนักงานที่ถูกลบ: " + แปลง (nvarchar (30), @quantityDeleteEmployee);

ขั้นตอนนี้จะนับจำนวนโครงการที่พนักงานที่มีหมายเลขบุคลากร @empId กำลังทำงานอยู่ และกำหนดค่าผลลัพธ์ให้กับพารามิเตอร์ ©counter หลังจากที่แถวทั้งหมดสำหรับหมายเลขบุคลากรที่กำหนดถูกลบออกจากตาราง Employee และ Works_on แล้ว ค่าที่คำนวณได้จะถูกกำหนดให้กับตัวแปร @quantityDeleteEmployee

ค่าพารามิเตอร์จะถูกส่งกลับไปยังขั้นตอนการเรียกเฉพาะเมื่อมีการระบุตัวเลือก OUTPUT ในตัวอย่างข้างต้น ขั้นตอน DeleteEmployee จะส่งผ่านพารามิเตอร์ @counter ไปยังขั้นตอนการเรียก ดังนั้นกระบวนงานที่เก็บไว้จึงส่งคืนค่าให้กับระบบ ดังนั้นจึงต้องระบุพารามิเตอร์ @counter ทั้งในตัวเลือก OUTPUT เมื่อประกาศขั้นตอนและในคำสั่ง EXECUTE เมื่อเรียกใช้

WITH RESULTS SETS clause ของคำสั่ง EXECUTE

ใน SQL Server 2012 คุณต้องป้อนคำสั่ง EXECUTE ด้วยคำสั่งชุดผลลัพธ์ซึ่งเมื่อตรงตามเงื่อนไขบางประการ คุณสามารถเปลี่ยนรูปแบบของชุดผลลัพธ์ของขั้นตอนการจัดเก็บได้

สองตัวอย่างต่อไปนี้จะช่วยอธิบายประโยคนี้ ตัวอย่างแรกคือตัวอย่างเบื้องต้นที่แสดงให้เห็นว่าผลลัพธ์อาจมีลักษณะอย่างไรเมื่อละเว้นคำสั่งย่อย WITH RESULTS SETS:

ขั้นตอน EmployeesInDept เป็นขั้นตอนง่ายๆ ที่แสดงหมายเลขบุคลากรและนามสกุลของพนักงานทุกคนที่ทำงานในแผนกเฉพาะ หมายเลขแผนกเป็นพารามิเตอร์ขั้นตอนและต้องระบุเมื่อโทร การดำเนินการตามขั้นตอนนี้จะสร้างตารางที่มีสองคอลัมน์ซึ่งมีส่วนหัวตรงกับชื่อของคอลัมน์ที่เกี่ยวข้องในตารางฐานข้อมูล เช่น ไอดีและนามสกุล. หากต้องการเปลี่ยนส่วนหัวของคอลัมน์ผลลัพธ์ (รวมถึงประเภทข้อมูล) SQL Server 2012 จะใช้ส่วนคำสั่ง WITH RESULTS SETS ใหม่ การใช้ประโยคนี้แสดงไว้ในตัวอย่างด้านล่าง:

ใช้ SampleDb; EXEC EmployeesInDept "d1" พร้อมชุดผลลัพธ์ (( INT ไม่ใช่ NULL, [นามสกุล] CHAR (20) ไม่ใช่ NULL));

ผลลัพธ์ของการดำเนินการขั้นตอนการจัดเก็บที่เรียกว่าในลักษณะนี้จะเป็นดังนี้:

อย่างที่คุณเห็น การรันโพรซีเดอร์ที่เก็บไว้โดยใช้คำสั่งย่อย WITH RESULT SETS ในคำสั่ง EXECUTE ช่วยให้คุณสามารถเปลี่ยนชื่อและชนิดข้อมูลของคอลัมน์ในชุดผลลัพธ์ที่สร้างโดยโพรซีเดอร์ ดังนั้นฟังก์ชันใหม่นี้จึงให้ความยืดหยุ่นมากขึ้นในการดำเนินการตามขั้นตอนการจัดเก็บและวางผลลัพธ์ไว้ในตารางใหม่

การเปลี่ยนโครงสร้างของขั้นตอนการจัดเก็บ

โปรแกรมฐานข้อมูลยังรองรับคำสั่งอีกด้วย เปลี่ยนแปลงขั้นตอนเพื่อปรับเปลี่ยนโครงสร้างของขั้นตอนการจัดเก็บ โดยทั่วไปจะใช้คำสั่ง ALTER PROCEDURE เพื่อเปลี่ยนคำสั่ง Transact-SQL ภายในขั้นตอน พารามิเตอร์ทั้งหมดของคำสั่ง ALTER PROCEDURE มีความหมายเหมือนกับพารามิเตอร์เดียวกันของคำสั่ง CREATE PROCEDURE วัตถุประสงค์หลักของการใช้คำสั่งนี้คือเพื่อหลีกเลี่ยงการแทนที่สิทธิ์ในกระบวนงานที่เก็บไว้ที่มีอยู่

โปรแกรมฐานข้อมูลรองรับ ชนิดข้อมูลเคอร์เซอร์- ชนิดข้อมูลนี้ใช้ในการประกาศเคอร์เซอร์ในกระบวนงานที่เก็บไว้ เคอร์เซอร์เป็นโครงสร้างการเขียนโปรแกรมที่ใช้ในการจัดเก็บผลลัพธ์ของการสืบค้น (โดยปกติจะเป็นชุดของแถว) และอนุญาตให้ผู้ใช้แสดงผลลัพธ์นั้นทีละแถว

หากต้องการลบขั้นตอนที่เก็บไว้หนึ่งหรือกลุ่ม ให้ใช้ คำสั่ง DROP PROCEDURE- เฉพาะเจ้าของหรือสมาชิกของบทบาทคงที่ db_owner และผู้ดูแลระบบเท่านั้นที่สามารถลบขั้นตอนที่เก็บไว้ได้

ขั้นตอนการจัดเก็บและ CLR

SQL Server รองรับ Common Language Runtime (CLR) ซึ่งช่วยให้คุณพัฒนาอ็อบเจ็กต์ฐานข้อมูลต่างๆ (ขั้นตอนการจัดเก็บ ฟังก์ชันที่ผู้ใช้กำหนด ทริกเกอร์ การรวมที่ผู้ใช้กำหนด และประเภทข้อมูลแบบกำหนดเอง) โดยใช้ C# และ Visual Basic CLR ยังช่วยให้คุณเรียกใช้งานออบเจ็กต์เหล่านี้ได้โดยใช้ระบบรันไทม์ทั่วไป

รันไทม์ภาษาทั่วไปถูกเปิดใช้งานและปิดใช้งานโดยใช้ตัวเลือก clr_เปิดใช้งานขั้นตอนของระบบ sp_configureซึ่งเปิดตัวเพื่อดำเนินการตามคำสั่ง กำหนดค่าใหม่- ตัวอย่างต่อไปนี้แสดงวิธีที่คุณสามารถใช้ขั้นตอนระบบ sp_configure เพื่อเปิดใช้งาน CLR:

ใช้ SampleDb; EXEC sp_configure "clr_enabled",1 กำหนดค่าใหม่

หากต้องการสร้าง คอมไพล์ และบันทึกขั้นตอนโดยใช้ CLR คุณต้องดำเนินการตามลำดับขั้นตอนต่อไปนี้ตามลำดับที่แสดง:

สร้างกระบวนงานที่เก็บไว้ใน C# หรือ Visual Basic แล้วคอมไพล์โดยใช้คอมไพเลอร์ที่เหมาะสม

การใช้คำแนะนำ สร้างแอสเซมบลีให้สร้างไฟล์ปฏิบัติการที่เกี่ยวข้อง

ดำเนินการตามขั้นตอนโดยใช้คำสั่ง EXECUTE

รูปด้านล่างแสดงไดอะแกรมกราฟิกของขั้นตอนที่อธิบายไว้ก่อนหน้านี้ ต่อไปนี้เป็นคำอธิบายโดยละเอียดเพิ่มเติมของกระบวนการนี้

ขั้นแรก สร้างโปรแกรมที่จำเป็นในสภาพแวดล้อมการพัฒนา เช่น Visual Studio คอมไพล์โปรแกรมที่เสร็จแล้วเป็นออบเจ็กต์โค้ดโดยใช้คอมไพเลอร์ C# หรือ Visual Basic รหัสนี้ถูกเก็บไว้ในไฟล์ไลบรารีลิงก์แบบไดนามิก (.dll) ซึ่งทำหน้าที่เป็นแหล่งที่มาสำหรับคำสั่ง CREATE ASSEMBLY ซึ่งสร้างรหัสปฏิบัติการระดับกลาง ถัดไป ออกคำสั่ง CREATE PROCEDURE เพื่อบันทึกโค้ดที่รันเป็นอ็อบเจ็กต์ฐานข้อมูล สุดท้าย ให้รันโพรซีเดอร์โดยใช้คำสั่ง EXECUTE ที่คุ้นเคย

ตัวอย่างด้านล่างแสดงซอร์สโค้ดสำหรับกระบวนงานที่เก็บไว้ใน C#:

การใช้ System.Data.SqlClient; โดยใช้ Microsoft.SqlServer.Server; StoredProcedures คลาสสาธารณะบางส่วน ( public static int CountEmployees() ( int rows; SqlConnection Connection = new SqlConnection("Context Connection=true"); Connection.Open(); SqlCommand cmd = Connection.CreateCommand(); cmd.CommandText = "select count(*) เป็น "จำนวนพนักงาน" " + "จากพนักงาน"; row = (int)cmd.ExecuteScalar(); Connection.Close(); กลับแถว; ) )

ขั้นตอนนี้ใช้แบบสอบถามเพื่อนับจำนวนแถวในตารางพนักงาน การใช้คำสั่งที่จุดเริ่มต้นของโปรแกรมระบุเนมสเปซที่จำเป็นในการรันโปรแกรม การใช้คำสั่งเหล่านี้ช่วยให้คุณสามารถระบุชื่อคลาสในซอร์สโค้ดโดยไม่ต้องระบุเนมสเปซที่เกี่ยวข้องอย่างชัดเจน ถัดไป มีการกำหนดคลาส StoredProcedures ซึ่ง แอตทริบิวต์ SqlProcedureซึ่งแจ้งคอมไพเลอร์ว่าคลาสนี้เป็นกระบวนงานที่เก็บไว้ วิธีการ CountEmployees() ถูกกำหนดไว้ภายในรหัสชั้นเรียน การเชื่อมต่อกับระบบฐานข้อมูลถูกสร้างขึ้นผ่านอินสแตนซ์ของคลาส การเชื่อมต่อ SQL- หากต้องการเปิดการเชื่อมต่อ จะใช้เมธอด Open() ของอินสแตนซ์นี้ ก CreateCommand() วิธีการช่วยให้คุณเข้าถึงอินสแตนซ์ของคลาสได้ SQLCommndซึ่งส่งคำสั่ง SQL ที่จำเป็นไปให้

ในข้อมูลโค้ดต่อไปนี้:

Cmd.CommandText = "select count(*) เป็น "จำนวนพนักงาน" " + "จากพนักงาน";

ใช้คำสั่ง SELECT เพื่อนับจำนวนแถวในตารางพนักงานและแสดงผลลัพธ์ ข้อความคำสั่งถูกระบุโดยการตั้งค่าคุณสมบัติ CommandText ของตัวแปร cmd ให้กับอินสแตนซ์ที่ส่งคืนโดยเมธอด CreateCommand() ต่อไปก็เรียกว่า วิธีการ ExecuteScalar()อินสแตนซ์ SqlCommand เมธอดนี้ส่งคืนค่าสเกลาร์ที่ถูกแปลงเป็นชนิดข้อมูลจำนวนเต็มและกำหนดให้กับตัวแปรแถว

ตอนนี้คุณสามารถคอมไพล์โค้ดนี้โดยใช้ Visual Studio ฉันเพิ่มคลาสนี้ในโครงการชื่อ CLRStoredProcedures ดังนั้น Visual Studio จะรวบรวมแอสเซมบลีที่มีชื่อเดียวกันพร้อมกับนามสกุล *.dll ตัวอย่างด้านล่างแสดงขั้นตอนถัดไปในการสร้างขั้นตอนการจัดเก็บ: การสร้างโค้ดที่ปฏิบัติการได้ ก่อนที่คุณจะเรียกใช้โค้ดในตัวอย่างนี้ คุณจำเป็นต้องทราบตำแหน่งของไฟล์ dll ที่คอมไพล์แล้ว (โดยปกติจะอยู่ในโฟลเดอร์ Debug ของโครงการ)

ใช้ SampleDb; ไปสร้าง ASSEMBLY CLRStoredProcedures จาก "D:\Projects\CLRStoredProcedures\bin\Debug\CLRStoredProcedures.dll" ด้วย PERMISSION_SET = SAFE

คำสั่ง CREATE ASSEMBLY รับโค้ดที่ได้รับการจัดการเป็นอินพุต และสร้างออบเจ็กต์ที่สอดคล้องกันซึ่งคุณสามารถสร้างขั้นตอนการจัดเก็บ CLR ฟังก์ชันที่ผู้ใช้กำหนด และทริกเกอร์ได้ คำสั่งนี้มีไวยากรณ์ดังต่อไปนี้:

สร้าง ASSEMBLY assembly_name [ การอนุญาต Owner_name ] จาก (dll_file) แบบแผนไวยากรณ์

พารามิเตอร์ assembly_name ระบุชื่อของแอสเซมบลี ส่วนคำสั่ง AUTHORIZATION ที่เป็นทางเลือกระบุชื่อบทบาทในฐานะเจ้าของแอสเซมบลีนี้ ส่วนคำสั่ง FROM ระบุเส้นทางที่มีชุดประกอบที่จะโหลดอยู่

ด้วยส่วนคำสั่ง PERMISSION_SETเป็น clause ที่สำคัญมากของคำสั่ง CREATE ASSEMBLY และต้องระบุเสมอ มันกำหนดชุดของการอนุญาตที่มอบให้กับรหัสแอสเซมบลี ชุดสิทธิ์อนุญาต SAFE นั้นมีข้อจำกัดมากที่สุด รหัสแอสเซมบลีที่มีสิทธิ์เหล่านี้ไม่สามารถเข้าถึงทรัพยากรระบบภายนอกเช่นไฟล์ได้ ชุดสิทธิ์ EXTERNAL_ACCESS อนุญาตให้โค้ดแอสเซมบลีเข้าถึงทรัพยากรระบบภายนอกบางอย่าง ในขณะที่ชุดสิทธิ์ UNSAFE อนุญาตให้เข้าถึงทรัพยากรอย่างไม่จำกัดทั้งภายในและภายนอกระบบฐานข้อมูล

หากต้องการบันทึกข้อมูลรหัสแอสเซมบลี ผู้ใช้จะต้องสามารถออกคำสั่ง CREATE ASSEMBLY ได้ เจ้าของแอสเซมบลีคือผู้ใช้ (หรือบทบาท) ที่ดำเนินการคำสั่ง คุณสามารถกำหนดให้ผู้ใช้รายอื่นเป็นเจ้าของแอสเซมบลีได้โดยใช้ส่วนคำสั่ง AUTHORIZATION ของคำสั่ง CREATE SCHEMA

โปรแกรมฐานข้อมูลยังรองรับคำสั่ง ALTER ASSEMBLY และ DROP ASSEMBLY คำสั่ง ALTER ASSEMBLYใช้ในการอัพเดตแอสเซมบลีเป็นเวอร์ชันล่าสุด คำสั่งนี้ยังเพิ่มหรือลบไฟล์ที่เกี่ยวข้องกับแอสเซมบลีที่เกี่ยวข้อง คำแนะนำ DROP ASSEMBLYลบแอสเซมบลีที่ระบุและไฟล์ที่เกี่ยวข้องทั้งหมดออกจากฐานข้อมูลปัจจุบัน

ตัวอย่างด้านล่างแสดงวิธีการสร้างขั้นตอนการจัดเก็บตามโค้ดที่ได้รับการจัดการที่คุณนำไปใช้ก่อนหน้านี้:

ใช้ SampleDb; ไปสร้างขั้นตอน CountEmployees เป็นชื่อภายนอก CLRStoredProcedures.StoredProcedures.CountEmployees

คำสั่ง CREATE PROCEDURE ในตัวอย่างแตกต่างจากคำสั่งเดียวกันในตัวอย่างก่อนหน้านี้ที่มี พารามิเตอร์ชื่อภายนอก- ตัวเลือกนี้ระบุว่าโค้ดถูกสร้างขึ้นโดยรันไทม์ภาษาทั่วไป ชื่อในประโยคนี้ประกอบด้วยสามส่วน:

Assembly_name.class_name.method_name

assembly_name - ระบุชื่อของชุดประกอบ

class_name - ระบุชื่อของคลาสทั่วไป

method_name - ส่วนเสริม ระบุชื่อของวิธีการที่กำหนดไว้ภายในคลาส

การดำเนินการตามขั้นตอนของ CountEmployees จะแสดงอยู่ในตัวอย่างด้านล่าง:

ใช้ SampleDb; ประกาศ @count INT EXECUTE @count = CountEmployees PRINT @count -- ส่งคืน 7

คำสั่ง PRINT ส่งคืนจำนวนแถวปัจจุบันในตารางพนักงาน

ในบทช่วยสอนนี้คุณจะได้เรียนรู้วิธีการ สร้างและลบขั้นตอนใน SQL Server(Transact-SQL) พร้อมไวยากรณ์และตัวอย่าง

คำอธิบาย

ใน SQL Server ขั้นตอนคือโปรแกรมที่เก็บไว้ซึ่งคุณสามารถส่งผ่านพารามิเตอร์ได้ มันไม่คืนค่าเหมือนฟังก์ชัน อย่างไรก็ตาม สามารถส่งกลับสถานะสำเร็จ/ล้มเหลวไปยังขั้นตอนที่เรียกได้

สร้างขั้นตอน

คุณสามารถสร้างขั้นตอนการจัดเก็บของคุณเองได้ใน SQL Server (Transact-SQL) มาดูกันดีกว่า

ไวยากรณ์

ไวยากรณ์ของขั้นตอนใน SQL Server (Transact-SQL):

สร้าง (ขั้นตอน | PROC) Procedure_name
[ @ชนิดข้อมูลพารามิเตอร์
[ แปรผัน ] [ = ค่าเริ่มต้น ] [ ออก | เอาท์พุท | อ่านอย่างเดียว]
, ประเภทข้อมูล @parameter
[ แปรผัน ] [ = ค่าเริ่มต้น ] [ ออก | เอาท์พุท | อ่านอย่างเดียว ] ]
[ ด้วย ( การเข้ารหัส | คอมไพล์ใหม่ | ดำเนินการตามข้อ ) ]
[สำหรับการจำลอง]
เช่น
เริ่ม
executable_section
จบ;

พารามิเตอร์หรืออาร์กิวเมนต์

schema_nameเป็นชื่อของสคีมาซึ่งเป็นของกระบวนงานที่เก็บไว้
Procedure_nameเป็นชื่อที่จะกำหนดขั้นตอนนี้ใน SQL Server
@parameter - พารามิเตอร์ตั้งแต่หนึ่งตัวขึ้นไปถูกส่งไปยังโพรซีเดอร์
type_schema_name คือสคีมาที่เป็นเจ้าของประเภทข้อมูล หากมี
ประเภทข้อมูล — ชนิดข้อมูลสำหรับ @parameter
VARYING - ตั้งค่าสำหรับพารามิเตอร์เคอร์เซอร์เมื่อชุดผลลัพธ์เป็นพารามิเตอร์เอาต์พุต
default คือค่าเริ่มต้นที่จะกำหนดให้กับพารามิเตอร์ @parameter
OUT - ซึ่งหมายความว่า @parameter เป็นพารามิเตอร์เอาต์พุต
OUTPUT - ซึ่งหมายความว่า @parameter เป็นพารามิเตอร์เอาต์พุต
อ่านอย่างเดียว - ซึ่งหมายความว่า @parameter ไม่สามารถเขียนทับโดยกระบวนงานที่เก็บไว้ได้
การเข้ารหัส - ซึ่งหมายความว่าแหล่งที่มาของกระบวนงานที่เก็บไว้จะไม่ถูกจัดเก็บเป็นข้อความธรรมดาในมุมมองของระบบ SQL Server
คอมไพล์ใหม่ - ซึ่งหมายความว่าแผนแบบสอบถามจะไม่ถูกแคชสำหรับกระบวนงานที่เก็บไว้นี้
ดำเนินการ AS - ตั้งค่าบริบทความปลอดภัยสำหรับการดำเนินการตามขั้นตอนที่เก็บไว้
สำหรับการจำลอง - ซึ่งหมายความว่าขั้นตอนการจัดเก็บจะถูกดำเนินการในระหว่างการจำลองแบบเท่านั้น

ตัวอย่าง

ลองดูตัวอย่างการสร้างกระบวนงานที่เก็บไว้ใน SQL Server (Transact-SQL)
ด้านล่างนี้เป็นตัวอย่างง่ายๆ ของขั้นตอน:

ธุรกรรม-SQL

สร้างขั้นตอน FindSite @site_name VARCHAR (50) ออกมาตามที่ประกาศเริ่มต้น @site_id INT;< 10 SET @site_name = "yandex.com"; ELSE SET @site_name = "google.com"; END;

สร้างขั้นตอน FindSite @site_name VARCHAR(50) ออกแล้ว เริ่ม ประกาศ @site_id INT ; SET @site_id = 8 ; ถ้า@site_id< 10 SET @ site_name = "yandex.com" ; อื่น SET @site_name = "google.com" ; จบ ;

ขั้นตอนนี้เรียกว่า FindSite มีพารามิเตอร์หนึ่งตัวที่เรียกว่า @site_name ซึ่งเป็นพารามิเตอร์เอาต์พุตที่ได้รับการอัปเดตตามตัวแปร @site_id

จากนั้นคุณสามารถอ้างอิงขั้นตอนการจัดเก็บใหม่ที่เรียกว่า FindSite ได้เช่นนี้

ใน Microsoft SQL Server เพื่อนำไปใช้และทำให้อัลกอริทึมของคุณเองเป็นแบบอัตโนมัติ ( การคำนวณ) คุณสามารถใช้ขั้นตอนการจัดเก็บได้ ดังนั้นวันนี้เราจะพูดถึงวิธีการสร้าง แก้ไข และลบขั้นตอนเหล่านี้

แต่ก่อนอื่น มีทฤษฎีเล็กๆ น้อยๆ เพื่อให้คุณเข้าใจว่า Stored Procedure คืออะไร และเหตุใดจึงจำเป็นใน T-SQL

บันทึก! สำหรับมือใหม่หัดเขียนโปรแกรม ฉันขอแนะนำสื่อที่มีประโยชน์ต่อไปนี้บน T-SQL:

• หากต้องการศึกษาภาษา T-SQL แบบละเอียดเพิ่มเติม ฉันแนะนำให้อ่านหนังสือ - เส้นทางของโปรแกรมเมอร์ T-SQL บทช่วยสอนเกี่ยวกับภาษา Transact-SQL
• หลักสูตรออนไลน์ระดับมืออาชีพบน T-SQL

ขั้นตอนการจัดเก็บใน T-SQL คืออะไร?

ขั้นตอนการจัดเก็บ– สิ่งเหล่านี้คือวัตถุฐานข้อมูลที่มีอัลกอริทึมในรูปแบบของชุดคำสั่ง SQL กล่าวอีกนัยหนึ่งเราสามารถพูดได้ว่า Stored Procedure คือโปรแกรมภายในฐานข้อมูล Stored Procedures ใช้เพื่อจัดเก็บโค้ดที่ใช้ซ้ำได้บนเซิร์ฟเวอร์ ตัวอย่างเช่น คุณเขียนอัลกอริธึมบางอย่าง การคำนวณตามลำดับ หรือคำสั่ง SQL แบบหลายขั้นตอน และเพื่อไม่ให้ดำเนินการตามคำแนะนำทั้งหมดที่รวมอยู่ในอัลกอริธึมนี้ในแต่ละครั้ง คุณสามารถจัดรูปแบบได้ เป็นขั้นตอนการจัดเก็บ ในเวลาเดียวกัน เมื่อคุณสร้างขั้นตอน SQL เซิร์ฟเวอร์จะคอมไพล์โค้ด จากนั้น ทุกครั้งที่คุณเรียกใช้ขั้นตอน SQL นี้ เซิร์ฟเวอร์จะไม่คอมไพล์ใหม่

ในการรันโพรซีเดอร์ที่เก็บไว้ใน SQL Server คุณต้องเขียนคำสั่ง EXECUTE หน้าชื่อ นอกจากนี้ยังสามารถย่อคำสั่งนี้เป็น EXEC ได้ด้วย การเรียกใช้ Stored Procedure ในคำสั่ง SELECT เนื่องจากฟังก์ชันจะไม่ทำงานอีกต่อไป เช่น ขั้นตอนต่างๆ จะถูกเปิดตัวแยกกัน

ในขั้นตอนการจัดเก็บ ต่างจากฟังก์ชันตรงที่จะดำเนินการแก้ไขข้อมูลได้อยู่แล้ว เช่น: UNSERT, UPDATE, DELETE คุณยังสามารถใช้คำสั่ง SQL ได้เกือบทุกประเภทในขั้นตอน เช่น CREATE TABLE เพื่อสร้างตารางหรือ EXECUTE เช่น เรียกขั้นตอนอื่น ๆ ข้อยกเว้นคือคำสั่งหลายประเภท เช่น การสร้างหรือการเปลี่ยนแปลงฟังก์ชัน มุมมอง ทริกเกอร์ การสร้างสคีมา และคำแนะนำอื่น ๆ ที่คล้ายกัน ตัวอย่างเช่น คุณไม่สามารถสลับบริบทการเชื่อมต่อฐานข้อมูล (USE) ในกระบวนงานที่เก็บไว้ได้

ขั้นตอนที่เก็บไว้สามารถมีพารามิเตอร์อินพุตและพารามิเตอร์เอาต์พุต สามารถส่งคืนข้อมูลแบบตาราง หรือไม่ส่งคืนอะไรเลย ให้ดำเนินการตามคำแนะนำที่มีอยู่ในนั้นเท่านั้น

ขั้นตอนที่เก็บไว้มีประโยชน์มาก โดยช่วยให้เราดำเนินการต่างๆ โดยอัตโนมัติหรือลดความซับซ้อนได้ เช่น คุณจำเป็นต้องสร้างรายงานการวิเคราะห์ที่ซับซ้อนต่างๆ อย่างต่อเนื่องโดยใช้ตาราง Pivot เช่น ตัวดำเนินการ PIVOT เพื่อให้ง่ายต่อการกำหนดแบบสอบถามด้วยโอเปอเรเตอร์นี้ ( ดังที่คุณทราบ ไวยากรณ์ของ PIVOT ค่อนข้างซับซ้อน) คุณสามารถเขียนขั้นตอนที่จะสร้างรายงานสรุปแบบไดนามิกให้กับคุณได้ เช่น วัสดุ "Dynamic PIVOT ใน T-SQL" จะให้ตัวอย่างการใช้คุณลักษณะนี้ในรูปแบบของขั้นตอนการจัดเก็บ

ตัวอย่างการทำงานกับ Stored Procedure ใน Microsoft SQL Server

แหล่งข้อมูลสำหรับตัวอย่าง

ตัวอย่างทั้งหมดด้านล่างนี้จะทำงานใน Microsoft SQL Server 2016 Express เพื่อแสดงให้เห็นว่า Stored Procedures ทำงานอย่างไรกับข้อมูลจริง เราต้องการข้อมูลนี้ มาสร้างมันกัน ตัวอย่างเช่น เรามาสร้างตารางทดสอบและเพิ่มระเบียนลงไป สมมติว่ามันจะเป็นตารางที่ประกอบด้วยรายการผลิตภัณฑ์พร้อมราคา

คำแนะนำในการสร้างตาราง CREATE TABLE TestTable( INT IDENTITY(1,1) NOT NULL, INT NOT NULL, VARCHAR(100) NOT NULL, MONEY NULL) GO -- คำแนะนำในการเพิ่มข้อมูล INSERT INTO TestTable(CategoryId, ProductName, Price) ค่า (1 , "เมาส์", 100), (1, "คีย์บอร์ด", 200), (2, "โทรศัพท์", 400) GO --เลือกแบบสอบถาม SELECT * FROM TestTable

เรามีข้อมูลแล้ว ตอนนี้เรามาสร้างขั้นตอนการจัดเก็บกันดีกว่า

การสร้างขั้นตอนการจัดเก็บใน T-SQL - คำสั่ง CREATE PROCEDURE

ขั้นตอนที่เก็บไว้ถูกสร้างขึ้นโดยใช้คำสั่ง สร้างขั้นตอนหลังจากคำสั่งนี้ คุณต้องเขียนชื่อของขั้นตอนของคุณ จากนั้น หากจำเป็น ให้กำหนดพารามิเตอร์อินพุตและเอาต์พุตในวงเล็บ หลังจากนี้คุณเขียนคำหลัก AS และเปิดบล็อกคำแนะนำด้วยคำหลัก BEGIN ปิดบล็อกนี้ด้วยคำว่า END ภายในบล็อกนี้ คุณเขียนคำสั่งทั้งหมดที่ใช้อัลกอริธึมของคุณหรือการคำนวณตามลำดับบางประเภท กล่าวคือ คุณเขียนโปรแกรมใน T-SQL

ตัวอย่างเช่น ลองเขียน Stored Procedure ที่จะเพิ่มบันทึกใหม่ เช่น ผลิตภัณฑ์ใหม่สู่ตารางทดสอบของเรา ในการดำเนินการนี้ เราจะกำหนดพารามิเตอร์อินพุตสามรายการ: @CategoryId – ตัวระบุหมวดหมู่ผลิตภัณฑ์ @ProductName – ชื่อผลิตภัณฑ์ และ @Price – ราคาผลิตภัณฑ์ พารามิเตอร์นี้จะเป็นทางเลือก กล่าวคือ ไม่จำเป็นต้องส่งต่อไปยังขั้นตอน ( เช่นเรายังไม่ทราบราคา) เพื่อจุดประสงค์นี้ เราจะตั้งค่าเริ่มต้นในคำจำกัดความ พารามิเตอร์เหล่านี้อยู่ในเนื้อหาของขั้นตอน เช่น ในบล็อก BEGIN...END สามารถใช้ได้ เช่นเดียวกับตัวแปรปกติ ( ดังที่คุณทราบ ตัวแปรจะแสดงด้วยเครื่องหมาย @- หากคุณต้องการระบุพารามิเตอร์เอาต์พุต หลังจากชื่อพารามิเตอร์ให้ระบุคีย์เวิร์ด OUTPUT ( หรือเรียกสั้น ๆ ว่า OUT).

ในบล็อก BEGIN...END เราจะเขียนคำสั่งในการเพิ่มข้อมูล เช่นเดียวกับคำสั่ง SELECT ที่ส่วนท้ายของกระบวนการ เพื่อให้กระบวนงานที่เก็บไว้ส่งคืนข้อมูลแบบตารางเกี่ยวกับผลิตภัณฑ์ในหมวดหมู่ที่ระบุ โดยคำนึงถึง พิจารณาผลิตภัณฑ์ใหม่ที่เพิ่งเพิ่มเข้ามา นอกจากนี้ ในขั้นตอนการจัดเก็บนี้ ฉันได้เพิ่มการประมวลผลพารามิเตอร์ขาเข้า กล่าวคือ การลบช่องว่างเพิ่มเติมที่จุดเริ่มต้นและจุดสิ้นสุดของสตริงข้อความ เพื่อกำจัดสถานการณ์ที่มีการป้อนช่องว่างหลายช่องโดยไม่ตั้งใจ

นี่คือรหัสสำหรับขั้นตอนนี้ ( ฉันยังแสดงความคิดเห็นเกี่ยวกับเรื่องนี้).

สร้างขั้นตอน CREATE PROCEDURE TestProcedure (--ป้อนพารามิเตอร์ @CategoryId INT, @ProductName VARCHAR(100), @Price MONEY = 0) AS BEGIN --คำแนะนำที่ใช้อัลกอริทึมของคุณ --การประมวลผลพารามิเตอร์ขาเข้า --การลบช่องว่างเพิ่มเติมที่จุดเริ่มต้น และท้ายบรรทัดข้อความ SET @ProductName = LTRIM(RTRIM(@ProductName));

--เพิ่มบันทึกใหม่ INSERT INTO TestTable(CategoryId, ProductName, Price) VALUES (@CategoryId, @ProductName, @Price) --ส่งคืนข้อมูล SELECT * FROM TestTable WHERE CategoryId = @CategoryId END GO

คุณสามารถเรียกใช้กระบวนงานที่เก็บไว้ดังที่ฉันได้กล่าวไว้แล้วโดยใช้คำสั่ง EXECUTE หรือ EXEC พารามิเตอร์ขาเข้าจะถูกส่งไปยังโพรซีเดอร์โดยเพียงแค่แสดงรายการและระบุค่าที่เหมาะสมหลังชื่อโพรซีเดอร์ ( สำหรับพารามิเตอร์เอาต์พุต คุณต้องระบุคำสั่ง OUTPUT ด้วย- อย่างไรก็ตาม อาจไม่สามารถระบุชื่อของพารามิเตอร์ได้ แต่ในกรณีนี้ จำเป็นต้องปฏิบัติตามลำดับการระบุค่า เช่น ระบุค่าตามลำดับที่กำหนดพารามิเตอร์อินพุต ( นอกจากนี้ยังใช้กับพารามิเตอร์เอาต์พุตด้วย).

ไม่จำเป็นต้องระบุพารามิเตอร์ที่มีค่าเริ่มต้นซึ่งเรียกว่าพารามิเตอร์ทางเลือก

ต่อไปนี้เป็นวิธีการรัน Stored Procedure ที่แตกต่างกันแต่เทียบเท่ากันเล็กน้อย โดยเฉพาะขั้นตอนการทดสอบของเรา

1. เรียกขั้นตอนโดยไม่ระบุราคา EXECUTE TestProcedure @CategoryId = 1, @ProductName = "ทดสอบผลิตภัณฑ์ 1" --2 เรียกขั้นตอนที่ระบุราคา EXEC TestProcedure @CategoryId = 1, @ProductName = "Test product 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) AS BEGIN --คำแนะนำที่ใช้อัลกอริทึมของคุณ --การประมวลผลพารามิเตอร์ขาเข้า --การลบช่องว่างเพิ่มเติมที่จุดเริ่มต้นและ ท้ายบรรทัดข้อความ SET @ProductName = LTRIM(RTRIM(@ProductName));

--เพิ่มบันทึกใหม่ INSERT INTO TestTable(CategoryId, ProductName, Price) VALUES (@CategoryId, @ProductName, @Price) END GO

การลบขั้นตอนการจัดเก็บในคำสั่ง T-SQL - DROP PROCEDURE หากจำเป็น คุณสามารถลบขั้นตอนที่เก็บไว้ได้ โดยทำตามคำแนะนำ.

ขั้นตอนการวาง

ตัวอย่างเช่น ลองลบขั้นตอนการทดสอบที่เราสร้างขึ้น

เมื่อลบขั้นตอนที่เก็บไว้ ควรจำไว้ว่าหากขั้นตอนถูกอ้างอิงโดยขั้นตอนอื่นหรือคำสั่ง SQL หลังจากลบแล้ว ขั้นตอนเหล่านั้นจะล้มเหลวโดยมีข้อผิดพลาด เนื่องจากขั้นตอนที่อ้างอิงไม่มีอยู่อีกต่อไป

นั่นคือทั้งหมดที่ฉันมี ฉันหวังว่าเนื้อหาจะน่าสนใจและเป็นประโยชน์กับคุณ ลาก่อน!