Home-theater-designers
คุณอาจเคยได้ยินเกี่ยวกับการทำแผนที่เชิงวัตถุ (ORM) คุณอาจเคยใช้มาก่อน แต่มันคืออะไรกันแน่? และคุณใช้มันใน Python อย่างไร?
นี่คือทุกสิ่งที่คุณจำเป็นต้องรู้เกี่ยวกับ ORM และ Python
ORM คืออะไร?
การทำแผนที่เชิงวัตถุ (ORM) เป็นเทคนิคการเขียนโปรแกรมที่ใช้ในการเข้าถึงฐานข้อมูล มันเปิดเผยฐานข้อมูลของคุณเป็นชุดของวัตถุ คุณไม่จำเป็นต้องเขียนคำสั่ง SQL เพื่อแทรกหรือดึงข้อมูล คุณใช้ชุดของแอตทริบิวต์และวิธีการที่แนบมากับวัตถุ
อาจฟังดูซับซ้อนและไม่จำเป็น แต่สามารถช่วยประหยัดเวลาได้มากและช่วยควบคุมการเข้าถึงฐานข้อมูลของคุณ
นี่คือตัวอย่าง สมมติว่าเมื่อใดก็ตามที่คุณใส่รหัสผ่านลงในฐานข้อมูลของคุณ คุณต้องการแฮชรหัสผ่าน ดังที่อธิบายไว้ใน ความปลอดภัยของรหัสผ่านเว็บไซต์ นี่ไม่ใช่ปัญหาสำหรับกรณีการใช้งานทั่วไป—คุณต้องคำนวณก่อนทำการแทรก แต่ถ้าคุณต้องการแทรกบันทึกในหลาย ๆ ที่ในรหัส จะเกิดอะไรขึ้นถ้าโปรแกรมเมอร์คนอื่นแทรกลงในตารางของคุณ และคุณไม่รู้
เมื่อใช้ ORM คุณสามารถเขียนโค้ดเพื่อให้แน่ใจว่าเมื่อใดก็ตามที่มีการเข้าถึงแถวหรือฟิลด์ใดๆ ในฐานข้อมูลของคุณ โค้ดอื่นๆ ที่คุณกำหนดเองจะถูกดำเนินการก่อน
สิ่งนี้ยังทำหน้าที่เป็น 'แหล่งความจริงเดียว' หากคุณต้องการเปลี่ยนการคำนวณแบบกำหนดเอง คุณจะต้องเปลี่ยนการคำนวณในที่เดียว ไม่ใช่หลายแห่ง เป็นไปได้ที่จะปฏิบัติตามหลักการเหล่านี้หลายประการด้วย การเขียนโปรแกรมเชิงวัตถุ (OOP) ใน Python แต่ ORM ทำงานควบคู่กับหลักการ OOP เพื่อควบคุมการเข้าถึงฐานข้อมูล
มีบางสิ่งที่ต้องระวังเมื่อใช้ ORM และมีบางสถานการณ์ที่คุณอาจไม่ต้องการใช้ แต่โดยทั่วไปถือว่าเป็นสิ่งที่ดี โดยเฉพาะอย่างยิ่งใน codebase ขนาดใหญ่
ORM ใน Python โดยใช้ SQLAlchemy
เช่นเดียวกับงานอื่นๆ ใน Python การนำเข้าโมดูลทำได้เร็วและง่ายกว่าการเขียนของคุณเอง แน่นอน เป็นไปได้ที่จะเขียน ORM ของคุณเอง แต่ทำไมต้องสร้างวงล้อขึ้นมาใหม่?
ตัวอย่างต่อไปนี้ใช้ทั้งหมด SQLAlchemy ซึ่งเป็น Python ORM ที่ได้รับความนิยม แต่มีหลักการหลายอย่างที่นำไปใช้โดยไม่คำนึงถึงการใช้งาน
การตั้งค่า Python สำหรับ SQLAlchemy
ก่อนเริ่มใช้งาน คุณจะต้องตั้งค่าเครื่องของคุณสำหรับการพัฒนา Python ด้วย SQLAlchemy
คุณจะต้องใช้ Python 3.6 เพื่อทำตามตัวอย่างเหล่านี้ แม้ว่าเวอร์ชันเก่าจะใช้งานได้ แต่โค้ดด้านล่างจะต้องมีการแก้ไขก่อนที่จะทำงาน ไม่แน่ใจในความแตกต่าง? คำถามที่พบบ่อยเกี่ยวกับ Python ของเราครอบคลุมความแตกต่างทั้งหมด
ก่อนการเข้ารหัส คุณควรตั้งค่าสภาพแวดล้อม Python ซึ่งจะป้องกันปัญหากับแพ็คเกจ Python ที่นำเข้าอื่นๆ
รับรองว่ามี PIP ตัวจัดการแพ็คเกจ Python ติดตั้งซึ่งมาพร้อมกับ Python เวอร์ชันที่ทันสมัยที่สุด
เมื่อคุณพร้อมที่จะไป คุณสามารถเริ่มต้นด้วยการเตรียม SQLAlchemy ให้พร้อม จากภายในสภาพแวดล้อม Python ของคุณในบรรทัดคำสั่ง ให้ติดตั้ง SQLAlchemy ด้วย pip ติดตั้ง สั่งการ:
pip install SQLAlchemy-1.2.9NS 1.2.9 คือหมายเลขเวอร์ชัน คุณสามารถปล่อยตัวเลือกนี้ไว้เพื่อรับแพ็คเกจล่าสุดได้ แต่ควรเจาะจงไว้เป็นแนวทางที่ดี คุณไม่รู้ว่าเมื่อไรที่รุ่นใหม่อาจทำลายรหัสปัจจุบันของคุณ
ตอนนี้คุณพร้อมที่จะเริ่มเขียนโค้ดแล้ว คุณอาจจำเป็นต้องเตรียมฐานข้อมูลของคุณเพื่อยอมรับการเชื่อมต่อ Python แต่ตัวอย่างต่อไปนี้ทั้งหมดใช้ an SQLite ฐานข้อมูลที่สร้างในหน่วยความจำด้านล่าง
โมเดลใน SQLAlchemy
หนึ่งในองค์ประกอบหลักของ ORM คือ a แบบอย่าง . นี่คือคลาส Python ที่สรุปว่าตารางควรมีลักษณะอย่างไร และควรทำงานอย่างไร เป็นเวอร์ชัน ORM ของ สร้างตาราง คำสั่งใน SQL คุณต้องมีแบบจำลองสำหรับแต่ละตารางในฐานข้อมูลของคุณ
เปิดโปรแกรมแก้ไขข้อความหรือ IDE ที่คุณชื่นชอบ แล้วสร้างไฟล์ใหม่ชื่อ test.py . ป้อนรหัสเริ่มต้นนี้ บันทึกไฟล์ และเรียกใช้:
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
engine = create_engine('sqlite://') # Create the database in memory
Base.metadata.create_all(engine) # Create all the tables in the database
รหัสนี้ทำได้หลายอย่าง การนำเข้ามีความจำเป็นเพื่อให้ Python เข้าใจว่าจะหาโมดูล SQLAlchemy ได้จากที่ใด โมเดลของคุณจะใช้ declarative_base ในภายหลัง และกำหนดค่าโมเดลใหม่ ๆ ให้ทำงานตามที่คาดไว้
NS create_engine วิธีการสร้างการเชื่อมต่อใหม่กับฐานข้อมูลของคุณ หากคุณมีฐานข้อมูลอยู่แล้ว คุณจะต้องเปลี่ยน sqlite:// ไปยัง URI ฐานข้อมูลของคุณ รหัสนี้จะสร้างฐานข้อมูลใหม่ในหน่วยความจำเท่านั้น ฐานข้อมูลจะถูกทำลายเมื่อโค้ดของคุณดำเนินการเสร็จสิ้น
ในที่สุด create_all วิธีการสร้างตารางทั้งหมดที่กำหนดไว้ในโหมดของคุณในฐานข้อมูลของคุณ เนื่องจากคุณยังไม่ได้กำหนดแบบจำลองใดๆ จะไม่มีอะไรเกิดขึ้น ดำเนินการต่อและเรียกใช้รหัสนี้ เพื่อให้แน่ใจว่าคุณจะไม่มีปัญหาหรือการพิมพ์ผิด
มาทำโมเดลกันเถอะ เพิ่มการนำเข้าอื่นที่ด้านบนสุดของไฟล์ของคุณ:
from sqlalchemy import Column, Integer, Stringสิ่งนี้นำเข้า คอลัมน์ , จำนวนเต็ม , และ สตริง โมดูลจาก SQLAlchemy พวกเขากำหนดวิธีการทำงานของตารางฐานข้อมูล เขตข้อมูล คอลัมน์ และประเภทข้อมูล
ภายใต้ declarative_base , สร้างคลาสโมเดลของคุณ:
class Cars(Base):
__tablename__ = 'cars'
id = Column(Integer, primary_key=True)
make = Column(String(50), nullable=False)
color = Column(String(50), nullable=False)ตัวอย่างง่ายๆ นี้ใช้รถยนต์ แต่ตารางของคุณอาจมีข้อมูลใดๆ
แต่ละชั้นต้องสืบทอด ฐาน . ชื่อตารางฐานข้อมูลของคุณถูกกำหนดเป็น __ชื่อตาราง__ . ชื่อนี้ควรจะเหมือนกับชื่อคลาส แต่นี่เป็นเพียงการแนะนำ และจะไม่มีอะไรเสียหายหากไม่ตรงกัน
สุดท้าย แต่ละคอลัมน์ถูกกำหนดเป็นตัวแปรหลามภายในคลาส มีการใช้ข้อมูลประเภทต่างๆ และ Primary_key แอตทริบิวต์บอกให้ SQLAlchemy สร้าง NS คอลัมน์เป็นคีย์หลัก
ไปข้างหน้าและเพิ่มการนำเข้าครั้งสุดท้าย คราวนี้สำหรับ ForeignKey โมดูล. เพิ่มสิ่งนี้ควบคู่ไปกับ .ของคุณ คอลัมน์ นำเข้า:
from sqlalchemy import Column, ForeignKey, Integer, Stringตอนนี้สร้างคลาสโมเดลที่สอง คลาสนี้เรียกว่า เจ้าของรถ และเก็บรายละเอียดเจ้าของรถยนต์เฉพาะที่เก็บไว้ใน รถยนต์ ตาราง:
class CarOwners(Base):
__tablename__ = 'carowners'
id = Column(Integer, primary_key=True)
name = Column(String(50), nullable=False)
age = Column(Integer, nullable=False)
car_id = Column(Integer, ForeignKey('cars.id'))
car = relationship(Cars)มีคุณลักษณะใหม่หลายอย่างที่แนะนำที่นี่ NS car_id ฟิลด์ถูกกำหนดให้เป็นคีย์ต่างประเทศ มันเชื่อมโยงกับ NS ใน รถยนต์ ตาราง. สังเกตว่าชื่อตารางตัวพิมพ์เล็กถูกใช้อย่างไร แทนที่ชื่อคลาสตัวพิมพ์ใหญ่
สุดท้าย คุณลักษณะของ รถยนต์ ถูกกำหนดเป็น ความสัมพันธ์ . สิ่งนี้ทำให้โมเดลของคุณสามารถเข้าถึง รถยนต์ ตารางผ่านตัวแปรนี้ นี่แสดงให้เห็นด้านล่าง
หากคุณรันโค้ดนี้ในตอนนี้ คุณจะพบว่าไม่มีอะไรเกิดขึ้น นี่เป็นเพราะคุณยังไม่ได้บอกให้ทำอะไรที่เห็นได้ชัดเจน
วัตถุใน SQLAlchemy
เมื่อโมเดลของคุณถูกสร้างขึ้นแล้ว คุณสามารถเริ่มเข้าถึงออบเจ็กต์ และอ่านและเขียนข้อมูลได้ เป็นความคิดที่ดีที่จะวางตรรกะของคุณไว้ในคลาสและไฟล์ของตัวเอง แต่สำหรับตอนนี้ ตรรกะนั้นสามารถอยู่เคียงข้างโมเดลได้
กำลังเขียนข้อมูล
ในตัวอย่างนี้ คุณต้องแทรกข้อมูลบางส่วนลงในฐานข้อมูลก่อนจึงจะสามารถอ่านได้ หากคุณกำลังใช้ฐานข้อมูลที่มีอยู่ คุณอาจมีข้อมูลอยู่แล้ว ไม่ว่าจะด้วยวิธีใด การรู้วิธีแทรกข้อมูลก็ยังมีประโยชน์มาก
คุณอาจจะเคยชินกับการเขียน แทรก คำสั่งใน SQL SQLAlchemy จัดการสิ่งนี้ให้คุณ ต่อไปนี้เป็นวิธีแทรกหนึ่งแถวลงใน รถยนต์ แบบอย่าง. เริ่มต้นด้วยการนำเข้าใหม่สำหรับ ผู้ทำเซสชั่น :
from sqlalchemy.orm import sessionmakerนี่เป็นสิ่งจำเป็นในการสร้าง การประชุม และ DBเซสชั่น วัตถุที่ใช้ในการอ่านและเขียนข้อมูล:
DBSession = sessionmaker(bind=engine)
session = DBSession()ตอนนี้วางไว้ใต้ของคุณ create_all คำแถลง:
car1 = Cars(
make='Ford',
color='silver'
)
session.add(car1)
session.commit()มาทำลายรหัสนั้นกัน ตัวแปร รถ1 ถูกกำหนดให้เป็นวัตถุตาม รถยนต์ แบบอย่าง. ยี่ห้อและสีของมันถูกตั้งค่าเป็นพารามิเตอร์ มันเหมือนกับว่า 'ทำผมให้เป็นรถ แต่อย่าเพิ่งเขียนมันลงในฐานข้อมูล' รถคันนี้มีอยู่ในความทรงจำแต่กำลังรอที่จะถูกเขียนขึ้น
เพิ่มรถเข้ารอบด้วย session.add แล้วเขียนลงฐานข้อมูลด้วย session.commit .
ตอนนี้มาเพิ่มเจ้าของ:
owner1 = CarOwners(
name='Joe',
age='99',
car_id=(car1.id)
)
session.add(owner1)
session.commit()รหัสนี้เกือบจะเหมือนกับส่วนแทรกก่อนหน้าสำหรับ รถยนต์ แบบอย่าง. ข้อแตกต่างที่สำคัญที่นี่คือ car_id เป็นคีย์นอกดังนั้นจึงต้องมี id แถวที่มีอยู่ในตารางอื่น เข้าถึงได้ผ่าน รถ1.id คุณสมบัติ.
คุณไม่จำเป็นต้องสืบค้นฐานข้อมูลหรือส่งคืนรหัสใดๆ เนื่องจาก SQLAlchemy จะจัดการให้คุณ (ตราบใดที่คุณส่งข้อมูลก่อน)
การอ่านข้อมูล
เมื่อคุณได้เขียนข้อมูลบางอย่างแล้ว คุณสามารถเริ่มอ่านกลับได้ ต่อไปนี้เป็นวิธีการสอบถาม รถยนต์ และ เจ้าของรถ ตาราง:
result = session.query(Cars).all()มันง่ายมาก โดยใช้ แบบสอบถาม วิธีการที่พบใน การประชุม คุณระบุรุ่นแล้วใช้ ทั้งหมด วิธีการดึงผลลัพธ์ทั้งหมด หากคุณรู้ว่าจะมีผลลัพธ์เพียงผลลัพธ์เดียว คุณสามารถใช้ แรก กระบวนการ:
result = session.query(Cars).first()เมื่อคุณได้สอบถามโมเดลและเก็บผลลัพธ์ที่ส่งคืนไว้ในตัวแปรแล้ว คุณสามารถเข้าถึงข้อมูลผ่านออบเจ็กต์ได้:
print(result[0].color)สิ่งนี้จะพิมพ์ 'เงิน' สี เนื่องจากระเบียนนั้นเป็นแถวแรก คุณสามารถวนซ้ำวัตถุผลลัพธ์ได้หากต้องการ
เมื่อคุณกำหนดความสัมพันธ์ในแบบจำลองของคุณ คุณจะสามารถเข้าถึงข้อมูลในตารางที่เกี่ยวข้องโดยไม่ต้องระบุการรวม:
result = session.query(CarOwners).all()
print(result[0].name)
print(result[0].car.color)วิธีนี้ใช้ได้เนื่องจากโมเดลของคุณมีรายละเอียดของโครงสร้างตารางและ รถยนต์ แอตทริบิวต์ถูกกำหนดเป็นลิงค์ไปยัง รถยนต์ ตาราง.
อะไรที่ไม่ชอบเกี่ยวกับ ORM
บทช่วยสอนนี้ครอบคลุมเฉพาะพื้นฐานเท่านั้น แต่เมื่อคุณคุ้นเคยกับสิ่งเหล่านี้แล้ว คุณสามารถไปยังหัวข้อขั้นสูงได้ มีข้อเสียบางประการที่อาจเกิดขึ้นกับ ORM:
- คุณต้องเขียนแบบจำลองของคุณก่อนจึงจะสามารถเรียกใช้คิวรีได้
- เป็นอีกรูปแบบใหม่ที่ควรเรียนรู้
- อาจซับซ้อนเกินไปสำหรับความต้องการที่เรียบง่าย
- คุณต้องมีการออกแบบฐานข้อมูลที่ดีในการเริ่มต้น
ปัญหาเหล่านี้ไม่ใช่ปัญหาใหญ่ในตัวเอง แต่เป็นสิ่งที่ควรระวัง หากคุณกำลังทำงานกับฐานข้อมูลที่มีอยู่ คุณอาจถูกจับได้
หากคุณไม่มั่นใจว่า ORM เป็นเครื่องมือที่เหมาะสมสำหรับคุณ อย่าลืมอ่านเกี่ยวกับ คำสั่ง SQL ที่สำคัญที่โปรแกรมเมอร์ควรรู้ .
แบ่งปัน แบ่งปัน ทวีต อีเมล คุณควรอัปเกรดเป็น Windows 11 ทันทีหรือไม่Windows 11 กำลังจะมาในเร็วๆ นี้ แต่คุณควรอัปเดตโดยเร็วที่สุดหรือรอสองสามสัปดาห์ ลองหา
อ่านต่อไป หัวข้อที่เกี่ยวข้อง- การเขียนโปรแกรม
- Python
- SQL
- บทเรียนการเข้ารหัส
โจสำเร็จการศึกษาด้านวิทยาการคอมพิวเตอร์จากมหาวิทยาลัยลินคอล์น ประเทศอังกฤษ เขาเป็นนักพัฒนาซอฟต์แวร์มืออาชีพ และเมื่อเขาไม่ได้ขับโดรนหรือเขียนเพลง เขามักจะถูกมองว่าถ่ายภาพหรือผลิตวิดีโอ
วิธีการขอโทษอย่างมืออาชีพในอีเมลเพิ่มเติมจาก Joe Coburn
สมัครรับจดหมายข่าวของเรา
เข้าร่วมจดหมายข่าวของเราสำหรับเคล็ดลับทางเทคนิค บทวิจารณ์ eBook ฟรี และดีลพิเศษ!
คลิกที่นี่เพื่อสมัครสมาชิก