ขั้นตอนการจัดเก็บ sql คืออะไร แหล่งข้อมูลสำหรับตัวอย่าง โซลูชันที่รวบรวมจากเว็บของ "อะไรคือความแตกต่างระหว่างขั้นตอนการจัดเก็บและมุมมอง"

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

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

ขั้นตอนการโทร(…)

ดำเนินการขั้นตอน(...)

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

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

ด้านหลัง

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

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

จัดให้มีกลไกการป้องกัน ตามจุดก่อนหน้า หากคุณสามารถเข้าถึงข้อมูลผ่านขั้นตอนการจัดเก็บเท่านั้น จะไม่มีใครสามารถลบข้อมูลของคุณผ่านคำสั่ง SQL DELETE ได้

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

ขัดต่อ

เพิ่มภาระบนเซิร์ฟเวอร์ฐานข้อมูลเนื่องจากงานส่วนใหญ่ดำเนินการบนฝั่งเซิร์ฟเวอร์และบนฝั่งไคลเอ็นต์น้อยลง

คุณจะต้องเรียนรู้มาก คุณจะต้องเรียนรู้ไวยากรณ์นิพจน์ MySQL เพื่อเขียนขั้นตอนการจัดเก็บของคุณ

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

การย้ายจาก DBMS หนึ่งไปยังอีก (DB2, เซิร์ฟเวอร์ SQLฯลฯ) อาจทำให้เกิดปัญหาได้

วัตถุประสงค์และประโยชน์ของขั้นตอนการจัดเก็บ

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

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

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

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

ความสามารถในการเขียนโปรแกรม

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

ความปลอดภัย

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

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

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

การใช้ขั้นตอนการจัดเก็บ

โดยทั่วไปกระบวนงานที่เก็บไว้จะถูกสร้างขึ้นโดยใช้ภาษา SQL หรือการใช้งานเฉพาะใน DBMS ที่เลือก ตัวอย่างเช่น เพื่อวัตถุประสงค์เหล่านี้ ใน Microsoft SQL Server DBMS จะมีภาษา Transact-SQL ใน Oracle - PL/SQL ใน InterBase และ Firebird - PSQL ใน PostgreSQL - PL/pgSQL, PL/Tcl, PL/Perl PL/Python ใน IBM DB2 - SQL/PL (ภาษาอังกฤษ) ใน Informix - SPL MySQL เป็นไปตามมาตรฐาน SQL:2003 อย่างใกล้ชิด โดยมีภาษาคล้ายกับ SQL/PL

DBMS บางตัวอนุญาตให้ใช้ขั้นตอนการจัดเก็บที่เขียนด้วยภาษาการเขียนโปรแกรมใดๆ ที่สามารถสร้างไฟล์ปฏิบัติการอิสระได้ เช่น C++ หรือ Delphi ในคำศัพท์เฉพาะของ Microsoft SQL Server ขั้นตอนดังกล่าวเรียกว่าขั้นตอนการจัดเก็บแบบขยายและเป็นเพียงฟังก์ชันที่มีอยู่ใน Win32 DLL และ ตัวอย่างเช่น ใน Interbase และ Firebird ฟังก์ชันที่เรียกจาก DLL/SO จะมีชื่อที่แตกต่างกัน - UDF (User Defined Function) MS SQL 2005 นำเสนอความสามารถในการเขียนขั้นตอนการจัดเก็บในภาษา .NET ใด ๆ และขั้นตอนการจัดเก็บเพิ่มเติมมีแผนจะถูกยกเลิกในอนาคต ในทางกลับกัน Oracle DBMS อนุญาตให้เขียนขั้นตอนการจัดเก็บไว้ได้ ภาษาจาวา. ใน IBM DB2 การเขียนขั้นตอนและฟังก์ชันที่เก็บไว้ในภาษาการเขียนโปรแกรมทั่วไปเป็นวิธีดั้งเดิมที่ได้รับการสนับสนุนตั้งแต่ต้นและส่วนขยายขั้นตอน SQL ได้ถูกเพิ่มลงใน DBMS นี้ในเวอร์ชันที่ค่อนข้างช้าเท่านั้นหลังจากรวมไว้ในมาตรฐาน ANSI Informix ยังรองรับขั้นตอนใน Java และ C

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

ใน IBM DB2 DBMS กระบวนการจัดเก็บสามารถรวมเป็นโมดูลได้

ไวยากรณ์

สร้างขั้นตอน `p2`()

ตัวกำหนดความปลอดภัยของ SQL

แสดงความคิดเห็นเกี่ยวกับเพลง "ขั้นตอน"

เลือก "สวัสดีชาวโลก !";

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

คุณลักษณะ 4 ประการของขั้นตอนการจัดเก็บ:

ภาษา: เพื่อการพกพา ค่าเริ่มต้นคือ SQL

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

ความปลอดภัยของ SQL: สิทธิ์ผู้ใช้จะถูกตรวจสอบระหว่างการโทร INVOKER คือผู้ใช้ที่เรียกขั้นตอนการจัดเก็บ DEFINER คือ "ผู้สร้าง" ของกระบวนการ ค่าเริ่มต้นคือ DEFINER

หมายเหตุ: เพื่อวัตถุประสงค์ด้านเอกสาร ค่าเริ่มต้นคือ ""

การเรียกกระบวนงานที่เก็บไว้

โทรที่เก็บไว้_procedure_name (param1, param2, ....)

CALL Procedure1(10 , "พารามิเตอร์สตริง" , @parameter_var);

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

MySQL มีคำสั่ง ALTER PROCEDURE สำหรับการเปลี่ยนขั้นตอน แต่เหมาะสำหรับการเปลี่ยนแปลงคุณสมบัติบางอย่างเท่านั้น หากคุณต้องการเปลี่ยนพารามิเตอร์หรือเนื้อหาของขั้นตอน คุณควรลบและสร้างใหม่

การกำจัดเก็บไว้ขั้นตอน

ขั้นตอนการวางหากมี p2;

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

ตัวเลือก

สร้างขั้นตอน proc1(): รายการพารามิเตอร์ว่าง

สร้างขั้นตอน proc1 (ใน varname DATA-TYPE): พารามิเตอร์อินพุตหนึ่งตัว คำว่า IN เป็นทางเลือก เนื่องจากพารามิเตอร์เริ่มต้นคือ IN (in)

สร้างขั้นตอน proc1 (OUT varname DATA-TYPE): ส่งคืนพารามิเตอร์หนึ่งตัว

สร้างขั้นตอน proc1 (INOUT varname DATA-TYPE): หนึ่งพารามิเตอร์ทั้งอินพุตและส่งคืน

ไวยากรณ์การประกาศตัวแปรมีลักษณะดังนี้:

ประกาศ varname DATA-TYPE ค่าเริ่มต้นเริ่มต้น;

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

ประเภทของขั้นตอนการจัดเก็บ

SQL Server มีขั้นตอนการจัดเก็บหลายประเภท

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

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

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

ทริกเกอร์

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

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

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

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

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

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

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

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

การออกคำเตือนเตือนให้คุณดำเนินการบางอย่างเมื่ออัปเดตตารางที่นำไปใช้ในลักษณะใดลักษณะหนึ่ง

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

การสนับสนุนการจำลองแบบ

รูปแบบพื้นฐานของคำสั่ง CREATE TRIGGER แสดงอยู่ด้านล่าง:

<Определение_триггера>::=

สร้างทริกเกอร์ trigger_name

ก่อน | หลังจาก<триггерное_событие>

บน<имя_таблицы>

<список_старых_или_новых_псевдонимов>]

<тело_триггера>

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

การดำเนินการที่ทำโดยทริกเกอร์จะถูกระบุสำหรับแต่ละแถว (สำหรับแต่ละแถว) ที่ครอบคลุมโดยเหตุการณ์ หรือเพียงครั้งเดียวสำหรับแต่ละเหตุการณ์ (สำหรับแต่ละคำสั่ง)

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

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

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

สร้าง PROC dbo.ProcName
เช่น
ตั้งหมายเลขบน;
--นี่คือรหัสขั้นตอน
เลือก column1 จาก dbo.TblTable1
--Toggle SET NOCOUNT เป็นสถานะเริ่มต้น
ตั้งค่าจำนวนปิด;
ไป

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

SELECT * FROM dbo.MyTable --นี่เป็นสิ่งที่ดีที่จะทำ
-- แทน
SELECT * FROM MyTable -- และการทำเช่นนี้ถือเป็นเรื่องไม่ดี
--การเรียกขั้นตอน
EXEC dbo.MyProc --ดีอีกครั้ง
--แทน
EXEC MyProc --แย่!

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

4. ใช้ IF EXISTS (SELECT 1) แทน IF EXISTS (SELECT *):ในการตรวจสอบการมีอยู่ของบันทึกในตารางอื่น เราใช้คำสั่ง IF EXISTS สำนวนนี้คืนค่าเป็นจริงหากส่งคืนค่าอย่างน้อยหนึ่งค่าจากนิพจน์ภายใน ซึ่งไม่สำคัญว่า "1" จะเป็นคอลัมน์ทั้งหมดหรือตาราง โดยพื้นฐานแล้วข้อมูลที่ส่งคืนจะไม่ถูกใช้ในทางใดทางหนึ่ง ดังนั้น ในการบีบอัดการรับส่งข้อมูลระหว่างการส่งข้อมูล การใช้ "1" จึงมีเหตุผลมากกว่า ดังที่แสดงด้านล่าง:

หากมีอยู่ (เลือก 1 จาก sysobjects
โดยที่ชื่อ = "MyTable" และพิมพ์ = "U")

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

เริ่มลอง
--รหัส
สิ้นสุดการลอง
เริ่มจับ
--ข้อผิดพลาดในการจับรหัส
จบการจับ

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

ป.ล.
กระทู้แรกของผม อย่าตัดสินรุนแรงจนเกินไป

โพรซีเดอร์ที่เก็บไว้ของ 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 แต่การศึกษามีความจำเป็นสำหรับผู้ที่สร้างฐานข้อมูลที่น่าประทับใจ นอกจากนี้ยังมีความแตกต่างจำนวนมากที่อาจมีประโยชน์เมื่อศึกษาขั้นตอนการจัดเก็บ แต่นี่เป็นสิ่งจำเป็นสำหรับผู้ที่วางแผนจะมีส่วนร่วมในการเขียนโปรแกรมรวมถึงมืออาชีพด้วย

การประกาศขั้นตอน

สร้างขั้นตอน [({ใน|ออก|เข้า} [,…])]
[ชุดผลลัพธ์แบบไดนามิก ]
เริ่ม [อะตอมมิก]

จบ

คำหลัก
. ใน (อินพุต) – พารามิเตอร์อินพุต
. OUT (เอาต์พุต) – พารามิเตอร์เอาต์พุต
. INOUT – อินพุตและเอาต์พุต รวมถึงฟิลด์ (ไม่มีพารามิเตอร์)
. ชุดผลลัพธ์แบบไดนามิกบ่งชี้ว่าขั้นตอนสามารถเปิดเคอร์เซอร์ตามจำนวนที่ระบุซึ่งจะยังคงเปิดอยู่หลังจากที่ขั้นตอนกลับมา

หมายเหตุ
ไม่แนะนำให้ใช้พารามิเตอร์จำนวนมากในขั้นตอนการจัดเก็บ (โดยหลักแล้วจะมีตัวเลขและสตริงอักขระจำนวนมาก) เนื่องจากเครือข่ายและสแต็กโอเวอร์โหลด ในทางปฏิบัติ ภาษาถิ่นที่มีอยู่ของ Transact-SQL, PL/SQL และ Informix มีความแตกต่างอย่างมีนัยสำคัญจากมาตรฐาน ทั้งในการประกาศและการใช้พารามิเตอร์ ในการประกาศตัวแปร และการเรียกรูทีนย่อย Microsoft ขอแนะนำให้ใช้การประมาณต่อไปนี้เพื่อประเมินขนาดแคชของกระบวนงานที่เก็บไว้:
=(จำนวนผู้ใช้พร้อมกันสูงสุด)*(ขนาดของแผนการดำเนินการที่ใหญ่ที่สุด)*1.25 การกำหนดขนาดของแผนปฏิบัติการในหน้าต่างๆ สามารถทำได้โดยใช้คำสั่ง: DBCC MEMUSAGE

การเรียกขั้นตอน

ใน DBMS ที่มีอยู่จำนวนมาก กระบวนการจัดเก็บจะถูกเรียกโดยใช้ตัวดำเนินการ:

ขั้นตอนดำเนินการ [(][)]

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

ตัวอย่างการประกาศขั้นตอน

สร้างขั้นตอน Proc1 AS // ประกาศขั้นตอน
ประกาศเคอร์เซอร์ Cur1 สำหรับชื่อที่เลือก เมืองจากพนักงานขาย โดยที่เรตติ้ง>200 // ประกาศเคอร์เซอร์
OPEN Cur1 //เปิดเคอร์เซอร์
FETCH NEXT FROM Cur1 // อ่านข้อมูลจากเคอร์เซอร์
ในขณะที่ @@Fetch_Status=0
เริ่ม
ดึงข้อมูลถัดไปจาก Cur1
จบ
ปิด Cur1 // ปิดเคอร์เซอร์
จัดสรร Cur1
ดำเนินการ Proc1 // เรียกใช้โพรซีเดอร์

ความแตกต่าง
สามารถสร้างรูทีนย่อยสองรูทีนที่มีชื่อเดียวกันได้ในสคีมาเดียวกัน หากพารามิเตอร์ของรูทีนย่อยทั้งสองมีความแตกต่างกันเพียงพอที่จะแยกความแตกต่างได้ หากต้องการแยกความแตกต่างระหว่างสองรูทีนที่มีชื่อเดียวกันในสคีมาเดียวกัน แต่ละรูทีนจะได้รับชื่อทางเลือกและไม่ซ้ำกัน (ชื่อเฉพาะ) ชื่อดังกล่าวอาจถูกระบุอย่างชัดเจนเมื่อมีการกำหนดรูทีนย่อย เมื่อเรียกรูทีนย่อยที่มีชื่อเหมือนกันหลายชื่อ การกำหนดรูทีนย่อยที่ต้องการจะดำเนินการในหลายขั้นตอน:
. เริ่มแรก ขั้นตอนทั้งหมดที่มีชื่อที่ระบุจะถูกกำหนดไว้ และหากไม่มี ฟังก์ชันทั้งหมดที่มีชื่อที่กำหนดก็จะถูกกำหนดไว้
. เพื่อการวิเคราะห์เพิ่มเติม เฉพาะรูทีนย่อยที่เกี่ยวข้องเท่านั้น ผู้ใช้รายนี้มีสิทธิดำเนินการ (EXECUTE)
. สำหรับพวกเขาจะมีการเลือกจำนวนพารามิเตอร์ที่สอดคล้องกับจำนวนอาร์กิวเมนต์การโทร มีการตรวจสอบประเภทข้อมูลที่ระบุของพารามิเตอร์และตำแหน่ง
. หากมีรูทีนย่อยเหลืออยู่มากกว่าหนึ่งรูทีน จะมีการเลือกรูทีนย่อยที่มีชื่อที่สั้นกว่า
ในทางปฏิบัติ ใน Oracle polymorphism รองรับฟังก์ชันที่ประกาศในแพ็คเกจเท่านั้น DB@ - ในสคีมาที่แตกต่างกัน และใน Sybase และ MS SQL Server ห้ามโอเวอร์โหลด

การลบและการเปลี่ยนแปลงขั้นตอน
หากต้องการลบขั้นตอน ให้ใช้ตัวดำเนินการ:

หากต้องการเปลี่ยนขั้นตอน ให้ใช้ตัวดำเนินการ:

เปลี่ยนแปลงขั้นตอน [([{ใน|ออก|เข้า}])]
เริ่ม [อะตอมมิก]

จบ

สิทธิพิเศษในการดำเนินการตามขั้นตอน

ให้สิทธิ์ดำเนินการ ถึง |สาธารณะ [ด้วยตัวเลือกการให้ทุน]

ขั้นตอนของระบบ
DBMS จำนวนมาก (รวมถึง SQL Server) มีชุดขั้นตอนการจัดเก็บระบบในตัวเฉพาะที่คุณสามารถใช้เพื่อวัตถุประสงค์ของคุณเอง