ทริกเกอร์ sql เป็นขั้นตอนการจัดเก็บชนิดพิเศษที่เซิร์ฟเวอร์ดำเนินการโดยอัตโนมัติเมื่อข้อมูล (DML) ในตารางเชื่อมโยงกับการเปลี่ยนแปลง ทริกเกอร์เชื่อมต่อกับตารางเฉพาะ การเปลี่ยนแปลงข้อมูลทั้งหมดที่กระทำโดยทริกเกอร์จะถือเป็นธุรกรรมเดียว
ต่างจากขั้นตอน/ฟังก์ชันที่เก็บไว้ทั่วไป ทริกเกอร์จะถูกเรียกโดยเซิร์ฟเวอร์โดยปริยายเมื่อมีเหตุการณ์ทริกเกอร์เฉพาะเกิดขึ้น นอกจากนี้ ทริกเกอร์ SQL ไม่มีอาร์กิวเมนต์ งานต่อไปนี้ได้รับการแก้ไขโดยใช้ทริกเกอร์:
- การตรวจสอบความถูกต้องของข้อมูลที่มีการเปลี่ยนแปลง และตรวจสอบข้อจำกัดด้านความสมบูรณ์ของข้อมูลที่ซับซ้อนซึ่งจำเป็นต้องได้รับการดูแล
- การสะสม ข้อมูลทางสถิติโดยการบันทึกข้อมูลเกี่ยวกับการเปลี่ยนแปลงที่เกิดขึ้น
- การสนับสนุนการจำลองแบบ
การใช้ข้อจำกัดด้านความสมบูรณ์ กำหนดกฎเกณฑ์และค่าต่างๆ ทำให้ไม่สามารถบรรลุระดับความสมบูรณ์ของข้อมูลที่ต้องการได้เสมอไป บางครั้งคุณจำเป็นต้องดำเนินการ อัลกอริธึมที่ซับซ้อนการตรวจสอบข้อมูลเพื่อให้มั่นใจถึงความน่าเชื่อถือและความเป็นจริง นอกจากนี้มักจำเป็นต้องติดตามการเปลี่ยนแปลงค่าตารางเพื่อให้สามารถแก้ไขข้อมูลที่เกี่ยวข้องได้ตามต้องการ ทริกเกอร์ SQLถือได้ว่าเป็นตัวกรองประเภทหนึ่งที่มีผลใช้บังคับหลังจากการดำเนินการทั้งหมดเสร็จสิ้นตามกฎเกณฑ์ ค่ามาตรฐาน ฯลฯ
แอปพลิเคชัน ทริกเกอร์ SQLเกี่ยวข้องกับต้นทุนทรัพยากรเซิร์ฟเวอร์เพิ่มเติมสำหรับการเพิ่มการดำเนินการ ( ทริกเกอร์แทรก) การอัปเดต ( อัปเดตทริกเกอร์) หรือการลบ ( ทริกเกอร์ลบ) ข้อมูลในตาราง
เมื่อสามารถบรรลุผลลัพธ์เดียวกันได้โดยใช้ขั้นตอนการจัดเก็บหรือโปรแกรมแอปพลิเคชัน การใช้ทริกเกอร์จะไม่สามารถทำได้จริง
สร้างทริกเกอร์
รูปแบบพื้นฐานของคำสั่ง CREATE TRIGGER แสดงอยู่ด้านล่าง:สร้างทริกเกอร์ trigger_name [ ก่อน | หลังจาก ] บน table_name เริ่มต้น
ช่วงเวลาที่ทริกเกอร์เริ่มต้นจะถูกกำหนดโดยคำหลัก ก่อน(ทริกเกอร์เริ่มทำงานก่อนที่จะดำเนินการเหตุการณ์ที่เกี่ยวข้องกับทริกเกอร์ เช่น ก่อนที่จะเพิ่มบันทึก) หรือ หลังจาก(หลังเหตุการณ์) หากมีการเรียกทริกเกอร์ก่อนเหตุการณ์ ทริกเกอร์จะสามารถทำการเปลี่ยนแปลงบันทึกที่แก้ไขโดยเหตุการณ์ได้ เว้นแต่เหตุการณ์จะเป็นการลบบันทึก DBMS บางตัวกำหนดข้อจำกัดเกี่ยวกับคำสั่งที่สามารถใช้ในทริกเกอร์ได้ (เช่น อาจไม่ได้รับอนุญาตให้ทำการเปลี่ยนแปลงในตารางที่ทริกเกอร์ "เชื่อมโยง" เป็นต้น)
ทริกเกอร์สามารถเชื่อมต่อไม่ได้กับตาราง แต่เชื่อมต่อกับมุมมอง ดู- ในกรณีนี้มีการใช้กลไก "มุมมองที่อัปเดตได้" ด้วยความช่วยเหลือ เมื่อแนบทริกเกอร์เข้ากับมุมมอง คำหลัก ก่อนและ หลังจากส่งผลกระทบเฉพาะลำดับของการเรียกทริกเกอร์ เนื่องจากเหตุการณ์จริง (การลบ การแทรก หรือการอัปเดต) จะไม่เกิดขึ้น
สามารถเรียกทริกเกอร์ได้สำหรับแต่ละบรรทัด ( สำหรับแต่ละแถว) ครอบคลุมตามเหตุการณ์ที่กำหนด หรือเพียงครั้งเดียวสำหรับแต่ละเหตุการณ์ ( สำหรับแต่ละแถลงการณ์).
การกำหนด<список_псевдонимов>หมายถึงส่วนประกอบต่างๆ เช่น แถวเก่าหรือใหม่ (OLD / NEW) หรือตารางเก่าหรือใหม่ (OLD TABLE / NEW TABLE) ค่าเก่าใช้ไม่ได้กับเหตุการณ์การแทรก และค่าใหม่ใช้ไม่ได้กับเหตุการณ์การลบ
ข้อได้เปรียบหลักของทริกเกอร์ก็คือ คุณสมบัติมาตรฐานจะถูกบันทึกไว้ในฐานข้อมูลและเปิดใช้งานทุกครั้งที่มีการอัพเดต ซึ่งช่วยให้แอปพลิเคชันต่างๆ ง่ายขึ้นอย่างเห็นได้ชัด
ทริกเกอร์ที่เขียนไม่ถูกต้องอาจนำไปสู่ ปัญหาร้ายแรงเกี่ยวข้องกับลักษณะของการอุดตัน ทริกเกอร์สามารถบล็อกทรัพยากรได้เป็นระยะเวลานาน ดังนั้นควรให้ความสนใจเป็นพิเศษเพื่อลดความขัดแย้งในการเข้าถึงให้เหลือน้อยที่สุด
ทริกเกอร์ MS SQL
ไวยากรณ์สำหรับการสร้างทริกเกอร์ใน MS SQL DBMS มีดังนี้:
สร้างทริกเกอร์ trigger_name ON (พร้อมการเข้ารหัส) [ [,] [,] ] [ พร้อมผนวก ] [ ไม่ใช่สำหรับการจำลอง ] AS ( sql_statement )
สคีมา_ชื่อ
ชื่อของวงจรทริกเกอร์ DML ทริกเกอร์ DML ถูกจำกัดไว้ที่ขอบเขตสคีมาของตารางหรือมุมมองที่สร้างขึ้น ไม่สามารถระบุ schema_name สำหรับทริกเกอร์ DDL หรือทริกเกอร์การเข้าสู่ระบบได้
trigger_name
ชื่อทริกเกอร์ อาร์กิวเมนต์ trigger_name ต้องเป็นไปตามกฎสำหรับตัวระบุ ยกเว้นว่า trigger_name ไม่สามารถเริ่มต้นด้วยอักขระ # หรือ ##
table_name | view_name
ตารางหรือมุมมองที่มีการแนบทริกเกอร์
ตัวอย่างทริกเกอร์ ms sql
หากต้องการใช้ทริกเกอร์ จะมีการสร้างตาราง 2 ตาราง ได้แก่ test_table, test_log ทริกเกอร์จะเชื่อมต่อกับตาราง test_table เมื่ออัปเดตบันทึกในตาราง test_table ทริกเกอร์จะบันทึกผลลัพธ์ของการเปลี่ยนแปลงในตาราง test_log เหล่านั้น. ทริกเกอร์จะถูกเรียกในเหตุการณ์การอัปเดต
ตารางทดสอบ test_table:
สร้างตาราง dbo.test_table (id int ไม่ใช่ null, field1 varchar(255) null, field2 varchar(255) null, ข้อ จำกัด pkTestTableID คีย์หลัก(รหัส));
ตารางการบันทึก Test_log:
สร้างตาราง dbo.test_log (id bigint identity(1,1) ไม่ใช่ null, table_name varchar(50) ไม่ใช่ null, oper varchar(15) ไม่ใช่ null, record_old xml null, record_new xml null, ข้อมูล datetime null, ข้อ จำกัด คีย์หลัก pkTestLogID ( รหัส));
ทริกเกอร์การอัปเดตข้อมูล:
การอัปเดตทริกเกอร์สร้างทริกเกอร์ dbo.trg_test_table_update บน dbo.test_table สำหรับ UPDATE เมื่อเริ่มต้นตั้งค่า nocount บน - ตัวแปรสำหรับการจัดเก็บข้อมูลเก่าและข้อมูลใหม่ประกาศ @record_new xml;
ประกาศ @record_old xml;
-- ตารางที่ถูกลบจะเก็บชุดข้อมูลเก่า/ที่ถูกลบ @record_old = (SELECT * FROM ถูกลบสำหรับ XML RAW, TYPE);
-- ตารางที่แทรกจะเก็บชุดข้อมูลที่เปลี่ยนแปลง (เพิ่งสร้าง) @record_new = (SELECT * FROM แทรกสำหรับ XML RAW, TYPE);
ถ้า (@record_new ไม่ใช่ null) และ (@record_old ไม่ใช่ null) ให้เริ่มต้นการแทรกลงใน dbo.test_log (table_name, oper, record_old, record_new, data) ค่า ("test_table", "update", @record_old, @record_new , GETDATE ())สิ้นสุด; จบ;
มาเพิ่มแถวสองสามแถวลงในตารางทดสอบ ซึ่งเราจะอัปเดตเพื่อทดสอบทริกเกอร์:
แทรกลงในค่า dbo.test_table (id, field1, field2) (1, "กาแฟ", "เนสกาแฟ"); แทรกลงในค่า dbo.test_table (id, field1, field2) (2, "Tea" , "Greenfield");
เราตรวจสอบการทำงานของทริกเกอร์โดยอัปเดตแถว:
ตรวจสอบตารางการบันทึก test_log ผลลัพธ์ควรมีลักษณะเหมือนที่แสดงในภาพหน้าจอ:
ข้อมูล XML ได้รับการตรวจสอบและแสดงให้เห็นว่าตารางการบันทึกมีทั้งค่าเก่าและใหม่
ทริกเกอร์ PostgreSQL
ไวยากรณ์สำหรับการสร้างทริกเกอร์ สร้างทริกเกอร์ trigger_name [ เหตุการณ์ [ หรือ เหตุการณ์ ]] บน table_name สำหรับแต่ละ ( ROW | STATEMENT ) ดำเนินการขั้นตอน function_name (อาร์กิวเมนต์)อาร์กิวเมนต์ระบุชื่อของทริกเกอร์ที่จะสร้าง หากจำเป็นสามารถระบุชื่อของโครงการได้ (ก่อน | หลัง)คีย์เวิร์ด BEFORE หมายความว่าเช่นนั้น
ทริกเกอร์ก่อน
และจะต้องดำเนินการฟังก์ชันก่อนที่จะดำเนินการเหตุการณ์ที่เกี่ยวข้อง คีย์เวิร์ด AFTER หมายความว่าเช่นนั้น
ทริกเกอร์หลังจากนั้น
และฟังก์ชันนี้จะถูกเรียกหลังจากการดำเนินการที่ทริกเกอร์เสร็จสิ้น
( กิจกรรม [ หรือ กิจกรรม... ] ) เหตุการณ์ต่อไปนี้ได้รับการสนับสนุนใน PostgreSQL เมื่อแสดงรายการหลายเหตุการณ์ คำสำคัญ OR จะถูกใช้เป็นตัวคั่นและกำหนดจำนวนการเรียกใช้ฟังก์ชันเมื่อมีเหตุการณ์ที่ระบุเกิดขึ้น การใช้ ROW หมายความว่ามีการเรียกใช้ฟังก์ชันสำหรับแต่ละแถวที่ถูกแก้ไข หากต้องเรียกใช้ฟังก์ชันเพียงครั้งเดียวสำหรับทั้งคำสั่ง คำสำคัญ STATEMENT จะถูกนำมาใช้
ดำเนินการขั้นตอน function_name
ชื่อของฟังก์ชันที่เรียกว่าพร้อมอาร์กิวเมนต์ ในทางปฏิบัติ อาร์กิวเมนต์จะไม่ถูกใช้เมื่อเรียกใช้ฟังก์ชันทริกเกอร์
ไวยากรณ์คำจำกัดความฟังก์ชันทริกเกอร์
สร้างฟังก์ชัน function_name () ส่งคืนทริกเกอร์ AS DECLARE -- การประกาศตัวแปร BEGIN -- ฟังก์ชันทริกเกอร์ END; ภาษา plpgsql;
ฟังก์ชันทริกเกอร์ใช้ตัวแปรพิเศษที่มีข้อมูลเกี่ยวกับทริกเกอร์ที่เริ่มทำงาน การใช้ตัวแปรเหล่านี้ ฟังก์ชั่นทริกเกอร์ทำงานร่วมกับข้อมูล รายการด้านล่างคือตัวแปรบางส่วนที่มีอยู่ในฟังก์ชันทริกเกอร์
| ชื่อ | พิมพ์ | คำอธิบาย |
|---|---|---|
| ใหม่ | บันทึก | ค่าฟิลด์ใหม่ของบันทึกที่สร้างโดยคำสั่ง INSERT หรือคำสั่ง UPDATE ที่อัปเดตเมื่อทริกเกอร์ระดับบันทึก (ROW) เริ่มทำงาน ตัวแปรใช้เพื่อแก้ไขบันทึกใหม่ ตัวแปร NEW ใช้ได้เฉพาะระหว่าง INSERT และ UPDATE เท่านั้น ฟิลด์ของระเบียนใหม่สามารถแก้ไขได้โดยทริกเกอร์ |
| เก่า | บันทึก | ค่าฟิลด์บันทึกเก่าที่มีอยู่ในบันทึกก่อนที่คำสั่ง DELETE หรือ UPDATE จะถูกดำเนินการเมื่อทริกเกอร์ระดับบันทึก (ROW) เริ่มทำงาน ตัวแปร OLD ใช้ได้เฉพาะกับ DELETE และ UPDATE เท่านั้น ฟิลด์บันทึกเก่าเป็นแบบอ่านอย่างเดียวและไม่สามารถแก้ไขได้ |
| ทีจี_NAME | ชื่อ | ชื่อของทริกเกอร์ที่ยิง |
| TG_WHEN | ข้อความ | คำสั่ง BEFORE หรือ AFTER ขึ้นอยู่กับว่าทริกเกอร์ที่ระบุในคำจำกัดความเริ่มทำงานเมื่อใด |
| TG_LEVEL | ข้อความ | สตริง ROW หรือ STATEMENT ขึ้นอยู่กับระดับทริกเกอร์ที่ระบุในคำจำกัดความ |
| TG_OP | ข้อความ | สตริง INSERT, UPDATE หรือ DELETE ขึ้นอยู่กับการดำเนินการที่ทริกเกอร์ |
| TG_RELID | ออยด์ | ตัวระบุวัตถุของตารางที่ทริกเกอร์เริ่มทำงาน |
| TG_RELNAME | ชื่อ | ชื่อของตารางที่ทริกเกอร์เริ่มทำงาน |
ไปยังแต่ละฟิลด์ของเรกคอร์ด ใหม่และ เก่าในขั้นตอนทริกเกอร์จะมีการจัดการดังนี้ NEW.names, OLD.rg
ตัวอย่างทริกเกอร์ PostgreSQL
นำไปใช้ในตัวอย่างนี้ ระบบที่เรียบง่ายการบันทึกผู้ใช้ จะตรวจสอบตารางผู้ใช้และบันทึกการเปลี่ยนแปลงทั้งหมดในตารางการบันทึก ตัวอย่างเช่น เราจะสร้างตารางแบบง่าย
ตารางผู้ใช้:
สร้างตาราง "public".users (id int ไม่ใช่ null ชื่อ varchar (64) ข้อ จำกัด คีย์หลัก pkUsersID (id));
ตารางการบันทึก
สร้างตาราง "public".logs (varchar ข้อความ (256) การประทับเวลาข้อมูลโดยไม่มีเขตเวลา)
ฟังก์ชั่นทริกเกอร์
สร้างหรือแทนที่ฟังก์ชัน "public".add_to_log() ส่งคืนทริกเกอร์เป็น $$ ประกาศ v_action varchar(30);
v_user วาร์ชาร์(64); v_retstr วาร์ชาร์(256); เริ่มต้น ถ้า TG_OP = "INSERT" จากนั้น v_user = NEW.name; v_action:= "เพิ่มผู้ใช้ใหม่"; v_retstr:= v_action || v_ผู้ใช้; INSERT INTO "public".logs(ข้อความ, ข้อมูล) ค่า (v_retstr, NOW()); TG_OPกลับมาใหม่;
ELSIF TG_OP = "อัปเดต" จากนั้น v_user = NEW.name; ใหม่และ เก่า v_action:= "อัปเดตผู้ใช้"; v_retstr:= v_action || v_ผู้ใช้; INSERT INTO "public".logs(ข้อความ, ข้อมูล) ค่า (v_retstr, NOW());
กลับมาใหม่;
ELSIF TG_OP = "ลบ" จากนั้น v_user = OLD.name;
v_action:= "ลบผู้ใช้";
v_retstr:= v_action || v_ผู้ใช้;
INSERT INTO "public".logs(ข้อความ, ข้อมูล) ค่า (v_retstr, NOW());
คืนความเก่า;
เอนดิฟ; จบ; $$ ภาษา plpgsql;
ฟังก์ชันทริกเกอร์ที่ไม่มีพารามิเตอร์อินพุตจะส่งคืนชนิดพิเศษ<список_псевдонимов>สำหรับแต่ละแถวเมื่อ (new.field_name > 0) ประกาศ -- ตัวแปร ค่าคงที่ เคอร์เซอร์ ฯลฯ เริ่มต้น -- สิ้นสุดบล็อก PL/SQL;
ข้อจำกัดทริกเกอร์ที่เป็นทางเลือกสามารถรวมไว้ในข้อความการสร้างทริกเกอร์โดยการกำหนดนิพจน์บูลีน SQL ในวลี เมื่อไร- นิพจน์ในส่วนคำสั่ง WHEN ได้รับการทดสอบสำหรับแต่ละแถวที่ได้รับผลกระทบจากทริกเกอร์ หากผลลัพธ์ของนิพจน์เป็น TRUE เนื้อหาของทริกเกอร์จะถูกดำเนินการ หากนิพจน์เป็น FALSE หรือ NULL เนื้อหาทริกเกอร์จะไม่ถูกดำเนินการ นิพจน์ในส่วนคำสั่ง WHEN ต้องเป็นนิพจน์ SQL ไม่ใช่นิพจน์ PL/SQL และไม่สามารถรวมแบบสอบถามย่อยได้
อ้างอิง
ตัวเลือกการอ้างอิงสามารถใช้ในส่วนเนื้อหาของทริกเกอร์เพื่อหลีกเลี่ยงความขัดแย้งระหว่างชื่อความสัมพันธ์และชื่อตารางในกรณีที่ตารางชื่อ "เก่า" หรือ "ใหม่" สถานการณ์นี้เกิดขึ้นไม่บ่อยนักและแทบไม่เคยใช้ตัวเลือกนี้เลย
เป็นตัวอย่าง พิจารณาตารางชื่อใหม่ คำจำกัดความถัดไป สร้างทริกเกอร์แสดงทริกเกอร์ที่เกี่ยวข้องกับตาราง ใหม่ซึ่งใช้ตัวเลือก อ้างอิงเพื่อหลีกเลี่ยงความขัดแย้งระหว่างชื่อความสัมพันธ์และชื่อตาราง:
ทริกเกอร์ก่อน CREATE TRIGGER trg_dummy ก่อนอัปเดตในการอ้างอิงใหม่ ใหม่เป็นใหม่ล่าสุดสำหรับแต่ละแถว BEGIN:newest.field2:= TO_CHAR (:newest.field1); จบ;
ผู้ดำเนินการ ใหม่เปลี่ยนชื่อเป็นตัวเลือกการใช้ใหม่ล่าสุด อ้างอิงแล้วนำไปใช้ในตัวไกปืน
ภาคแสดงแบบมีเงื่อนไข
หากทริกเกอร์สามารถดำเนินการได้ด้วยคำสั่ง DML มากกว่าหนึ่งประเภท (เช่น "INSERT OR DELETE OR UPDATE") คำสั่งนั้นก็สามารถนำมาใช้ในเนื้อความของทริกเกอร์ได้ การใส่, กำลังลบและ กำลังอัปเดตเพื่อรันโค้ดส่วนต่างๆ ขึ้นอยู่กับเงื่อนไข ในโค้ดภายในเนื้อหาทริกเกอร์ คุณสามารถใช้เงื่อนไขต่อไปนี้:
หากใส่แล้ว - - เอนดิฟ; หากอัปเดตแล้ว - - เอนดิฟ;
จะตรงตามเงื่อนไขแรกในกรณีที่ทริกเกอร์เริ่มทำงานเมื่อมีการแทรกแถวลงในตาราง เงื่อนไขที่สองจะเป็นไปตามเมื่อมีการอัปเดตแถวของตาราง
ในตัวดำเนินการ กำลังอัปเดตคุณสามารถใช้เงื่อนไขเพิ่มเติมเพื่อตรวจสอบชื่อของคอลัมน์ที่กำลังอัปเดตได้ ตามตัวอย่าง ให้พิจารณาโค้ดต่อไปนี้ โดยที่เนื้อหาจะถูกดำเนินการหากส่วนคำสั่ง UPDATE ที่ทำให้เกิดทริกเกอร์อัปเดตคอลัมน์ SAL:
หากอัปเดต ("SAL") แล้ว - - เอนดิฟ;
Oracle ทริกเกอร์ปิดการใช้งานเปิดใช้งาน
ใน ทริกเกอร์ของออราเคิลสามารถปิดได้ชั่วคราวหากเกิดเงื่อนไขข้อใดข้อหนึ่งต่อไปนี้:
- ไม่สามารถเข้าถึงวัตถุที่ทริกเกอร์เข้าถึงได้
- จำเป็นต้องโหลดข้อมูลจำนวนมากโดยไม่ต้องเรียกทริกเกอร์
- คุณต้องโหลดข้อมูลลงในตารางโดยไม่ต้องเรียกใช้ทริกเกอร์
ทริกเกอร์จะเปิดใช้งานตามค่าเริ่มต้นเมื่อถูกสร้างขึ้น หากต้องการปิดใช้งานทริกเกอร์ คุณต้องใช้คำสั่ง เปลี่ยนทริกเกอร์พร้อมตัวเลือก ปิดการใช้งาน- หากต้องการเปิดใช้งานทริกเกอร์ ให้ใช้คำสั่ง ALTER TRIGGER พร้อมตัวเลือก เปิดใช้งาน- คุณสามารถปิดการใช้งานทริกเกอร์ทั้งหมดที่เกี่ยวข้องกับตารางพร้อมกันได้โดยใช้คำสั่ง เปลี่ยนตารางพร้อมตัวเลือก ปิดการใช้งานทริกเกอร์ทั้งหมด.
ปิดการใช้งานทริกเกอร์ ALTER TRIGGER TRG_Orders_INS DISABLE; -- เชื่อมต่อทริกเกอร์ ALTER TRIGGER TRG_Orders_INS ENABLE; -- ปิดการใช้งานทริกเกอร์ตารางทั้งหมด แก้ไขคำสั่งตาราง ปิดการใช้งานทริกเกอร์ทั้งหมด;
หากต้องการเปิดใช้งานหรือปิดใช้งานทริกเกอร์โดยใช้คำสั่ง ALTER TABLE คุณต้องเป็นเจ้าของตารางหรือมีสิทธิ์ที่เหมาะสม
ตัวอย่างทริกเกอร์ของ Oracle
เครื่องกำเนิดลำดับ สร้างลำดับ seqID; -- ตารางผู้ใช้ สร้างผู้ใช้ตาราง (id int PRIMARY KEY ไม่ใช่ null ชื่อ varchar (50) โทรศัพท์ varchar (15) วันที่ dt); -- ทริกเกอร์แทรกระบุรหัสบันทึกที่สร้างหรือแทนที่ทริกเกอร์ trgAutonumber ก่อนที่จะแทรกผู้ใช้ -- ทริกเกอร์ก่อนสำหรับแต่ละแถวเริ่มต้นเลือก seqID.NEXTVAL เป็น: new.id จากคู่; จบ; -- ทริกเกอร์แทรกระบุวันที่บันทึก สร้างหรือแทนที่ทริกเกอร์ trgDate ก่อนที่จะแทรกบน ผู้ใช้ทริกเกอร์ก่อน สำหรับแต่ละแถวเริ่มต้น ถ้า: old.dt เป็นโมฆะ แล้ว: new.dt:= current_date;
สิ้นสุดถ้า; สิ้นสุด trgDate; ในตัวอย่างต่อไปนี้ ทริกเกอร์ trgDepartmentst_del_cascade ดำเนินการลบเรกคอร์ดแบบเรียงซ้อนทริกเกอร์ลบ CASCADE
- ทริกเกอร์ที่เชื่อมต่อกับตารางแผนกจะใช้การดำเนินการอ้างอิง DELETE CASCADE บนคีย์หลักของตาราง deptID:
ทริกเกอร์หลังจากสร้างหรือแทนที่ทริกเกอร์ trgDepartmentst_del_cascade หลังจากลบบนแผนกสำหรับแต่ละแถว BEGIN /* หลังจากลบแถวออกจากตาราง Departments แล้ว ให้ลบแถวทั้งหมดออกจากตาราง Employees ที่มีค่า deptID เหมือนกัน */ ลบออกจากพนักงาน โดยที่ Employee.deptID = :old.deptID; จบ; หมายเหตุ: โดยปกติจะเป็นรหัสสำหรับลบน้ำตก
รวมกับรหัสสำหรับ UPDATE SET NULL หรือ UPDATE SET DEFAULT เพื่อพิจารณาทั้งการอัปเดตและการลบในทริกเกอร์เดียว
การสร้างเครื่องกำเนิดไฟฟ้า
ตัวสร้างคือโปรแกรมที่จัดเก็บไว้ในฐานข้อมูลที่สร้างหมายเลขเฉพาะในแต่ละครั้งที่มีการเข้าถึง
การสร้างเครื่องกำเนิดไฟฟ้า:<Имя генератора>
สร้างเครื่องกำเนิดไฟฟ้า
ค่าเริ่มต้นระบุโดยคำสั่ง:<Имя генератора>ชุดเครื่องกำเนิดไฟฟ้า<Начальное значение (целое число)>
ถึง
สร้างเครื่องกำเนิดไฟฟ้า GenStore
ตั้งค่า GENERATOR GenStore เป็น 1
ตัวสร้างที่สร้างขึ้นนั้นเข้าถึงได้โดยใช้ฟังก์ชัน<Имя генератора>, <Шаг>)
ทริกเกอร์คือขั้นตอนที่อยู่บนเซิร์ฟเวอร์ฐานข้อมูลและจะถูกเรียกโดยอัตโนมัติเมื่อมีการแก้ไขบันทึกฐานข้อมูล เช่น เมื่อคอลัมน์มีการเปลี่ยนแปลงหรือเมื่อมีการลบหรือเพิ่ม ซึ่งแตกต่างจากขั้นตอนการจัดเก็บ ทริกเกอร์ไม่สามารถเรียกจากแอปพลิเคชันไคลเอ็นต์ และคุณไม่สามารถส่งพารามิเตอร์ไปยังทริกเกอร์หรือรับผลลัพธ์จากทริกเกอร์เหล่านั้นได้
การสร้างทริกเกอร์:
สร้างทริกเกอร์<>สำหรับ<>
(ก่อน | หลัง)
(อัปเดต | แทรก | ลบ)
เช่น<Тело триггера>
ตัวอธิบายที่ใช้งานอยู่ | INACTIVE กำหนดว่าทริกเกอร์ทำงานทันทีหลังจากสร้างขึ้นหรือไม่ ค่าเริ่มต้นคือ ใช้งานอยู่
ก่อนคำอธิบาย | AFTER ระบุช่วงเวลาที่ทริกเกอร์เริ่มทำงานก่อนหรือหลังการเกิดเหตุการณ์ที่เกี่ยวข้องซึ่งเกี่ยวข้องกับการเปลี่ยนแปลงบันทึก
คำอธิบาย UPDATE | แทรก | DELETE กำหนดว่าเหตุการณ์ใดที่ทริกเกอร์ทริกเกอร์ - เมื่อแก้ไข เพิ่ม หรือลบบันทึก
สำหรับเหตุการณ์หนึ่ง คุณสามารถสร้างทริกเกอร์ได้หลายตัว ซึ่งแต่ละทริกเกอร์จะถูกดำเนินการโดยอัตโนมัติ (หากอยู่ในสถานะใช้งานอยู่) หากมีทริกเกอร์หลายตัว ลำดับการเรียกใช้ (ดำเนินการ) จะถูกกำหนดโดยหมายเลขที่ระบุในตัวถูกดำเนินการ POSITION ทริกเกอร์จะดำเนินการตามลำดับจากน้อยไปมากของตัวเลขเหล่านี้
การลบทริกเกอร์:
ปล่อยทริกเกอร์<Имя триггера>
การเปลี่ยนแปลงทริกเกอร์:
ในการเข้าถึงค่าคอลัมน์ จะใช้คำแนะนำการจัดรูปแบบ:
เก่า.<Имя столбца>- หมายถึงค่าเก่า (ก่อนการเปลี่ยนแปลง) ของคอลัมน์
ใหม่.<Имя столбца>- อ้างถึงค่าใหม่ (หลังการเปลี่ยนแปลง) ของคอลัมน์
การสร้างทริกเกอร์เพื่อเพิ่มค่าที่ไม่ซ้ำให้กับคอลัมน์หลัก
สร้างที่เก็บตาราง
(S_Code จำนวนเต็มไม่เป็นโมฆะ
คีย์หลัก(S_Code));
ถึง
สร้างเครื่องกำเนิดไฟฟ้า GenStore
สร้าง TRIGGER CodeStore สำหรับร้านค้า
ใหม่.S_Code = GEN_ID(GenStore, 1);
เมื่อเพิ่มลงในตารางแล้ว เก็บใหม่บันทึก คอลัมน์คีย์ S_Code ของบันทึกนั้นจะได้รับการกำหนดค่าเฉพาะโดยอัตโนมัติ สามารถทำได้โดยการเรียก GEN_ID ไปยังตัวสร้าง GenStore
การดำเนินการลบเรคคอร์ดแบบเรียงซ้อนโดยใช้ทริกเกอร์
สร้างที่เก็บตาราง
(S_Code จำนวนเต็มไม่เป็นโมฆะ
คีย์หลัก(S_Code));
สร้างการ์ดตาราง
(C_Code จำนวนเต็มไม่เป็นโมฆะ
C_Code2 จำนวนเต็มไม่เป็นโมฆะ
คีย์หลัก (C_Code));
สร้างทริกเกอร์ DeleteStore สำหรับร้านค้า
ลบออกจากการ์ด โดยที่ Store.S_Code = Cards.C_Code2;
หลังจากลบรายการในตาราง Store รายการที่เกี่ยวข้องทั้งหมดในตารางการ์ดจะถูกลบโดยอัตโนมัติ
ความคิดเห็น: ตารางไม่ควรอยู่ภายใต้ข้อจำกัดความสมบูรณ์ของการอ้างอิงที่ตั้งไว้ที่เลเยอร์กายภาพ
อัปเดตคอลัมน์ลิงก์ ( คอลัมน์สำคัญ) ของตารางที่เชื่อมโยง ซึ่งประกอบด้วยความจริงที่ว่าเมื่อค่าของคอลัมน์ลิงก์ของตารางหลักเปลี่ยนแปลง ค่าของคอลัมน์ลิงก์ของบันทึกที่เกี่ยวข้องทั้งหมดของตารางรองจะเปลี่ยนไปตามนั้น
สร้าง TRIGGER ChangeStore สำหรับร้านค้า
ถ้า (OLD.S_Code<>ใหม่.S_Code)
จากนั้นอัปเดตการ์ด
SET C_Code2 = ใหม่.S_Code
โดยที่ C_Code2 = OLD.S_Code;
เมื่อคุณเปลี่ยนคอลัมน์ S_Code ที่ใช้เชื่อมโยงตารางหลักของ Store กับตารางย่อย Cards ค่าในคอลัมน์ลิงก์ C_Code2 ของบันทึกที่เกี่ยวข้องในตารางย่อยจะเปลี่ยนโดยอัตโนมัติ
เพื่อให้คอลัมน์ตารางหลักสามารถแก้ไขได้ จะต้องไม่สร้างคีย์สำหรับคอลัมน์นั้น
สิ่งกระตุ้นเป็นรูทีนย่อยที่คล้ายกับขั้นตอนฐานข้อมูล ซึ่งจะถูกเรียกโดยอัตโนมัติโดย DBMS เมื่อทำการเปลี่ยนแปลง ลบ หรือเพิ่มบันทึกในตาราง ไม่สามารถเข้าถึงทริกเกอร์จากโปรแกรม ส่งพารามิเตอร์ไปให้ หรือรับผลลัพธ์จากทริกเกอร์ได้ ส่วนใหญ่แล้วทริกเกอร์จะใช้เพื่อรักษาความสมบูรณ์ของการอ้างอิงและการดำเนินการแบบเรียงซ้อนในฐานข้อมูล ข้อมูลจำเพาะอ้างอิง ซึ่งกำหนดการดำเนินการลบและอัปเดตแบบเรียงซ้อนและสร้างขึ้นเมื่อมีการประกาศตาราง ก็ถูกนำมาใช้ผ่านทริกเกอร์เช่นกัน แต่ข้อความของทริกเกอร์เหล่านี้ไม่สามารถแก้ไขได้
วัตถุประสงค์ของทริกเกอร์
ป้องกันการเปลี่ยนแปลง (เช่น ป้องกันการเปลี่ยนแปลงใบแจ้งหนี้หลังจากส่งออกไปแล้ว)
- บันทึกการเปลี่ยนแปลง (เช่น เก็บสำเนาข้อมูลเก่า)
- ตรวจสอบการเปลี่ยนแปลง (เช่น เก็บบันทึกของผู้ใช้และบทบาทที่เกี่ยวข้องกับการเปลี่ยนแปลง)
- บันทึกการเปลี่ยนแปลง (เช่น ตรวจสอบให้แน่ใจว่าการเปลี่ยนแปลงทั้งหมดเป็นไปตามนาฬิกาของเซิร์ฟเวอร์ ไม่ใช่ของไคลเอ็นต์)
- การดำเนินการตามกฎเกณฑ์ทางธุรกิจ
- การจำลองข้อมูล (เช่น เก็บบันทึกการเปลี่ยนแปลงทั้งหมดที่จะถูกส่งไปยังฐานข้อมูลอื่นในเวอร์ชันที่ใหม่กว่า)
- ผลผลิตที่เพิ่มขึ้น (เช่น การอัปเดตยอดคงเหลือหลังจากรายละเอียดธุรกรรมแต่ละรายการ เพื่อเร่งการสืบค้น)
ประกาศทริกเกอร์
สร้างทริกเกอร์ {ก่อน|หลัง} {ลบ|แทรก|อัปเดต [ของ ]} บน อ้างอิง {เก่า {[แถว]|โต๊ะ [เช่น] } ใหม่ {แถว|ตาราง} [เช่น] }] [เหตุการณ์ต่อไปนี้ได้รับการสนับสนุนใน PostgreSQL เมื่อแสดงรายการหลายเหตุการณ์ คำสำคัญ OR จะถูกใช้เป็นตัวคั่น {แถลงการณ์|แถว [เมื่อไร ]}]
[เริ่มต้นอะตอม]
[จบ]
คำหลัก
. ก่อน|หลัง– เวลาเริ่มต้นทริกเกอร์ – ก่อน | หลังการดำเนินการอัพเดต
. ลบ|แทรก|อัปเดต= เหตุการณ์ทริกเกอร์
. สำหรับแต่ละแถว– สำหรับแต่ละบรรทัด (ทริกเกอร์บรรทัด จากนั้นเมื่อ)
. สำหรับแต่ละแถลงการณ์– สำหรับทั้งทีม (ถูกต้องตามค่าเริ่มต้น)
. อ้างอิง– อนุญาตให้คุณกำหนดนามแฝงได้สูงสุด 4 ชื่อให้กับ old และ | หรือขึ้นบรรทัดใหม่และ | หรือตารางที่สามารถเข้าถึงได้โดยทริกเกอร์
ข้อจำกัดของทริกเกอร์
เนื้อความของทริกเกอร์ต้องไม่มีข้อความต่อไปนี้:
- การกำหนด การลบ และการเปลี่ยนแปลงวัตถุฐานข้อมูล (ตาราง โดเมน ฯลฯ)
- การประมวลผลธุรกรรม (COMMIT, ROLLBACK)
- การเชื่อมต่อและการตัดการเชื่อมต่อไปยังฐานข้อมูล (CONNECT, DISCONNECT)
คุณสมบัติของแอพพลิเคชั่น
- ทริกเกอร์จะดำเนินการหลังจากใช้การตรวจสอบความสมบูรณ์อื่นๆ (ที่ประกาศ) ทั้งหมดแล้ว และมีประโยชน์เมื่อเกณฑ์การทดสอบค่อนข้างซับซ้อน หากการตรวจสอบที่ประกาศปฏิเสธการดำเนินการอัพเดต ทริกเกอร์จะไม่ถูกดำเนินการ ทริกเกอร์ทำงานในบริบทของธุรกรรม แต่ข้อจำกัด FK ไม่ได้ดำเนินการ
- หากทริกเกอร์ทำให้เกิดการเปลี่ยนแปลงเพิ่มเติมในตารางฐาน บ่อยครั้งสิ่งนี้จะไม่นำไปสู่การดำเนินการแบบเรียกซ้ำ แต่ควรชี้แจงให้ชัดเจน ในดีบีเอ็มเอส เซิร์ฟเวอร์ SQL 2005 จัดเตรียมความสามารถในการระบุการเรียกซ้ำได้มากถึง 255 ระดับโดยใช้คีย์เวิร์ด OPTION (MAXRECURSIV 3)
- โดยทั่วไปทริกเกอร์จะไม่ถูกดำเนินการเมื่อประมวลผลคอลัมน์ไบนารีขนาดใหญ่ (BLOB)
- ควรจำไว้ว่าเมื่อใดก็ตามที่ข้อมูลได้รับการอัปเดต DBMS จะสร้างสิ่งที่เรียกว่าตารางเสมือนทริกเกอร์โดยอัตโนมัติ ซึ่งใน DBMS ต่างๆ นั้น ชื่อที่แตกต่างกัน- ใน InterBase และ Oracle - สิ่งเหล่านี้ใหม่และเก่า ใน SQL Server - แทรกและลบแล้ว ยิ่งไปกว่านั้น เมื่อข้อมูลเปลี่ยนแปลง ทั้งสองก็จะถูกสร้างขึ้น ตารางเหล่านี้มีจำนวนคอลัมน์เท่ากัน โดยมีชื่อและโดเมนเดียวกันกับตารางที่กำลังอัปเดต SQL Server 2005 DBMS ให้ความสามารถในการระบุตาราง รวมถึงตารางชั่วคราว ที่ควรแทรกข้อมูลลงในโดยใช้คีย์เวิร์ด OUTPUT Inserted.ID,... INTO @
- ใน DBMS จำนวนหนึ่ง อนุญาตให้ประกาศทริกเกอร์สำหรับการดำเนินการหลายอย่างพร้อมกันได้ ในการใช้การตอบสนองที่แตกต่างกันต่อการดำเนินการต่างๆ Oracle จัดเตรียมเพรดิเคตการลบ การแทรก การอัปเดต ซึ่งจะคืนค่า True สำหรับประเภทการอัปเดตที่เกี่ยวข้อง
- ใน ออราเคิล DBMSคุณสามารถระบุรายการคอลัมน์สำหรับทริกเกอร์การอัปเดต (หลังการอัปเดต) ซึ่งจะทำให้แน่ใจได้ว่าทริกเกอร์จะถูกเรียกเฉพาะเมื่อค่าของคอลัมน์เหล่านี้เท่านั้นที่เปลี่ยนแปลง
- สามารถประกาศทริกเกอร์ได้หลายตัวสำหรับแต่ละเหตุการณ์ทริกเกอร์ (Oracle มี 12 ทริกเกอร์ต่อตาราง) และโดยปกติแล้วลำดับที่ทริกเกอร์จะเริ่มทำงานจะขึ้นอยู่กับลำดับที่สร้างขึ้น ใน DBMS บางตัว เช่น InterBase ลำดับการเริ่มต้นระบบจะถูกระบุโดยใช้คีย์เวิร์ดเพิ่มเติม POSITION โดยทั่วไป ควรดำเนินการทริกเกอร์สำหรับแต่ละคำสั่งก่อน จากนั้นจึงสำหรับแต่ละบรรทัด
- ทริกเกอร์สามารถฝังอยู่ภายในกันและกันได้ ดังนั้น SQL Server อนุญาตให้มีระดับการซ้อน 32 ระดับ (คุณสามารถใช้ตัวแปรส่วนกลาง @@NextLevel เพื่อกำหนดระดับการซ้อนได้)
ข้อเสียของทริกเกอร์
ความซับซ้อน การดำเนินการบางอย่างกับข้อมูลในฐานข้อมูลทำให้การออกแบบ การนำไปใช้ และการดูแลระบบมีความซับซ้อน
- ชิงทรัพย์ ฟังก์ชั่นจากผู้ใช้ เป็นการยากที่จะปรับปรุงแอปพลิเคชันให้ทันสมัยเมื่อคุณสมบัติบางอย่างถูกซ่อนอยู่
- ผลกระทบต่อประสิทธิภาพการทำงาน เมื่อมีทริกเกอร์จำนวนน้อย เวลาในการประมวลผลข้อมูลจะเพิ่มขึ้น
การแก้ไขและการลบทริกเกอร์
หากต้องการลบทริกเกอร์ ให้ใช้คำสั่ง DROP TRIGGER
- หากต้องการเปลี่ยนทริกเกอร์ ให้ใช้คำสั่ง ALTER TRIGGER...
- ปิดการใช้งานทริกเกอร์
ในบางกรณี เช่น ระหว่างการโหลดเป็นชุด จำเป็นต้องปิดใช้งานทริกเกอร์ DBMS จำนวนหนึ่งมีความสามารถที่สอดคล้องกัน ในออราเคิลและ SQL รหัสเซิร์ฟเวอร์คำว่า DISABLE|ENABLE ใน InterBase INACTIVE|ACTIVE ในคำสั่ง ALTER TRIGGER
คุณสมบัติของเซิร์ฟเวอร์อุตสาหกรรม
1) อินเตอร์เบส/ไฟร์เบิร์ด
สร้างทริกเกอร์ สำหรับ {ใช้งานอยู่ | ไม่ใช้งาน} {ก่อน|หลัง} {แทรก|ลบ|อัปเดต} [ตำแหน่ง ]
เช่น [ประกาศตัวแปร [()]]
เริ่ม
จบ
ตัวอย่าง:
สร้างทริกเกอร์ BF_Del_Cust สำหรับลูกค้า
ใช้งานก่อนที่จะลบตำแหน่ง 1 AS
เริ่ม
ลบออกจากคำสั่งซื้อโดยที่ Order.CNum=Customer.CNum;
จบ;
2) เซิร์ฟเวอร์ SQL
สร้างทริกเกอร์ บน [ด้วยการเข้ารหัส] {สำหรับ|หลัง|แทน} {แทรก|อัปเดต|ลบ}
เช่น
ใช้ B1;
ไป
สร้างทริกเกอร์ InUpCust1 บนลูกค้าหลังจากแทรก อัปเดต
AS RISEERROR('ตารางลูกค้ามีการเปลี่ยนแปลง');
ทริกเกอร์ประเภทเพิ่มเติม
Oracle และ SQL Server มอบความสามารถในการสร้าง (แทนที่) ทริกเกอร์สำหรับมุมมองที่ไม่ได้รับการอัพเดต เพื่อจุดประสงค์นี้ จึงมีการระบุคำหลัก INSTEAD OF:
สร้างทริกเกอร์แทนการแทรกเป็น ...
คุณสามารถตรวจสอบความพยายามของลูกค้าในการอัปเดตข้อมูลโดยใช้มุมมองและดำเนินการใดๆ จัดการมุมมองที่ไม่ได้รับการอัปเดต ฯลฯ
- SQL Server DBMS มีทริกเกอร์การย้อนกลับที่หยุดการกระทำทั้งหมดและแสดงข้อความ:
ทริกเกอร์ย้อนกลับ
สิ่งกระตุ้น (สิ่งกระตุ้น) เป็นขั้นตอนการจัดเก็บชนิดพิเศษที่ผู้ใช้ไม่ได้เรียกใช้โดยตรง และการดำเนินการนั้นมีเงื่อนไขตามการเกิดเหตุการณ์บางอย่าง (การกระทำ) โดยพื้นฐานแล้วจะเป็นการเพิ่ม INSERT หรือการลบแถว DELETE ในตารางที่กำหนด หรือการแก้ไข อัปเดตข้อมูลในคอลัมน์เฉพาะของตารางที่กำหนด ฐานสัมพันธ์ข้อมูล. ทริกเกอร์ใช้เพื่อรับรองความสมบูรณ์ของข้อมูลและใช้ตรรกะทางธุรกิจที่ซับซ้อน ทริกเกอร์จะเริ่มทำงานโดยอัตโนมัติโดยเซิร์ฟเวอร์เมื่อมีการพยายามเปลี่ยนแปลงข้อมูลในตารางที่เชื่อมโยงอยู่ การปรับเปลี่ยนข้อมูลทั้งหมดที่ทำขึ้นจะถือว่าดำเนินการในธุรกรรมซึ่งมีการดำเนินการที่ทำให้เกิดการทริกเกอร์ ดังนั้น หากตรวจพบข้อผิดพลาดหรือละเมิดความสมบูรณ์ของข้อมูล ธุรกรรมนี้อาจถูกย้อนกลับ
ทริกเกอร์จะถูกสร้างขึ้นแยกกันสำหรับแต่ละตารางและอยู่ใน Object Explorer ในโฟลเดอร์ "ทริกเกอร์" มาสร้างทริกเกอร์สำหรับตาราง "ครู" กันดีกว่า โฟลเดอร์ "Triggers" จะเป็นส่วนหนึ่งของตาราง "ครู":
มาสร้างทริกเกอร์ที่แสดงข้อความ “บันทึกเพิ่ม” เมื่อมีการเพิ่มบันทึกลงในตาราง มาสร้างทริกเกอร์ใหม่โดยคลิกขวาที่โฟลเดอร์ "ทริกเกอร์" ในตาราง "ครู" และเลือก "ทริกเกอร์ใหม่" จากเมนูที่ปรากฏขึ้น หน้าต่างต่อไปนี้พร้อมกับทริกเกอร์ใหม่จะปรากฏขึ้น:
ลองดูที่โครงสร้างของทริกเกอร์:
1) ขอบเขตของชื่อฟังก์ชัน (Trigger_Name)
2) พื้นที่ที่แสดงตารางที่กำลังสร้างทริกเกอร์ (Table_Name)
3) พื้นที่ที่แสดงเวลาที่จะดำเนินการทริกเกอร์ (INSERT - เมื่อสร้างบันทึกในตาราง DELETE - เมื่อลบและ UPDATE - เมื่อเปลี่ยนแปลง) และวิธีการดำเนินการ (ALTER - หลังจากดำเนินการดำเนินการ แทน - แทนที่จะดำเนินการ การดำเนินการ);
4) เนื้อความของทริกเกอร์ประกอบด้วยคำสั่งของภาษาการเขียนโปรแกรมแบบสอบถาม TSQL
ในหน้าต่างทริกเกอร์ใหม่ ให้ป้อนรหัส:
สร้างทริกเกอร์ tr_add
บน dbo.teachers
พิมพ์ "เพิ่มรายการใหม่"
จากรูป คุณจะเห็นว่าทริกเกอร์ “Add Indicator” ที่สร้างขึ้นถูกดำเนินการหลังจากเพิ่มบันทึก (หลังจากแทรก) ลงในตาราง “dbo.teachers” (ON dbo.teachers) หลังจากเพิ่มรายการแล้ว ทริกเกอร์จะแสดงข้อความ "เพิ่มรายการใหม่แล้ว" (พิมพ์ "เพิ่มรายการใหม่แล้ว") มารันโค้ดที่พิมพ์โดยคลิกที่ปุ่มบนแถบเครื่องมือ ข้อความ “คำสั่งเสร็จสมบูรณ์” จะปรากฏที่ด้านล่างของหน้าต่างโค้ด
มาดูกันว่าทริกเกอร์ใหม่ทำงานอย่างไร มาสร้างคำขอว่างใหม่และป้อนคำสั่งต่อไปนี้เพื่อเพิ่ม รายการใหม่ไปที่ตาราง “dbo.teachers”:
แทรกลงใน dbo.teachers
"ซิโดรอฟ"
มาดำเนินการคำสั่งที่พิมพ์โดยคลิกที่ปุ่มบนแถบเครื่องมือ ระเบียนใหม่จะถูกเพิ่มลงในตาราง และทริกเกอร์จะแสดงข้อความ "เพิ่มระเบียนใหม่"
ทริกเกอร์ที่มี UPDATE และ DELETE ถูกสร้างขึ้นในลักษณะเดียวกัน
การมอบหมาย: ตามด้วยธีมของคุณเอง สร้างในSQLเซิร์ฟเวอร์การจัดการสตูดิโอการแสดง (3-4)แบบสอบถาม (3-4), ขั้นตอนการจัดเก็บ (3-4), ฟังก์ชั่นที่ผู้ใช้กำหนด (3-4), ทริกเกอร์ (INSERT,อัปเดตและลบ- ใช้คำสั่งแบบมีเงื่อนไขและลูปเมื่อสร้างตัวดำเนินการ
ทริกเกอร์คือขั้นตอนที่จัดเก็บไว้ในเซิร์ฟเวอร์ในรูปแบบที่คอมไพล์ และดำเนินการโดยอัตโนมัติเมื่อมีเหตุการณ์การเพิ่ม แก้ไข หรือลบบันทึกเกิดขึ้น โดยไม่คำนึงถึงความต้องการของลูกค้า คุณไม่สามารถบังคับให้ทริกเกอร์ทำงานจากแอปพลิเคชันไคลเอนต์ได้ ไม่สามารถผ่านทริกเกอร์ได้ พารามิเตอร์อินพุตและรับพารามิเตอร์เอาต์พุตจากมัน
ทริกเกอร์ใช้งานได้เสมอ ปัจจุบันบันทึกและดำเนินการตามการกระทำเฉพาะ
ทริกเกอร์สามารถดำเนินการได้ก่อนที่เหตุการณ์จะเกิดขึ้น (parameter ก่อน)หรือหลังเกิดเหตุการณ์ (parameter หลังจาก).
ทริกเกอร์มีความโดดเด่นตามทิศทางของการกระทำ:
- แทรก -เพื่อเพิ่มรายการ;
- อัปเดต- เพื่อแก้ไขบันทึก;
- ลบ- เพื่อลบบันทึก
ทริกเกอร์ถูกสร้างขึ้นสำหรับตารางเฉพาะและเป็นของตารางนั้น หากตารางมีทริกเกอร์หลายตัวในทิศทางเดียวกัน เวลาตอบสนองจะถูกกำหนดโดยพารามิเตอร์เป็นหลัก ก่อนและ หลังจากและเมื่อไร ค่าเดียวกันพารามิเตอร์การเกิดเหตุการณ์ - พารามิเตอร์ ตำแหน่งระบุหมายเลข (ลำดับ) ของทริกเกอร์
เมื่อทำงานกับทริกเกอร์ โปรดจำไว้ว่า:
- เมื่อย้อนกลับธุรกรรม การเปลี่ยนแปลงทั้งหมดที่ทำโดยทริกเกอร์จะถูกย้อนกลับ
- การเปลี่ยนแปลงแบบเรียงซ้อนและการลบแบบเรียงซ้อนในตารางลูกนั้นสามารถนำไปใช้ได้อย่างง่ายดาย
- การเปลี่ยนแปลงที่ทำกับเนื้อความของทริกเกอร์จะทำงานโดยอัตโนมัติสำหรับแอปพลิเคชันไคลเอนต์แต่ละรายการ กล่าวคือ ไม่จำเป็นต้องสื่อสารการเปลี่ยนแปลงที่ทำกับผู้ใช้แต่ละคน
ทริกเกอร์ถูกสร้างขึ้นตามกฎสำหรับการสร้างขั้นตอนการจัดเก็บแม้ว่าจะมีคุณสมบัติพิเศษบางอย่างก็ตาม
กำลังสร้างทริกเกอร์
หากต้องการสร้างทริกเกอร์ ให้ใช้โอเปอเรเตอร์ สร้างทริกเกอร์
รูปแบบตัวดำเนินการ
สร้างทริกเกอร์ สำหรับ
[ คล่องแคล่ว | ไม่ได้ใช้งาน]
[ ก่อน|หลังจาก]
[แทรก | อัปเดต ลบ ]
[ ตำแหน่ง ]
วัตถุประสงค์ของตัวเลือก:
คล่องแคล่ว- ทริกเกอร์ทำงานอยู่ เช่น เมื่อเข้าถึงตารางที่ระบุ ขั้นตอนที่เขียนใน stele ทริกเกอร์จะถูกดำเนินการ
ไม่ได้ใช้งาน- ทริกเกอร์เป็นแบบพาสซีฟ เช่น ทริกเกอร์ถูกสร้างและเก็บไว้บนเซิร์ฟเวอร์ แต่เมื่อเข้าถึงตารางที่ระบุ องค์ประกอบทริกเกอร์> จะไม่ถูกดำเนินการ
ก่อน- ถึงการเกิดขึ้นของเหตุการณ์;
หลังจาก -กำหนดเวลาตอบสนอง หลังจากการเกิดขึ้นของเหตุการณ์;
แทรก -กำหนดทริกเกอร์เหตุการณ์การเพิ่มบันทึกลงในตาราง
อัปเดต -กำหนดเหตุการณ์การแก้ไขบันทึกในตารางสำหรับทริกเกอร์
ลบ -กำหนดทริกเกอร์เหตุการณ์การลบบันทึกออกจากตาราง
ตำแหน่ง -กำหนดหมายเลขทริกเกอร์ (ตำแหน่ง) ภายในเหตุการณ์ทริกเกอร์เฉพาะ (ก่อนหรือ หลังจาก).
เพื่ออธิบายขั้นตอนทริกเกอร์ จะมีการใช้ตัวดำเนินการและโครงสร้างเดียวกันกับที่ใช้ในการสร้างขั้นตอนการจัดเก็บ ส่วนหัวของทริกเกอร์จะกำหนดกิจกรรม เหตุการณ์การเริ่มทำงาน การดำเนินการที่ทริกเกอร์ตอบสนอง และตำแหน่งการเริ่มทำงานของทริกเกอร์ (ไม่บังคับ)
เมื่อเขียน trigger stele> คุณสามารถใช้คำหลักเพิ่มเติมได้ เก่า(ก่อนวันงาน) และ ใหม่(หลังงาน) ตามด้วยชื่อสนาม
เนื่องจากในฐานข้อมูลระยะไกล การเปลี่ยนแปลงทั้งหมดในตาราง (การเพิ่ม การแก้ไข และการลบบันทึก) จึงเกิดขึ้นในกลุ่มตัวอย่าง (ใน แรม) จากนั้น ตัวอย่างเช่น เมื่อเปลี่ยนค่าของฟิลด์ คุณสามารถเข้าถึงทั้งค่าของฟิลด์เก่า (ก่อนการเปลี่ยนแปลง) - ObO.fieldname> และค่าของฟิลด์ใหม่ (หลังการเปลี่ยนแปลง) - NEW-ชื่อฟิลด์ หากไม่มี มีการเปลี่ยนแปลงกับฟิลด์ที่ระบุ จากนั้นฟิลด์ ObO.chmb> จะเท่ากับฟิลด์ NEW.chmb
ตัวอย่างที่ 6.10กำลังสร้างทริกเกอร์
สร้างทริกเกอร์ T_COMPCODE สำหรับผู้แต่ง
ใช้งานก่อนแทรกตำแหน่ง 0
new.code_composer=gen_id(g_composers, 1); ถ้า (COMPOSERS.data เกิดไม่เป็นโมฆะ) ให้เริ่มต้น
new.actuallyage = (นักแสดง ("ตอนนี้" ณ วันที่) -COMPOSERS.data_born)/365; ถ้า (COMPOSERS.data วันไม่เป็นโมฆะ) ดังนั้น COM POSERS.age =(COMPOSERS.data_day-COMPOSERS.data เกิด) /365; อย่างอื่น new.age=null; จบ
ทริกเกอร์เริ่มทำงานก่อนเหตุการณ์เพิ่มบันทึกใหม่และคำนวณอายุของผู้แต่ง อายุที่คำนวณได้จะถูกเขียนลงในฟิลด์ "อันที่จริง_อายุ».
ทริกเกอร์การเปลี่ยนแปลง
หากต้องการเปลี่ยนทริกเกอร์ให้ใช้คำสั่ง เปลี่ยนทริกเกอร์ซึ่งมีรูปแบบและหลักการทำงานคล้ายคลึงกับคำสั่ง เปลี่ยนแปลงขั้นตอนเพื่อเปลี่ยนเนื้อความของกระบวนงานที่เก็บไว้
รูปแบบคำสั่ง
เปลี่ยนทริกเกอร์ สำหรับ [ คล่องแคล่วฉัน ไม่ได้ใช้งาน
ก่อนฉัน หลังจาก
แทรกฉัน อัปเดต ลบ
[ ตำแหน่ง 1
หลังจากดำเนินการตามคำสั่งแล้ว เปลี่ยนทริกเกอร์คำจำกัดความทริกเกอร์เก่าถูกแทนที่ด้วยคำจำกัดความใหม่ ไม่สามารถกู้คืนคำจำกัดความทริกเกอร์เก่าได้
ตัวอย่างที่ 6.11การแก้ไขทริกเกอร์
เปลี่ยนทริกเกอร์ T_COMPCODE สำหรับผู้แต่งที่ใช้งานอยู่ก่อนที่จะแทรกตำแหน่ง 5 เป็น
new.code_composer=gen_id(g_composers, 1); ถ้า (COMPOSERS.data_born ไม่ใช่ null) ให้เริ่มต้น
new.actually_age = (นักแสดง ("ตอนนี้" ณ วันที่)-COMPOSERS.data_born)/365; ถ้า (COM POSERS.dataday ไม่ใช่ null) ดังนั้น COM POSERS.age =
(COMPOSERS.data_day-COMPOSERS.data เกิด) /365; อย่างอื่น new.age=null; จบ
อย่างอื่นเริ่มต้น new.age=null; ใหม่.actually_age=null; สิ้นสุดสิ้นสุด
ทริกเกอร์ที่สร้างขึ้นในตัวอย่างที่ 6.10 ได้รับการแก้ไขเพื่อรวมตำแหน่งใหม่ ( ตำแหน่ง) การเปิดใช้งานทริกเกอร์ - 5
การถอดทริกเกอร์
หากต้องการลบทริกเกอร์ให้ใช้คำสั่ง
ตัวอย่างที่ 6.12การถอดทริกเกอร์
วางทริกเกอร์ T_COMPCODE
ทริกเกอร์ที่ถูกลบไม่สามารถกู้คืนได้
การใช้ทริกเกอร์ในการดำเนินการแบบเรียงซ้อน
ตามที่ระบุไว้ข้างต้น เอฟเฟกต์แบบเรียงซ้อนมีสองประเภท: การเปลี่ยนแปลงแบบเรียงซ้อนและการลบแบบเรียงซ้อน ดังนั้น สำหรับแต่ละตารางหลัก คุณจะต้องจัดเตรียมทริกเกอร์สองตัว: ตัวหนึ่งสำหรับการเปลี่ยนแปลงแบบเรียงซ้อน ตัวที่สองสำหรับการลบแบบเรียงซ้อน ในกรณีนี้ เงื่อนไข Referential Integrity จะต้องถูกลบออก
ตัวอย่างที่ 6.13การลบเรคคอร์ดแบบเรียงซ้อน
เมื่อลบนามสกุลออกจากตารางหลัก แกมจำเป็นต้องลบนามสกุลที่เกี่ยวข้อง (ตามคีย์นามสกุล)
li) ในตารางย่อยทั้งหมด (ในตารางตัวอย่าง ผู้เขียนและ หนังสือ).
สร้างทริกเกอร์ DEL FAM สำหรับ FAM ที่ใช้งานอยู่
ลบจากผู้เขียน
โดยที่ FAM.KEYFAM = ผู้แต่ง คีย์แฟม; ลบออกจากหนังสือ
โดยที่ FAM.KEY FAM = BOOK.KEY FAM;
ตัวอย่างที่ 6.14การแก้ไขบันทึกแบบเรียงซ้อน
เมื่อค่าของฟิลด์คีย์เปลี่ยนแปลง (คีย์แฟม)ในตารางหลัก แฟมคุณต้องเปลี่ยนค่าที่เกี่ยวข้อง กุญแจต่างประเทศในตารางย่อยทั้งหมด (ในตารางตัวอย่าง ผู้แต่ง และ หนังสือ)
สร้างทริกเกอร์ UPD FAM สำหรับ FAM ที่ใช้งานอยู่
ก่อนอัปเดตเป็น
ถ้า (OLD.KEYFAM ใหม่.KEY FAM) ให้เริ่มต้น
อัปเดตผู้เขียนตั้งค่า KEY FAM = NEW.KEY FAM
WHERE KEY FAM - OLD.KEY FAM; UPDATE ชุดหนังสือ KEYFAM - N EW. คีย์แฟม
โดยที่ KEY FAM = OLD.KEY FAM;
คุณสมบัติของการใช้เอฟเฟกต์น้ำตก:
- เมื่อธุรกรรมถูกย้อนกลับ การเปลี่ยนแปลงทั้งหมดที่กระทำโดยทริกเกอร์จะถูกส่งกลับไปยัง ค่าดั้งเดิม;
- ทริกเกอร์หนึ่งตัวสามารถเข้าถึงหลายตารางได้
- ทริกเกอร์สามารถเข้าถึงได้เท่านั้น ปัจจุบันรายการตาราง เช่น การย้ายไปยังรายการตารางอื่นเป็นสิ่งต้องห้าม
การรับรองความถูกต้องของข้อมูลโดยใช้ทริกเกอร์
เนื่องจากตารางหนึ่งสามารถมีทริกเกอร์ได้หลายรายการสำหรับเหตุการณ์เดียว (การเพิ่ม การแก้ไข หรือการลบบันทึก) จึงเป็นไปได้ที่จะมั่นใจในความน่าเชื่อถือของข้อมูลที่ป้อนลงในตาราง ในการสร้างทริกเกอร์เพื่อให้มั่นใจในความน่าเชื่อถือของข้อมูล จะมีการใช้โอเปอเรเตอร์และคำสำคัญเพิ่มเติม
ก. ตรวจสอบให้แน่ใจว่าค่าของฟิลด์ไม่ซ้ำกัน
ตามกฎแล้วเครื่องกำเนิดไฟฟ้าจะใช้เพื่อวัตถุประสงค์เหล่านี้ สำหรับการทำงานกับเครื่องกำเนิดไฟฟ้าดูย่อหน้าที่ 6.3 ตัวสร้างจะถูกสร้างขึ้นในขั้นแรก จากนั้นชื่อของตัวสร้างจะถูกระบุในส่วนเนื้อหาของทริกเกอร์
ตัวอย่างที่ 6.15กรอกข้อมูลในช่องคีย์หลัก
เขียนทริกเกอร์เพื่อเพิ่มค่าคีย์หลักที่ไม่ซ้ำ คีย์แฟม.เครื่องกำเนิดไฟฟ้า จีเอฟเอเอ็มได้ถูกสร้างขึ้นแล้ว
สร้างทริกเกอร์เพื่อสร้างกรอบให้กับครอบครัว
ใหม่. คีย์แฟม = GEN_ID(G_FAM, 1);
ตัวอย่างที่ 6.16กรอกข้อมูลในช่องข้อมูล
สร้างทริกเกอร์ TCOMPDATE สำหรับผู้แต่ง
ใช้งานก่อนอัปเดตตำแหน่ง 0
ถ้า (COMPOSERS.data เกิดไม่เป็นโมฆะ) ให้เริ่มต้น
new.actually_age = (นักแสดง ("ตอนนี้" AS
วันที่)-COMPOSERS.data_born)/365; ถ้า (วัน COMPOSERS.data ไม่เป็นโมฆะ) ดังนั้น COM POSERS.age =
(COM POSERS.data_day-COMPOSERS.data_born)/365; อย่างอื่น new.age=null; จบ
อย่างอื่นเริ่มต้น new.age=null; ใหม่.actually_age=null; จบ
ใน ในตัวอย่างนี้อายุของบุคคลนั้นจะถูกคำนวณและกรอกข้อมูลลงในฟิลด์ อายุจริงๆ
การบันทึกการตรวจสอบโดยใช้ทริกเกอร์
ในฐานข้อมูลระยะไกล การเก็บบันทึกการเปลี่ยนแปลงตารางฐานข้อมูลเพื่อระบุแหล่งที่มาของข้อมูลที่ไม่ถูกต้องถือเป็นเรื่องที่สนใจเป็นพิเศษ เมื่อเก็บบันทึกการเปลี่ยนแปลง ข้อมูลต่อไปนี้จะถูกบันทึกไว้ในตารางพิเศษ:
- ดำเนินการบนโต๊ะ
- ค่าฟิลด์ใหม่
- ค่าฟิลด์เก่า
- วันที่เปลี่ยนแปลง
- นามสกุล ชื่อ และนามสกุลของผู้ใช้ (ชื่อผู้ใช้);
- หมายเลขเวิร์กสเตชัน (ชื่อ)
ตัวอย่างที่ 6.17บันทึกการตรวจสอบเสร็จสิ้นโดยอัตโนมัติ
สร้างทริกเกอร์ AFTJNS_DOGS สำหรับสุนัขที่ใช้งานอยู่หลังจากแทรกตำแหน่ง 0 ตามที่เริ่มต้น
แทรกลงในค่าบันทึก (act, table_name,record_id) ("INSERT", "DOGS", DOGS. ID); จบ
สร้างทริกเกอร์ AFT_UPD_DOGS สำหรับสุนัขที่ใช้งานอยู่หลังจากอัปเดตตำแหน่ง 0 ตามที่เริ่มต้น
แทรกลงในค่าบันทึก (act, table_name, record_id) ('UPDATE', DOGS', DOGS.ID);
สร้างทริกเกอร์ AFT DEL DOGS สำหรับสุนัขที่ใช้งานอยู่หลังจากลบตำแหน่ง 0 AS
แทรกลงในค่าบันทึก (act,table_name,record_id) (’DELETE,”DOGS',DOGS.ID); จบ
ในตัวอย่างนี้สำหรับตาราง สุนัขมีการสร้างทริกเกอร์สามรายการ (หนึ่งรายการสำหรับแต่ละเหตุการณ์ แทรก อัปเดตและ ลบ).ทริกเกอร์แต่ละตัวจะเพิ่มลงในตารางการตรวจสอบ บันทึกหนึ่งบรรทัดที่มีฟิลด์ "ดำเนินการ", "ชื่อตาราง" และ "หมายเลขบันทึก" หากต้องการ คุณสามารถเพิ่มจำนวนฟิลด์ในตารางการตรวจสอบได้
