ทำความรู้จักกับ UDFs เครื่องทุ่นแรงในฐานข้อมูล
เวลาเราเขียนโปรแกรม เรามักจะเจอกับชุดคำสั่งเดิม ๆ ที่ต้องใช้ซ้ำบ่อยครั้ง ในโลกของฐานข้อมูลเราก็มีตัวช่วยที่เรียกว่า User-Defined Functions (UDFs) หรือฟังก์ชันที่ผู้ใช้สร้างขึ้นเอง เพื่อให้เราเขียนโค้ดได้สั้นลงและจัดการได้ง่ายขึ้นครับ
ลองนึกภาพว่าคุณต้องคำนวณภาษีจากราคาสินค้าในทุกตารางข้อมูล ถ้าไม่มีฟังก์ชัน คุณต้องเขียนสูตรคูณยาวเหยียดซ้ำไปซ้ำมาในทุกคำสั่ง Query (คำสั่งถามข้อมูลจากฐานข้อมูล) แต่ถ้าคุณสร้างฟังก์ชันเก็บไว้ คุณแค่เรียกชื่อฟังก์ชันนั้นขึ้นมาใช้ ผลลัพธ์ก็จะออกมาทันทีครับ
การใช้ UDFs ช่วยให้โค้ดของคุณสะอาดขึ้นมาก เมื่อต้องแก้ไขกฎการคำนวณ คุณก็แค่เข้าไปแก้ในฟังก์ชันที่เดียว ไม่ต้องไล่ตามแก้ทุกจุดในระบบ นี่คือทักษะสำคัญที่โปรแกรมเมอร์มืออาชีพต้องมี เพื่อลดความผิดพลาดและประหยัดเวลาในการพัฒนาซอฟต์แวร์ครับ
Scalar Functions: ฟังก์ชันที่ให้ผลลัพธ์เพียงค่าเดียว
Scalar Functions (ฟังก์ชันที่คืนค่ากลับมาเป็นค่าเดียว เช่น เลขหนึ่งตัว หรือข้อความหนึ่งประโยค) เป็นประเภทที่ง่ายที่สุดครับ มันทำงานเหมือนเครื่องคิดเลข คือเราส่งค่าเข้าไป แล้วมันก็คำนวณและส่งค่าเดียวกลับออกมาให้เราใช้งานต่อได้ทันที
เรามักใช้ฟังก์ชันประเภทนี้ในการแปลงข้อมูล หรือคำนวณอะไรที่เรียบง่าย เช่น การหาอายุจากวันเกิด หรือการแปลงชื่อให้เป็นตัวพิมพ์ใหญ่ทั้งหมด สิ่งสำคัญคือฟังก์ชันประเภทนี้จะคืนค่าได้แค่ค่าเดียวต่อการเรียกใช้งานหนึ่งครั้งเท่านั้นครับ
ข้อควรระวังคือ ถ้าเราเรียกใช้ Scalar Function ภายในคำสั่งที่ต้องดึงข้อมูลหลายล้านแถว อาจจะทำให้ฐานข้อมูลทำงานช้าลงได้ เพราะมันต้องวิ่งไปทำงานในฟังก์ชันนั้นซ้ำ ๆ ทุกแถวที่ดึงออกมา ดังนั้นควรใช้เมื่อจำเป็นและออกแบบให้เรียบง่ายที่สุดครับ
-- สร้างฟังก์ชันคำนวณภาษี 7%
CREATE FUNCTION dbo.CalculateTax (@Price DECIMAL(10,2))
RETURNS DECIMAL(10,2)
AS
BEGIN
RETURN @Price * 0.07 -- คืนค่าภาษีที่คำนวณได้
END
บรรทัดแรกคือคำสั่งสร้างฟังก์ชันชื่อ CalculateTax โดยรับค่าตัวเลข @Price เข้ามา บรรทัดถัดมาคือการบอกว่าผลลัพธ์ที่ได้จะเป็นเลขทศนิยม บรรทัดที่เหลือคือการคำนวณภาษีและส่งค่ากลับไปครับ
ผลลัพธ์ที่ได้คือเราสามารถใช้คำสั่ง SELECT dbo.CalculateTax(100) แล้วจะได้ผลลัพธ์เป็น 7.00 กลับมาทันทีครับ
Inline Table-Valued Functions: ทางเลือกที่รวดเร็วและยืดหยุ่น
ถ้า Scalar Function คือเครื่องคิดเลข Inline Table-Valued Functions (ฟังก์ชันที่คืนค่ากลับมาเป็นตารางข้อมูลโดยไม่มีขั้นตอนยุ่งยาก) ก็เหมือนกับแม่พิมพ์ที่ช่วยตัดข้อมูลออกมาเป็นชุด ๆ ให้เราเอาไปใช้งานต่อได้เลยครับ
ข้อดีของฟังก์ชันประเภทนี้คือมันทำงานได้เร็วมาก เพราะฐานข้อมูลจะมองคำสั่งข้างในฟังก์ชันเหมือนเป็นส่วนหนึ่งของคำสั่งหลักที่เราเขียนเลย ทำให้ตัวช่วยในการเพิ่มความเร็วของฐานข้อมูลทำงานได้เต็มที่ครับ
เรามักใช้มันเมื่อต้องการดึงข้อมูลที่ผ่านการกรองมาแล้ว เช่น ดึงรายการสินค้าที่ราคาแพงกว่าที่กำหนด หรือดึงรายชื่อพนักงานในแผนกที่ระบุ ซึ่งมันจะคืนค่าออกมาเป็นตารางที่มีหลายแถวหลายคอลัมน์เหมือนกับเราสั่ง SELECT ข้อมูลจากตารางจริง ๆ เลยครับ
-- สร้างฟังก์ชันดึงสินค้าที่ราคาแพงกว่าที่กำหนด
CREATE FUNCTION dbo.GetExpensiveProducts (@MinPrice DECIMAL(10,2))
RETURNS TABLE
AS
RETURN (
SELECT ProductID, ProductName, Price
FROM Products
WHERE Price > @MinPrice -- คัดกรองเฉพาะสินค้าที่ราคาถึงเกณฑ์
)
คำสั่งนี้สร้างฟังก์ชันที่รับค่า @MinPrice เข้ามา แล้วส่งผลลัพธ์เป็นตารางจากคำสั่ง SELECT ที่อยู่ด้านในครับ สังเกตว่าฟังก์ชันประเภทนี้ไม่มีคำสั่ง BEGIN หรือ END เพราะมันคือการส่งผลลัพธ์จากคำสั่งเดียวออกมาตรง ๆ ครับ
ผลลัพธ์ที่ได้คือเมื่อรัน SELECT * FROM dbo.GetExpensiveProducts(500) คุณจะได้ตารางรายชื่อสินค้าที่มีราคามากกว่า 500 บาทออกมาทันทีครับ
Multi-statement Table-Valued Functions: เมื่อต้องทำหลายขั้นตอน
บางครั้งการดึงข้อมูลไม่ได้ง่ายแค่บรรทัดเดียว แต่ต้องมีเงื่อนไขซับซ้อนหลายชั้น นี่คือหน้าที่ของ Multi-statement Table-Valued Functions (ฟังก์ชันที่คืนค่าเป็นตารางโดยผ่านหลายขั้นตอนการทำงาน) ซึ่งช่วยให้เราเขียนตรรกะที่ซับซ้อนได้ครับ
ฟังก์ชันประเภทนี้จะสร้างตารางชั่วคราวขึ้นมาในหน่วยความจำก่อน เราสามารถใช้คำสั่ง INSERT ข้อมูลเข้าไปในตารางนี้ทีละขั้นตอน หรือใช้ IF-ELSE เพื่อเลือกข้อมูลตามเงื่อนไขที่ซับซ้อน ก่อนจะส่งค่ากลับออกมาให้ผู้ใช้งานครับ
แม้จะยืดหยุ่นสูง แต่ก็แลกมาด้วยความเร็วที่อาจจะลดลงเมื่อเทียบกับแบบ Inline เพราะฐานข้อมูลต้องสร้างตารางชั่วคราวและจัดการข้อมูลหลายรอบ ดังนั้นให้ใช้เฉพาะตอนที่ฟังก์ชันแบบอื่นทำไม่ได้จริง ๆ เท่านั้นครับ
-- ฟังก์ชันที่มีขั้นตอนการทำงานหลายแบบ
CREATE FUNCTION dbo.GetFilteredReport (@Type INT)
RETURNS @ResultTable TABLE (ID INT, Info VARCHAR(100))
AS
BEGIN
IF @Type = 1 -- ถ้าเป็นประเภทที่ 1
INSERT INTO @ResultTable SELECT ID, Name FROM TableA
ELSE -- ถ้าเป็นประเภทอื่น
INSERT INTO @ResultTable SELECT ID, Description FROM TableB
RETURN -- ส่งค่าตารางที่กรอกข้อมูลเสร็จแล้วกลับไป
END
บรรทัดแรกกำหนดโครงสร้างตารางที่จะส่งกลับออกไป บรรทัดต่อมามีการใช้ IF เพื่อแยกการทำงานว่าจะไปดึงข้อมูลจากตารางไหน บรรทัดสุดท้ายคือการส่งตารางนั้นออกมาครับ
ผลลัพธ์คือเมื่อเรียกใช้ฟังก์ชันนี้ ระบบจะทำการตรวจสอบเงื่อนไขและเลือกข้อมูลที่ถูกต้องมาให้เราในรูปแบบตารางที่พร้อมใช้งานครับ
ข้อควรระวังที่มือใหม่มักพลาด
จุดที่มือใหม่มักพลาดคือการพยายามใส่คำสั่งที่เปลี่ยนข้อมูลในฐานข้อมูล เช่น INSERT, UPDATE หรือ DELETE ไว้ข้างในฟังก์ชัน ซึ่งฐานข้อมูลจะไม่อนุญาตให้ทำแบบนั้นครับ ฟังก์ชันต้องเป็นสิ่งที่ใช้ "อ่าน" ข้อมูลเท่านั้น
อีกเรื่องคือการตั้งชื่อฟังก์ชันครับ ควรตั้งชื่อให้สื่อความหมาย เช่น CalculateAge หรือ GetActiveUsers เพื่อให้คนในทีมอ่านโค้ดแล้วเข้าใจทันทีว่าฟังก์ชันนี้ทำหน้าที่อะไร โดยไม่ต้องเปิดไปดูโค้ดข้างในครับ
สุดท้ายคือเรื่องของ Performance (ประสิทธิภาพความเร็ว) อย่าลืมว่าการใช้ฟังก์ชันที่ซับซ้อนเกินไปในคำสั่งที่ดึงข้อมูลปริมาณมหาศาลจะทำให้โปรแกรมของคุณทำงานช้าลงอย่างเห็นได้ชัด ให้ทดสอบความเร็วทุกครั้งหลังจากสร้างฟังก์ชันใหม่ครับ ทดสอบก่อนใช้งานจริงเสมอ คือกฎทองของโปรแกรมเมอร์ครับ
สรุป: การนำไปใช้จริงในการทำงาน
การเข้าใจ UDFs จะช่วยให้คุณเขียนฐานข้อมูลได้เหมือนกับการเขียนโปรแกรมทั่วไป คือมีการแยกส่วนประกอบที่ใช้ซ้ำได้ออกไปเป็นฟังก์ชัน ทำให้โค้ดของคุณดูเป็นระเบียบและดูแลรักษาง่ายขึ้นมากครับ
ลองจินตนาการว่าในโปรเจกต์ทำระบบร้านค้าออนไลน์ คุณมีฟังก์ชัน dbo.FormatCurrency สำหรับแปลงตัวเลขให้เป็นรูปแบบเงินบาท หรือ dbo.GetStockStatus สำหรับตรวจสอบว่าสินค้าชิ้นไหนเหลือในสต็อกบ้าง คุณจะเรียกใช้ฟังก์ชันเหล่านี้ได้ทั้งในหน้าเว็บและรายงานสรุปยอดขายครับ
เมื่อคุณเริ่มสร้างฟังก์ชันเหล่านี้ได้ คุณจะพบว่าตัวเองเขียนโค้ดได้เร็วขึ้นและบั๊กน้อยลง เพราะทุกอย่างถูกทดสอบและเก็บไว้ในที่เดียว นี่คือขั้นตอนสำคัญในการเปลี่ยนจากคนที่เขียนโค้ดได้ ไปสู่คนที่เขียนโค้ดได้อย่างมีคุณภาพครับ
