ข้อดีของการใช้ตัวสร้างคิวรี SQL คืออะไร

มีข้อได้เปรียบอะไรบ้างในการใช้ตัวสร้างแบบสอบถามแทนที่จะใช้ SQL ดิบ?

เช่น

$q->select('*')
  ->from('posts')
  ->innerJoin('terms', 'post_id')
  ->where(...)

VS:

SELECT * FROM posts WHERE ...

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

นามธรรมของการเขียน SQL ผ่านกรอบที่ดีบทคัดย่อ

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

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

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

ผู้สร้างแบบสอบถามเป็นสัตว์เลี้ยงที่เกลียดชังฉันมากดังนั้นฉันจึงเขียน Framework ของฉันเอง (Apeel) เพื่อหลีกเลี่ยงการใช้มัน!

หากคุณใช้ PDO (ซึ่งฉันขอแนะนำให้คุณทำอย่างแน่นอน) ดังนั้นการจัดการอินพุตให้เป็นประโยชน์สำหรับคุณ

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

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

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

อย่างไรก็ตามนั่นเป็นเหตุผลว่าทำไมไม่ใช้อย่างใดอย่างหนึ่งบางคนรักพวกเขา

ในทางทฤษฎี? ใช่. Glenn Nelson ชี้ให้เห็นว่าพวกเขามักจะช่วยคุณได้อย่างไร (ถ้าเป็นตัวสร้างแบบสอบถามที่ดี)

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

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

ฉันคิดว่าประโยชน์ของการสร้างแบบสอบถามแบบวันต่อวันเป็นประโยชน์คือการนำโค้ดกลับมาใช้ใหม่และความสามารถในการปฏิบัติตามหลักการของ DRY

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

function joinTaskWithClient($queryBuilder) {
    $queryBuilder->join('task', 'contract', 'task.contract_id = contract.id')
                 ->join('contract', 'client', 'contract.client_id = client.id');
}

ดังนั้นการใช้งานจะเป็น:

$queryBuilder->select('client.name')
             ->from('client')
             ->where('task.id=:task')->setParameter('task', 42);
joinTaskWithClient($queryBuilder);

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

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

ฉันจะให้คำตอบตามไฟล์ readme ของตัวสร้าง SQL แบบกำหนดเองของฉัน ( Dialect )

(ตามด้วยข้อความธรรมดาลบการอ้างอิงเฉพาะไลบรารีออก)

ความต้องการ

1. รองรับผู้ค้าฐานข้อมูลหลายราย (เช่น MySQL, PostgreSQL, SQLite, MS SQL / SQL Server, Oracle, DB2, .. )
2. ขยายไปยังฐานข้อมูลใหม่ได้อย่างง่ายดาย (ผ่านการตั้งค่าแบบไม่ใช้งาน, การปรับใช้)
3. ความเป็นโมดุลและความสามารถในการถ่ายโอนได้อย่างอิสระ
4. API ที่ยืดหยุ่นและใช้งานง่าย

คุณสมบัติ

1. เทมเพลตที่ใช้ไวยากรณ์
2. การสนับสนุนมุมมองที่กำหนดเองนุ่ม
3. db abstraction, modularity และ transferability
4. แม่แบบที่เตรียมไว้
5. การหลบหนีข้อมูล

ฉันคิดว่าคุณสมบัติและข้อกำหนดข้างต้นแสดงเหตุผลที่จะใช้ตัวสร้างนามธรรมของ SQL

คุณสมบัติส่วนใหญ่ข้างต้นได้รับการสนับสนุนโดยผู้สร้าง SQL ส่วนใหญ่ (แม้ว่าฉันไม่คิดว่าทุกคนจะได้รับการสนับสนุนตามความรู้ของฉัน)

ตัวอย่างการใช้งาน:

1. แพลตฟอร์ม CMS สามารถทำงานได้ (โดยไม่มีการเปลี่ยนแปลงโค้ดพื้นฐาน) กับผู้ขาย DB หลายราย
2. รหัสแอปพลิเคชันที่กำหนดเองซึ่งผู้ขาย DB สามารถเปลี่ยนแปลงได้และ / หรือ schema ของ dB เป็นแบบไดนามิก (ซึ่งหมายความว่าแบบสอบถามจำนวนมากไม่สามารถกำหนดรหัสยาก แต่ยังคงต้องมีบทคัดย่อพอเพื่อให้รหัสมีความแข็งแกร่งต่อการเปลี่ยนแปลง)
3. การสร้างต้นแบบที่มีฐานข้อมูลอื่นมากกว่าที่ใช้ในการผลิต (จะต้องใช้รหัสฐานซ้ำกันอย่างน้อยสำหรับรหัสบางส่วน)
4. รหัสแอปพลิเคชันไม่แน่นหนาเข้ากับผู้ให้บริการฐานข้อมูลและ / หรือการนำไปใช้ (แม้จะอยู่ในผู้จำหน่ายฐานข้อมูลเดียวกันเช่นผู้จำหน่ายฐานข้อมูลรุ่นต่าง ๆ ) ดังนั้นจึงมีความแข็งแกร่งยืดหยุ่นและเป็นโมดูลมากกว่า
5. หลายกรณีปกติของแบบสอบถามและการหลบหนีข้อมูลได้รับการจัดการโดยกรอบงานของตัวเองและปกตินี้เป็นทั้งที่ดีที่สุดและเร็วขึ้น

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

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

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

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

ดูว่าฉันหมายถึงอะไร

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

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

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

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

อย่าเข้าใจฉันผิด

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

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

ฉันผิดที่คิดว่าการไม่เขียนข้อความค้นหาคุณไม่สามารถตรวจสอบความต้องการในการสร้างมุมมองที่แน่นอนได้หรือไม่?

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