การสัมภาษณ์นักพัฒนา: การวิเคราะห์คำถามฐานข้อมูล

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

1. ฐานข้อมูลคืออะไร? พวกเขาแบ่งออกเป็นประเภทใดบ้าง?

DBMS หมายถึงอะไร?

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

ประเภทฐานข้อมูล

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

คุณสามารถอ่านเพิ่มเติมเกี่ยวกับฐานข้อมูลที่ไม่เกี่ยวข้องได้ในบทความนี้: คำ แนะนำเกี่ยวกับ NoSQL สำหรับนักพัฒนา ระบบจัดการฐานข้อมูล (DBMS)คือชุดของซอฟต์แวร์ที่ผู้ใช้สามารถสร้างฐานข้อมูล (DB) และดำเนินการต่างๆ กับฐานข้อมูลได้ เช่น เสริม อัปเดต ลบ เลือก ฯลฯ DBMS รับประกันความปลอดภัย ความสมบูรณ์ และความปลอดภัยของข้อมูล ที่เก็บข้อมูลและอนุญาตให้คุณให้สิทธิ์การเข้าถึงการบริหารฐานข้อมูล ตามตัวอย่าง MySql คือ DBMS ที่ให้การเข้าถึงฐานข้อมูลเชิงสัมพันธ์หรือ MongoDB สำหรับฐานข้อมูลที่ไม่เชิงสัมพันธ์

2. การทำให้เป็นมาตรฐานคืออะไร? ฟอร์มปกติ? การทำให้เป็นมาตรฐานมีกี่รูปแบบ? ตั้งชื่อสามตัวแรก

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

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

3. การทำให้เป็นปกติ

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

4. ดัชนี

ดัชนีคือชุดค่าที่จัดเรียงซึ่งเชื่อมโยงกับตารางหรือมุมมองด้วยคอลัมน์เฉพาะที่ช่วยเพิ่มความเร็วในการดึงข้อมูล นั่นคือนี่คือดัชนีประเภทหนึ่ง: เหมือนตัวอักษรในสมุดโทรศัพท์ที่ช่วยเราในการค้นหาด้วยนามสกุล หากใช้อย่างถูกต้อง คุณลักษณะนี้สามารถปรับปรุงประสิทธิภาพได้อย่างมากเมื่อทำงานกับฐานข้อมูลขนาดใหญ่ หรือจะลดได้มากก็ได้ เพื่อเร่งการค้นหา คีย์เหล่านี้จะถูกจัดเก็บไว้ในโครงสร้างต้นไม้ที่สมดุลซึ่งใช้ค้นหา ตามกฎแล้ว จะต้องป้อนดัชนีในช่องที่มีการค้นหาบ่อยที่สุด คุณควรคิดถึงการสร้างดัชนีไม่เร็วกว่าเมื่อคุณมีบันทึกอย่างน้อย 10,000 รายการ มิฉะนั้นคุณ จะไม่เห็นผลที่เห็นได้ชัดเจน เนื่องจากการเพิ่มประสิทธิภาพก่อนกำหนดคือEVIL และดัชนีจะส่งผลต่อประสิทธิภาพของระบบได้อย่างไร? เมื่อมีการแทรกข้อมูลใหม่หรือลบข้อมูลเก่า โครงสร้างต้นไม้ที่สมดุลจะถูกคำนวณใหม่ จริงๆ แล้ว ยิ่งมีข้อมูลและดัชนีมากเท่าไร ก็ยิ่งต้องนับต้นไม้มากขึ้นเท่านั้น ลองนึกภาพสถานการณ์: คุณมีบันทึกประมาณ 20,000 รายการและดัชนี 7 รายการในตารางนี้ นั่นคือเมื่อแทรกข้อมูล คุณต้องคำนวณต้นไม้ 7 ต้นใหม่ โดยแต่ละต้นมี 20,000 รายการ พูดอย่างเคร่งครัด ไม่แนะนำให้ใช้ดัชนีสำหรับตารางที่ข้อมูลจะถูกเพิ่ม/ลบบ่อยๆ เลย สุดท้ายนี้ ฉันอยากจะทราบว่าดัชนีสำหรับคอลัมน์ที่พบค่าบ่อยๆnullจะไม่มีประสิทธิภาพเท่าที่ควร ดังนั้นจึงไม่คุ้มที่จะเพิ่มลงในคอลัมน์ดังกล่าว

อะไรคือความแตกต่างระหว่างดัชนีแบบคลัสเตอร์และแบบไม่คลัสเตอร์ใน SQL?

เป็นกลุ่ม:

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

ไม่ใช่คลัสเตอร์:

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

การสร้างดัชนีที่ไม่ใช่คลัสเตอร์:

CREATE INDEX index_name ON table_name(column_name)

6. ดัชนีคอมโพสิตคืออะไร?

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

CREATE INDEX index_name ON table_name(first_column_name, second_column_name, third_column_name)

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

7. ดัชนีครอบคลุมคืออะไร? ดัชนีเฉพาะ?

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

CREATE UNIQUE INDEX index_name ON table_name(column_name)

8. คีย์หลักคืออะไร

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

CREATE TABLE table_name(
column_name int PRIMARY KEY,
…..)

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

ALTER TABLE table_name ADD PRIMARY KEY (column_name);

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

คีย์ต่างประเทศคืออะไร?

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

CREATE TABLE table_name{
column_name int,
…..
FOREIGN KEY(column_name) REFERENCES another_table_name(another_table_column_name) }

หลังจากสร้างตารางแล้ว:

ALTER TABLE table_name
ADD FOREIGN KEY(column_name) REFERENCES another_table_name(another_table_column_name));

คุณสามารถตั้งค่าลักษณะการทำงานของคีย์ภายนอกได้เมื่อจัดการฟิลด์ที่คีย์อ้างอิงถึง การจัดการอาจเป็นON DELETEประเภท ต่อไปนี้ ON UPDATE: ตัวเลือกพฤติกรรมที่เป็นไปได้:

• CASCADE— ด้วยคุณสมบัตินี้ แถวจากตารางที่ขึ้นต่อกันจะถูกลบหรือเปลี่ยนแปลงโดยอัตโนมัติเมื่อมีการลบหรือเปลี่ยนแปลงแถวที่เกี่ยวข้องในตารางหลัก
• SET NULL— ด้วยคุณสมบัตินี้ เมื่อแถวที่เกี่ยวข้องถูกลบหรืออัพเดตจากตารางหลัก ค่าNULLสำหรับคอลัมน์คีย์นอกจะถูกตั้งค่า
• NO ACTION— ปฏิเสธความพยายามที่จะลบหรือเปลี่ยนแถวในตารางหลักหากมีแถวที่เกี่ยวข้องกันในตารางที่ขึ้นต่อกัน
• RESTRICT- เทียบเท่ากับNO ACTION;
SET DEFAULT- ด้วยคุณสมบัตินี้ เมื่อแถวที่เกี่ยวข้องถูกลบหรืออัพเดตจากตารางหลัก ค่าเริ่มต้น (ถ้ามี) สำหรับคอลัมน์คีย์นอกจะถูกตั้งค่า

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

CREATE TABLE table_name{
column_name int,
…..
FOREIGN KEY(column_name) REFERENCES another_table_name(another_table_column_name) ON UPDATE CASCADE ON DELETE CASCADE }

ON DELETEหากพฤติกรรมสำหรับ และ ไม่ได้ตั้งค่าไว้อย่างชัดเจนON UPDATEพฤติกรรมนั้นจะถูกตั้งค่าRESTRICTเป็น

10. ประเภทของการเชื่อมต่อระหว่างตาราง (Join)

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

• INNER JOIN- การเชื่อมต่อที่แสดงเฉพาะข้อมูลเหล่านั้นจากตารางแรกที่สอดคล้องกับข้อมูลบางส่วนจากตารางที่สอง ที่เหลือก็ลงไป
• LEFT JOIN- การเชื่อมต่อที่แสดงข้อมูลทั้งหมดจากตารางแรกและข้อมูลที่เกี่ยวข้องจากตารางที่สอง ถ้ามี หากไม่มีข้อมูลที่เกี่ยวข้อง เขตข้อมูลจากตารางที่สองจะว่างเปล่า
• RIGHT JOIN- การเชื่อมต่อที่แสดงข้อมูลทั้งหมดจากตารางที่สองและข้อมูลที่เกี่ยวข้องจากตารางแรก ถ้ามี หากไม่มีข้อมูลที่เกี่ยวข้อง เขตข้อมูลจากตารางแรกจะว่างเปล่า
• FULL JOIN- การเชื่อมต่อที่แสดงข้อมูลทั้งหมดจากตารางแรกและตารางที่สอง หากไม่มีข้อมูลที่เกี่ยวข้องในตารางอื่น ช่องสำหรับข้อมูลนั้นจะว่างเปล่า
• CROSS JOIN- cross join โดยที่แต่ละแถวของตารางแรกถูกรวมเข้ากับแต่ละแถวของตารางที่สอง (แต่ละแถวต่อกัน) นั่นคือถ้าสองตารางมีแถวละ 3 แถว หลังจากการรวมนี้เราจะได้ผลลัพธ์เป็น 9 แถว

ตัวอย่างJoin(inner):

SELECT *
FROM first_table
INNER JOIN second_table ON first_table.some_column = second_table.some_column

11. คุณสมบัติกรดในฐานข้อมูลคืออะไร?

A - Atomicityช่วยให้มั่นใจได้ว่าไม่มีการทำธุรกรรมใด ๆ เกิดขึ้นกับระบบบางส่วน มีการดำเนินการย่อยทั้งหมดหรือไม่มีเลย ตัวอย่างเช่น การโอนเงินจากธนาคารไปยังบัญชีอื่นเกี่ยวข้องกับการดำเนินการสองอย่าง:

1. โอนเงินเข้าบัญชีธนาคาร
2. โอนเงินจากบัญชีธนาคารไปยังบัญชีเฉพาะ

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

12. ระดับการแยกธุรกรรม

แต่ละระดับการแยกอนุญาต/ห้ามการกระทำบางอย่าง (โอกาส):

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

เพื่อความสะดวก เราจะพิจารณาระดับการแยกและความสามารถในตาราง:

13. การแทรก SQL คืออะไร?

การแทรก SQLเป็นหนึ่งในวิธีการแฮ็กเว็บไซต์ โดยสาระสำคัญคือการแทรกโค้ด SQL บางส่วนลงในข้อมูลผ่านGETการสืบค้นPOSTหรือคุกกี้ หากเว็บไซต์ดำเนินการฉีดดังกล่าว จะสามารถเข้าถึงฐานข้อมูลและแฮ็กแอปพลิเคชันได้ เช่น เรารู้ชื่อของตัวแปรบางตัว สมมติว่ามีcolumn_nameประเภท booleanหากระบบไวต่อการฉีดเราสามารถเพิ่มOR column_name=trueแล้วเขียนทุกสิ่งที่เราต้องการจากฐานข้อมูล ORจะสร้างเงื่อนไข OR และนิพจน์ของเราหลังจากนั้นจะเป็นเสมอtrueซึ่งจะพาเราไปไกลกว่านั้น การโจมตีเว็บไซต์ เช่น การแทรก SQL เกิดขึ้นได้เนื่องจากการประมวลผลข้อมูลขาเข้าที่ใช้ในการสืบค้น SQL ที่ไม่เหมาะสม เมื่อเชื่อมต่อกับฐานข้อมูลโดยใช้JDBCคุณจะใช้ไฟล์Statements. เพื่อเพิ่มความปลอดภัย จำเป็นต้องใช้PreparedStatementแทนแบบปกติStatementเนื่องจากเมื่อใช้แล้วStatementสตริงการสืบค้นและค่าจะถูกรวมเข้าด้วยกัน ทำให้สามารถฉีดได้ ในทางกลับกันPreparedStatementจะมีเทมเพลตคำขอเฉพาะ และข้อมูลจะถูกแทรกลงในนั้นโดยแสดงเครื่องหมายคำพูด ด้วยเหตุนี้ การฉีด SQL จะถูกมองว่าเป็นเพียงการแสดงสตริงของบางฟิลด์เท่านั้น เพื่อป้องกันการแทรก SQL คุณสามารถใช้การตรวจสอบตามนิพจน์ทั่วไป (คุณสามารถอ่านเพิ่มเติมเกี่ยวกับนิพจน์ทั่วไปได้ในบทความนี้ ) อีกทางเลือกหนึ่งคือกำหนดขีดจำกัดจำนวนอักขระของพารามิเตอร์ขาเข้า: ตัวอย่างเช่น หากคุณควรได้รับตัวเลขไม่เกิน 9999 ก็ควรจำกัดจำนวนอักขระขาเข้าสี่ตัว จะช่วยลดความเสี่ยงของการแฮ็กโดยใช้การแทรก SQL คุณสามารถเรียนรู้เพิ่มเติมเกี่ยวกับความปลอดภัยใน Java ได้จากบทความ“ความปลอดภัยใน Java: แนวปฏิบัติที่ดีที่สุด”

14. ขั้นตอนการจัดเก็บมีอะไรบ้าง? ฟังก์ชั่นที่เก็บไว้? สิ่งกระตุ้น?

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

CREATE PROCEDURE procedure_name (first_param some_type, second_param some_type..)
 begin
……...
 end

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

CALL procedure_name (first_param, second_param…..);

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

CREATE FUNCTION function_name (first_param, second_param…..)
RETURNS some_type
 begin
……...
RETURN some_value;
end

การเรียกใช้ฟังก์ชันที่เก็บไว้:

SELECT function_name(first_param, second_param…..);

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

CREATE TRIGGER trigger_name
ON table_name
AFTER INSERT
 begin
……...
 end

15. ฝึกฝน

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