เริ่มต้นเรียน Django ORM อย่างไรให้เข้าใจง่าย: จาก Model สู่ Data Science

Django ORM คืออะไร ทำไมนักพัฒนาและเจ้าของธุรกิจควรรู้

Django ORM (Object-Relational Mapping) คือสะพานเชื่อมระหว่างโค้ด Python กับฐานข้อมูล มันช่วยให้คุณเขียนคำสั่งจัดการฐานข้อมูลทั้งหมดด้วย Python ล้วนๆ โดยไม่ต้องเขียน SQL ดิบแม้แต่บรรทัดเดียว จุดเด่นสำคัญคือโค้ดอ่านง่าย ปลอดภัยจาก SQL Injection โดยอัตโนมัติ และที่สำคัญคือคุณเปลี่ยนฐานข้อมูลจาก PostgreSQL ไป MySQL หรือ SQLite ได้โดยแทบไม่ต้องแก้โค้ดเลย

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

3 ขั้นตอนเริ่มต้นเรียน Django ORM แบบปูพื้นฐานเข้าใจง่าย

1. เริ่มจาก Model — แปลงความคิดให้เป็นโครงสร้างข้อมูล

ก่อนจะใช้ ORM ได้ คุณต้องเข้าใจ Model ก่อน Model ใน Django คือคลาส Python ที่ใช้กำหนดโครงสร้างตารางในฐานข้อมูล วิธีคิดที่ดีที่สุดคือมองว่าหนึ่ง Model เท่ากับหนึ่งตาราง (Table) และแต่ละ attribute ในคลาสคือหนึ่งคอลัมน์ (Column) ในตารางนั้น ลองดูตัวอย่างระบบร้านค้าออนไลน์:

from django.db import models

class Category(models.Model):
    name = models.CharField(max_length=100)
    slug = models.SlugField(unique=True)
    is_active = models.BooleanField(default=True)

class Product(models.Model):
    category = models.ForeignKey(Category, on_delete=models.CASCADE)
    name = models.CharField(max_length=250)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    stock = models.PositiveIntegerField(default=0)
    description = models.TextField(blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

เมื่อคุณมี Model แล้ว Django ORM จะสร้างชุดคำสั่ง CRUD (Create, Read, Update, Delete) ให้คุณใช้ได้ทันทีโดยไม่ต้องเขียน SQL เอง:

# CREATE — เพิ่มสินค้าใหม่
product = Product.objects.create(
    category=some_category,
    name="กาแฟม็อคค่าพรีเมียม",
    price=89.00,
    stock=200,
)

# READ — ค้นหาสินค้า
all_products = Product.objects.all()
cheap = Product.objects.filter(price__lt=100)
single = Product.objects.get(id=1)

# UPDATE — แก้ไขข้อมูล
product.price = 95.00
product.save()

# DELETE — ลบข้อมูล
product.delete()

2. ฝึกฝน QuerySet และ Lookup Types ให้คล่อง

QuerySet คือหัวใจของ Django ORM มันคือชุดคำสั่งสำหรับดึงข้อมูลที่ทำงานแบบ Lazy — หมายความว่า Django จะยังไม่ query ฐานข้อมูลจริงๆ จนกว่าคุณจะเริ่มใช้งานข้อมูลนั้น (เช่น loop หรือเรียก list()) ข้อดีคือคุณสามารถต่อคำสั่ง filter หลายๆ ตัวโดยไม่เปลืองทรัพยากร และ Django จะ optimize query ให้เป็น SQL ที่มีประสิทธิภาพที่สุดให้อัตโนมัติ

Lookup Types ที่ควรฝึกฝนจนชำนาญมีดังนี้:

• __exact และ __iexact — เปรียบเทียบแบบตรงตัวและไม่สนตัวพิมพ์เล็กใหญ่
• __contains และ __icontains — ค้นหาข้อความบางส่วน (LIKE '%keyword%')
• __gt, __gte, __lt, __lte — เปรียบเทียบมากกว่า น้อยกว่า สำหรับตัวเลขและวันที่
• __startswith, __endswith — ค้นหาจากจุดเริ่มต้นหรือลงท้ายของข้อความ
• __in — ตรวจสอบว่าค่าอยู่ในลิสต์ที่กำหนดหรือไม่
• __range — ค้นหาค่าในช่วง (เหมาะกับการ filter วันที่)
• __isnull — ตรวจสอบว่าฟิลด์เป็น NULL หรือไม่

ตัวอย่างการใช้งาน lookup types ร่วมกันเพื่อสร้าง query ที่ซับซ้อนแต่ยังอ่านง่าย:

from datetime import date, timedelta

last_week = date.today() - timedelta(days=7)

# ค้นหาสินค้าราคาต่ำกว่า 200 ที่มีสต็อก และถูกสร้างใน 7 วันที่ผ่านมา
recent_affordable = Product.objects.filter(
    price__lt=200,
    stock__gt=0,
    created_at__gte=last_week,
    name__icontains="กาแฟ",
).order_by("-created_at")

3. จัดการความสัมพันธ์ระหว่างข้อมูลและป้องกัน N+1 Query Problem

ข้อมูลในโลกจริงไม่ได้อยู่อย่างโดดเดี่ยว มันมีความสัมพันธ์กันเสมอ Django ORM รองรับความสัมพันธ์ 3 รูปแบบ:

• ForeignKey (One-to-Many) — ใช้บ่อยที่สุด เช่น ลูกค้าหนึ่งคนมีหลายคำสั่งซื้อ หมวดหมู่หนึ่งมีหลายสินค้า
• ManyToManyField (Many-to-Many) — เช่น สินค้าหนึ่งชิ้นอยู่ได้หลายโปรโมชัน และหนึ่งโปรโมชันครอบคลุมหลายสินค้า
• OneToOneField (One-to-One) — เช่น ผู้ใช้หนึ่งคนมีโปรไฟล์ขยายข้อมูลหนึ่งชุด

ปัญหาสำคัญที่นักพัฒนามือใหม่มักเจอคือ N+1 Query Problem — การที่ Django ส่ง query ไปหาฐานข้อมูลซ้ำๆ โดยไม่จำเป็น ตัวอย่างเช่น การ loop เพื่อดึงชื่อหมวดหมู่ของสินค้าแต่ละชิ้นจะทำให้เกิด query เพิ่มทีละ 1 ครั้งต่อสินค้า ซึ่งถ้ามีสินค้า 1,000 ชิ้น คุณจะส่ง query 1,001 ครั้ง!

วิธีแก้ไขคือใช้ select_related() สำหรับ ForeignKey (ทำ SQL JOIN) และ prefetch_related() สำหรับ ManyToManyField (ทำ query แยกแล้วรวมผลใน Python):

# แย่ — เกิด N+1 Query
products = Product.objects.all()
for p in products:
    print(p.category.name)  # query ฐานข้อมูลทุกครั้งที่ loop

# ดี — ใช้ select_related ลดเหลือ query เดียว
products = Product.objects.select_related("category").all()
for p in products:
    print(p.category.name)  # ใช้ข้อมูลจาก JOIN แล้ว ไม่ query เพิ่ม

เมื่อ Django ORM พบกับ Python Data Science: จุดเชื่อมต่อที่ทรงพลัง

องค์กรที่ใช้ Django เป็น Backend มักมีข้อมูลมหาศาลสะสมอยู่ในฐานข้อมูล แต่มักแยกส่วนระหว่าง "ทีมพัฒนาเว็บ" กับ "ทีม Data Science" ออกจากกัน ทั้งที่จริงแล้ว Django ORM สามารถเป็นสะพานเชื่อมชั้นดีระหว่างสองโลกนี้ได้

Python สำหรับ Data Science เหมาะกับโปรเจกต์ที่ต้องการวิเคราะห์ข้อมูลเชิงลึกและสร้างโมเดลทำนาย เช่น การพยากรณ์ยอดขายรายเดือน การแบ่งกลุ่มลูกค้าด้วยเทคนิค Clustering การวิเคราะห์แนวโน้มพฤติกรรมผู้ใช้ หรือการสร้างระบบแนะนำสินค้าด้วย Machine Learning แต่คำถามที่มักเกิดขึ้นคือ "ข้อมูลมาจากไหน?" — สำหรับธุรกิจที่ใช้ Django อยู่แล้ว คำตอบนั้นง่ายมาก: ข้อมูลอยู่ในฐานข้อมูลของคุณนั่นเอง

ข้อได้เปรียบของการใช้ Django ORM ร่วมกับ Data Science คือคุณสามารถใช้ ORM ดึงข้อมูลที่ต้องการด้วยเงื่อนไขซับซ้อนได้โดยตรง แล้วส่งต่อให้ไลบรารีอย่าง pandas ทันที โดยไม่ต้องสร้าง ETL Pipeline แยกต่างหาก:

import pandas as pd
from myapp.models import Order

# ใช้ Django ORM ดึงข้อมูลเฉพาะที่ต้องการวิเคราะห์
qs = Order.objects.filter(
    created_at__year=2026,
    status="completed",
).select_related("customer").values(
    "customer__name",
    "total_amount",
    "created_at__month",
)

# แปลงเป็น DataFrame เพื่อวิเคราะห์ต่อด้วย pandas
df = pd.DataFrame.from_records(qs)

# ต่อไปก็ใช้ความสามารถของ pandas, matplotlib, scikit-learn ได้เต็มที่
monthly_sales = df.groupby("created_at__month")["total_amount"].sum()
print(monthly_sales)

แนวคิดนี้เหมาะมากสำหรับธุรกิจขนาดกลางที่ต้องการเริ่มต้นทำ Data Science โดยไม่ต้องลงทุนสร้าง Data Warehouse หรือ Data Lake ก่อน — คุณสามารถเริ่มจากฐานข้อมูลที่มีอยู่แล้วของ Django ได้ทันที

5 ข้อผิดพลาดที่มือใหม่ Django ORM ควรรู้ไว้ก่อน

• ลืมเรียก save() หลังแก้ object — การเปลี่ยนค่า attribute เฉยๆ ไม่ได้ update ฐานข้อมูล ต้องเรียก .save() ทุกครั้ง
• ใช้ all() แล้ว filter ใน Python แทนที่จะ filter ใน QuerySet — ดึงข้อมูลทั้งหมดมากรองใน Python เปลืองแรมและช้ากว่าการ filter ในฐานข้อมูล
• ไม่ใส่ db_index=True ในฟิลด์ที่ใช้ filter บ่อยๆ — ทำให้ query ช้าลงเมื่อข้อมูลโตขึ้น ควรมี index ในฟิลด์ที่ใช้ใน WHERE, ORDER BY, JOIN บ่อยๆ
• ใช้ count() ใน if statement แทน exists() — ถ้าต้องการแค่ตรวจสอบว่ามีข้อมูลหรือไม่ ให้ใช้ .exists() ซึ่งเร็วกว่าเพราะทำ LIMIT 1
• ละเลย Django Debug Toolbar — เครื่องมือฟรีที่ช่วยให้คุณเห็นทุก SQL query ที่ Django สั่ง ไม่ใช้คือพลาดโอกาส optimize ครั้งใหญ่

เริ่มต้นเรียนรู้ Django ORM ตั้งแต่วันนี้

วิธีเรียนที่ดีที่สุดคือการลงมือทำ เลือกโปรเจกต์ง่ายๆ สักหนึ่งอย่าง — เช่น ระบบบันทึกรายรับรายจ่ายส่วนตัว ระบบจัดการสต็อกสินค้าร้านค้า หรือระบบจองคิว — แล้วตั้งกฎกับตัวเองว่าจะใช้ Django ORM จัดการข้อมูลทั้งหมดโดยไม่เขียน SQL ดิบ เริ่มจาก query ง่ายๆ แล้วค่อยๆ ท้าทายตัวเองด้วย query ที่ซับซ้อนขึ้น

สำหรับเจ้าของธุรกิจที่กำลังมองหาทีมพัฒนาเว็บไซต์ ระบบหลังบ้าน หรือโซลูชัน AI ด้วย Python-Django ทีมงาน pythonthailand.com (Para-Studio เชียงใหม่) มีประสบการณ์พัฒนาระบบให้กับธุรกิจ SME ไทยมาอย่างต่อเนื่อง ตั้งแต่เว็บแอปพลิเคชัน ระบบจัดการสต็อก ไปจนถึงระบบ AI อัตโนมัติที่ช่วยลดต้นทุนและเพิ่มประสิทธิภาพให้ธุรกิจ เราออกแบบสถาปัตยกรรมฐานข้อมูลและโค้ดโดยให้ความสำคัญกับความเร็ว ความปลอดภัย และการบำรุงรักษาในระยะยาว

สนใจปรึกษาหรือขอใบเสนอราคา ติดต่อทีมงานได้ที่ หน้า Contact เรายินดีให้คำแนะนำโดยไม่มีค่าใช้จ่ายครับ

---

หากชอบบทความดีๆ โปรดติดตามพวกเราด้วยนะคะ 🙏