TypeScript Academy · บทเรียน

การสร้างการสืบค้นที่ปลอดภัยด้านชนิดข้อมูล

สร้างการสืบค้นที่ปฏิเสธคอลัมน์ที่ไม่ถูกต้องตั้งแต่เวลาคอมไพล์

การสร้างการสืบค้นที่ปลอดภัยด้านชนิดข้อมูล เป็นบทเรียน TypeScript Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน TypeScript Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส TypeScript Academy มีบทเรียนทั้งหมด 4 บทเรียน

คิวรีที่อ้างอิงคอลัมน์ที่ไม่รู้จักไม่ได้

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

การอ้างอิงคอลัมน์ที่มีชนิดข้อมูล

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

import { eq } from "drizzle-orm";

// users.id and users.name are typed column objects
const rows = await db
  .select()
  .from(users)
  .where(eq(users.id, 1));

คอลัมน์ที่ไม่รู้จัก = ข้อผิดพลาดระหว่างคอมไพล์

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

await db.select().from(users).where(eq(users.idd, 1));
//                                          ^^^^ 
// Error: Property "idd" does not exist on the users table.

ตัวถูกดำเนินการเปรียบเทียบที่มีชนิดข้อมูล

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

eq(users.age, 30);       // ok: age is number
eq(users.age, "thirty"); // Error: string is not assignable to number

การเลือกคอลัมน์เฉพาะ

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

const partial = await db
  .select({ id: users.id, name: users.name })
  .from(users);
// result rows: { id: number; name: string }[]

การปฏิเสธคอลัมน์จากตารางอื่น

แผนผัง select จำกัดให้ใช้ได้เฉพาะคอลัมน์ของตารางที่คิวรีเท่านั้น การอ้างอิงคอลัมน์จากตารางที่ไม่เกี่ยวข้องจะทำให้คอมไพล์ไม่ผ่าน

await db
  .select({ title: posts.title }) // posts not in this query
  .from(users);
// Error: posts.title is not part of the FROM clause.

เงื่อนไขที่นำมาประกอบกันได้

เงื่อนไขสามารถรวมกันด้วย and, or และ not แต่ละส่วนยังคงมีชนิดข้อมูลกำกับอยู่ ดังนั้นเงื่อนไขที่มีรูปแบบผิดจะถูกตรวจพบแม้อยู่ลึกภายในโครงสร้างต้นไม้

import { and, gt, eq } from "drizzle-orm";

const q = db.select().from(users).where(
  and(gt(users.age, 18), eq(users.isAdmin, false))
);

การจัดลำดับและการจำกัดจำนวน

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

import { desc } from "drizzle-orm";

await db.select().from(users).orderBy(desc(users.age)).limit(10);

กลไกการปฏิเสธทำงานอย่างไร

ตัวสร้างเป็นแบบเจเนอริกตามชนิดของตาราง ลายเซ็นของ where และ select รับเฉพาะค่าชนิด Column<TTable> ดังนั้นคอมไพเลอร์จึงปฏิเสธสิ่งอื่นตามโครงสร้าง

// Conceptual signature
declare function select<T>(
  table: T,
  cols: { [k: string]: ColumnOf<T> }
): Query;

การเพิ่มข้อมูลก็มีชนิดข้อมูลกำกับเช่นกัน

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

await db.insert(users).values({
  name: "Ada",
  isAdmin: false,
  // missing fields would error; extra unknown keys error too
});

เหตุผลที่สิ่งนี้ช่วยได้

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

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ตรวจสอบความเข้าใจของคุณเกี่ยวกับการสร้างคิวรีที่ปลอดภัยด้านชนิดข้อมูล

สรุป

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

คำถามที่พบบ่อย

บทเรียน “การสร้างการสืบค้นที่ปลอดภัยด้านชนิดข้อมูล” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การสร้างการสืบค้นที่ปลอดภัยด้านชนิดข้อมูล” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส TypeScript Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส TypeScript Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การสร้างการสืบค้นที่ปลอดภัยด้านชนิดข้อมูล”

สร้างการสืบค้นที่ปฏิเสธคอลัมน์ที่ไม่ถูกต้องตั้งแต่เวลาคอมไพล์ คุณปฏิบัติ TypeScript Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน TypeScript Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน TypeScript Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน

บทเรียน “การสร้างการสืบค้นที่ปลอดภัยด้านชนิดข้อมูล” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน TypeScript Academy นี้ได้ไหม

ได้ บทเรียน TypeScript Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

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

← กลับไปที่ TypeScript Academy