การรวมตัวควบคุมแหล่งที่มาของฐานข้อมูล SQL ใน Microsoft Fabric

นําไปใช้กับ:✅ฐานข้อมูล SQL ใน Microsoft Fabric

ในบทช่วยสอนนี้ คุณจะได้เรียนรู้วิธีทํางานกับฐานข้อมูล SQL ของคุณใน Fabric โดยใช้การควบคุมแหล่งที่มาของการรวม Fabric git

ฐานข้อมูล SQL ใน Microsoft Fabric มีการรวมการควบคุมแหล่งที่มาหรือ "การรวม git" เพื่อให้ผู้ใช้สามารถติดตามคําจํากัดความของวัตถุฐานข้อมูลของตนเมื่อเวลาผ่านไป การรวมนี้ช่วยให้ทีมสามารถ:

• คอมมิตฐานข้อมูลกับตัวควบคุมแหล่งที่มา ซึ่งจะแปลงฐานข้อมูลสดเป็นโค้ดในที่เก็บตัวควบคุมแหล่งที่มาที่กําหนดค่าไว้โดยอัตโนมัติ (เช่น Azure DevOps)
• อัปเดตวัตถุฐานข้อมูลจากเนื้อหาของตัวควบคุมแหล่งข้อมูล ซึ่งตรวจสอบความถูกต้องของโค้ดในที่เก็บตัวควบคุมแหล่งข้อมูลก่อนที่จะใช้การเปลี่ยนแปลงความแตกต่างกับฐานข้อมูล

ถ้าคุณไม่คุ้นเคยกับ git นี่คือแหล่งข้อมูลที่แนะนําบางประการ:

• git คืออะไร
• โมดูลการฝึกอบรม: บทนําสู่ git
• บทช่วยสอน: การจัดการวงจรชีวิตใน Fabric

บทความนี้นําเสนอชุดของสถานการณ์ที่มีประโยชน์ซึ่งคุณสามารถใช้แยกกันหรือใช้ร่วมกันเพื่อจัดการกระบวนการพัฒนาของคุณด้วยฐานข้อมูล SQL ใน Fabric:

• แปลงฐานข้อมูล Fabric SQL เป็นโค้ดในตัวควบคุมแหล่งข้อมูล
• อัปเดตฐานข้อมูล Fabric SQL จากตัวควบคุมแหล่งข้อมูล
• สร้างพื้นที่ทํางานสาขา
• ผสานการเปลี่ยนแปลงจากสาขาหนึ่งลงในอีกสาขาหนึ่ง
• จัดการข้อมูลแบบคงที่ด้วยสคริปต์หลังการปรับใช้

สถานการณ์ในบทความนี้จะครอบคลุมในตอนของข้อมูลที่ถูกเปิดเผย ดูวิดีโอสําหรับภาพรวมของการรวมตัวควบคุมแหล่งข้อมูลใน Fabric:

หมายเหตุ

การตั้งค่าระดับฐานข้อมูล เช่น การเปรียบเทียบและระดับความเข้ากันได้ไม่รวมอยู่ในการควบคุมแหล่งที่มาและการรวมไปป์ไลน์การปรับใช้ในขณะนี้ สําหรับการตั้งค่าฐานข้อมูลที่คุณสามารถตั้งค่าได้โดยใช้ T-SQL หลังจากสร้างฐานข้อมูล คุณสามารถปรับเปลี่ยนฐานข้อมูลด้วยสคริปต์หลังจากการปรับใช้

ข้อกำหนดเบื้องต้น

• คุณต้องมีความจุ Fabric ที่มีอยู่ หากคุณไม่ทําเช่นนี้ ให้ เริ่มการทดลองใช้ Fabric
• ตรวจสอบให้แน่ใจว่าคุณ ได้เปิดใช้งานการตั้งค่าผู้เช่าการรวม Git แล้ว
• สร้างพื้นที่ทํางานใหม่หรือใช้พื้นที่ทํางาน Fabric ที่มีอยู่
• สร้างหรือใช้ฐานข้อมูล SQL ที่มีอยู่ใน Fabric ถ้าคุณยังไม่มี ให้สร้างฐานข้อมูล SQL ใหม่ใน Fabric
• ทางเลือก: ติดตั้ง Visual Studio Code, ส่วนขยาย MSSQL และส่วนขยาย SQL projects สําหรับ VS Code

ตั้งค่า

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

สําหรับขั้นตอนในการเชื่อมต่อพื้นที่ทํางานของคุณกับที่เก็บตัวควบคุมแหล่งข้อมูล ให้ดู เริ่มต้นใช้งานการรวม Git พื้นที่ทํางานของคุณสามารถเชื่อมต่อกับที่เก็บระยะไกล Azure DevOps หรือ GitHub ได้

เพิ่มฐานข้อมูล Fabric SQL ไปยังตัวควบคุมแหล่งข้อมูล

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

1. เชื่อมต่อกับฐานข้อมูล SQL ของคุณ ในตัวแก้ไข Fabric SQL SQL Server Management Studio, ส่วนขยาย MSSQL สําหรับ Visual Studio Code หรือเครื่องมือภายนอกอื่นๆ
2. สร้างตาราง กระบวนงานที่เก็บไว้ หรือวัตถุอื่นๆ ในฐานข้อมูลใหม่
3. เลือก ปุ่มตัวควบคุม แหล่ง เพื่อเปิดแผงควบคุมต้นทาง
4. เลือกกล่องกาเครื่องหมายถัดจากฐานข้อมูลที่ต้องการ เลือกยืนยัน การบริการ Fabric อ่านข้อกําหนดวัตถุจากฐานข้อมูลและเขียนไปยังที่เก็บระยะไกล
5. ขณะนี้คุณสามารถดูประวัติของวัตถุฐานข้อมูลในมุมมองแหล่งข้อมูลของที่เก็บโค้ดได้

เมื่อคุณแก้ไขฐานข้อมูลต่อไป รวมถึงการแก้ไขวัตถุที่มีอยู่ ให้ยอมรับการเปลี่ยนแปลงเหล่านั้นกับตัวควบคุมแหล่งที่มา โดยทําตามขั้นตอนก่อนหน้านี้

ไฟล์โครงการ SQL

แฟ้มโครงการ SQL ในที่เก็บตัวควบคุมแหล่งที่มาประกอบด้วยข้อมูลเมตาเกี่ยวกับฐานข้อมูล การรวมการควบคุมแหล่งที่มาของแฟบริกใช้ไฟล์นี้เพื่อนําฟังก์ชันการทํางานเพิ่มเติมมาสู่ไปป์ไลน์การควบคุมและการปรับใช้แหล่งที่มา การรวมการควบคุมแหล่งที่มาของแฟบริกจะสร้างและอัปเดตไฟล์โครงการโดยอัตโนมัติ หลีกเลี่ยงการแก้ไขไฟล์โครงการด้วยตนเอง เนื่องจากการแก้ไขไฟล์โครงการของคุณถูกเขียนทับโดยการรวมการควบคุมแหล่งที่มาของ Fabric ในการยอมรับครั้งต่อไปจาก Fabric อย่างไรก็ตาม ถ้าคุณต้องการสร้างโครงการ SQL ภายในเครื่อง โดยใช้เครื่องมือ SQL เช่น SQL Server Management Studio หรือส่วนขยายโครงการ SQL สําหรับ Visual Studio Code คุณสามารถเพิ่มการอ้างอิงไปยังแฟ้มใน master.dacpac แฟ้มโครงการของคุณได้

การรวม Fabric กับโปรเจ็กต์ SQL จะเพิ่มคุณสมบัติเมตาดาต้าเหล่านี้ลงในไฟล์โปรเจ็กต์:

• ไม่รวม .sharedQueries โฟลเดอร์จากการสร้างโครงการฐานข้อมูล การยกเว้นนี้ช่วยให้คุณสามารถติดตามสคริปต์ในการควบคุมแหล่งที่มาได้โดยไม่ส่งผลกระทบต่อการตรวจสอบความถูกต้องของแบบจําลองฐานข้อมูล
• สคริปต์ก่อนการปรับใช้และหลังการปรับใช้จากโฟลเดอร์ .sharedQueries
• การอ้างอิงวัตถุระบบเป็นการอ้างอิงแพคเกจไปยังไฟล์ master.dacpac

ความสามารถในการอ้างอิงวัตถุระบบถูกตั้งค่าโดยอัตโนมัติโดยไม่จําเป็นต้องดําเนินการใดๆ ตัวแก้ไขคิวรี Fabric มีสคริปต์ก่อนการปรับใช้และหลังการปรับใช้ภายใต้โฟลเดอร์คิวรีที่ใช้ร่วมกัน

อัปเดตฐานข้อมูล Fabric SQL จากตัวควบคุมแหล่งข้อมูล

ในสถานการณ์สมมตินี้ คุณสร้างวัตถุฐานข้อมูลเป็นรหัสในส่วนขยายโครงการ SQL ใน Visual Studio Code จากนั้น commit แฟ้มไปยังตัวควบคุมแหล่งที่มาก่อนที่จะปรับปรุงฐานข้อมูล Fabric SQL จากการรวมตัวควบคุมแหล่งที่มา สถานการณ์นี้มุ่งเป้าไปที่นักพัฒนาที่ต้องการทํางานใน Visual Studio Code มีแอปพลิเคชันที่มีอยู่โดยใช้โครงการ SQL หรือมีข้อกําหนดไปป์ไลน์ CI/CD ขั้นสูง

1. ตรวจสอบให้แน่ใจว่าคุณติดตั้ง Visual Studio Code รุ่นล่าสุดและส่วนขยายโครงการ MSSQL และ SQL สําหรับ Visual Studio Code
   • ใช้ตัวควบคุมแหล่งที่มา git แบบบูรณาการของ Visual Studio Code
2. สร้างฐานข้อมูล SQL ใหม่ในพื้นที่ทํางานของคุณและส่งไปยังตัวควบคุมแหล่งข้อมูลโดยไม่ต้องเพิ่มวัตถุใดๆ ขั้นตอนนี้เพิ่มโครงการ SQL ที่ว่างเปล่าและเมตาดาต้ารายการฐานข้อมูล SQL ไปยังที่เก็บ
3. โคลนที่เก็บตัวควบคุมแหล่งข้อมูลไปยังเครื่องภายในเครื่องของคุณ
   • หากคุณกําลังใช้ Azure DevOps ให้เลือกเมนูบริบท ... สําหรับโครงการควบคุมแหล่งที่มา เลือก Clone เพื่อคัดลอกที่เก็บ Azure DevOps ของคุณไปยังเครื่องในเครื่องของคุณ หากคุณเพิ่งเริ่มใช้ Azure DevOps โปรดดูคู่มือ Code with git สําหรับ Azure DevOps
   • หากคุณกําลังใช้ GitHub ให้เลือกปุ่ม Code ในที่เก็บ และคัดลอก URL เพื่อโคลนที่เก็บไปยังเครื่องภายในเครื่องของคุณ หากคุณเพิ่งเริ่มใช้ GitHub โปรดดูคู่มือ การโคลนที่เก็บ
4. เปิดโฟลเดอร์ที่โคลนใน Visual Studio Code สาขาที่เชื่อมโยงกับพื้นที่ทํางานของคุณอาจไม่ใช่สาขาเริ่มต้น คุณควรเห็นโฟลเดอร์ที่มีชื่อ <yourdatabase>.SQLDatabase ใน Visual Studio Code หลังจากสลับสาขา
5. สร้าง .sql แฟ้มสําหรับตารางอย่างน้อยหนึ่งตารางที่คุณต้องการสร้างในฐานข้อมูลภายในโครงสร้างโฟลเดอร์สําหรับฐานข้อมูลของคุณ ไฟล์ ควรประกอบด้วยคําสั่ง CREATE TABLE สําหรับตาราง ตัวอย่างเช่น สร้างไฟล์ที่ชื่อว่า MyTable.sql ในโฟลเดอร์ dbo/Tables ที่มีเนื้อหาต่อไปนี้:

   CREATE TABLE dbo.MyTable
   (
       Id INT PRIMARY KEY,
       ExampleColumn NVARCHAR(50)
   );
   

6. เพื่อให้แน่ใจว่าไวยากรณ์ถูกต้อง ให้ตรวจสอบแบบจําลองฐานข้อมูลด้วยโครงการ SQL หลังจากเพิ่มไฟล์แล้ว ให้ใช้มุมมองโครงการฐานข้อมูลใน Visual Studio Code เพื่อสร้างโครงการ
7. หลังจากสร้างสําเร็จ ให้ คอมมิต ไฟล์ไปยังการควบคุมแหล่งที่มาโดยใช้มุมมองการควบคุมแหล่งที่มาใน Visual Studio Code หรืออินเทอร์เฟซ git ภายในเครื่องที่คุณต้องการ
8. ส่ง/ซิงค์การยอมรับของคุณไปยังที่เก็บระยะไกล ตรวจสอบว่าไฟล์ใหม่ของคุณปรากฏใน Azure DevOps หรือ GitHub
9. กลับไปยังอินเทอร์เฟซเว็บ Fabric และเปิดแผงควบคุม แหล่ง ในพื้นที่ทํางาน คุณอาจมีการแจ้งเตือนว่า "คุณมีการเปลี่ยนแปลงที่ค้างอยู่จาก git" เลือก ปุ่ม อัปเดต (อัปเดตทั้งหมด) เพื่อนําโค้ดจากโครงการ SQL ของคุณไปใช้กับฐานข้อมูล
   • คุณอาจเห็นฐานข้อมูลทันทีที่ระบุว่าเป็น "ไม่ได้ผูกมัด" หลังจากการอัปเดต สถานะนี้เกิดขึ้นเนื่องจากคุณลักษณะการรวม Git ทําการเปรียบเทียบโดยตรงของเนื้อหาไฟล์ทั้งหมดที่สร้างขึ้นสําหรับข้อกําหนดรายการ และอาจเกิดความแตกต่างโดยไม่ได้ตั้งใจได้ ตัวอย่างหนึ่งคือแอตทริบิวต์แบบอินไลน์บนคอลัมน์ ในกรณีเหล่านี้ คุณต้องยอมรับกลับไปยังการควบคุมแหล่งที่มาในเว็บอินเตอร์เฟส Fabric เพื่อซิงค์ข้อกําหนดกับสิ่งที่สร้างขึ้นเป็นส่วนหนึ่งของการดําเนินการยอมรับ
10. เมื่อการอัปเดตเสร็จสิ้น ให้ใช้เครื่องมือที่คุณเลือกเพื่อเชื่อมต่อกับฐานข้อมูล วัตถุที่คุณเพิ่มลงในโครงการ SQL จะปรากฏในฐานข้อมูล

หมายเหตุ

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

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

• /p:ScriptDatabaseOptions = false
• /p:DoNotAlterReplicatedObjects = false
• /p:IncludeTransactionalScripts = true
• /p:GenerateSmartDefaults = true

คุณยังสามารถโคลนโครงการ SQL ที่ควบคุมแหล่งที่มาไปยังเครื่องภายในเครื่องของคุณเพื่อแก้ไขใน Visual Studio Code, SQL Server Management Studio หรือเครื่องมือโครงการ SQL อื่นๆ สร้างโครงการ SQL ภายในเครื่องเพื่อตรวจสอบความถูกต้องของการเปลี่ยนแปลงก่อนที่จะนําไปใช้กับการควบคุมแหล่งที่มา

สร้างพื้นที่ทํางานสาขา

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

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

ผสานการเปลี่ยนแปลงจากสาขาหนึ่งลงในอีกสาขาหนึ่ง

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

สร้างพื้นที่ทํางานสองแห่งที่มีสาขาที่เกี่ยวข้องในที่เก็บเดียวกัน ตามที่อธิบายไว้ใน สถานการณ์ก่อนหน้า

1. ด้วยฐานข้อมูลบนสาขารอง ทําการเปลี่ยนแปลงวัตถุในฐานข้อมูล
   • ตัวอย่างเช่น ปรับเปลี่ยนกระบวนงานที่เก็บไว้ที่มีอยู่ หรือสร้างตารางใหม่
2. ตรวจสอบการเปลี่ยนแปลงเหล่านี้กับการควบคุมแหล่งที่มาโดยใช้ปุ่ม Commit บนแผงควบคุมแหล่งที่มาใน Fabric
3. ใน Azure DevOps หรือ GitHub ให้สร้างคําขอดึงข้อมูลจากสาขารองไปยังสาขาหลัก
   • ในคําขอดึงข้อมูล คุณสามารถดูการเปลี่ยนแปลงในรหัสฐานข้อมูลระหว่างพื้นที่ทํางานหลักและพื้นที่ทํางานรองได้
4. เมื่อคุณเสร็จสิ้นคําขอดึงข้อมูล ตัวควบคุมแหล่งข้อมูลจะได้รับการอัปเดต แต่ฐานข้อมูลใน Fabric บนพื้นที่ทํางานหลักจะไม่เปลี่ยนแปลง เมื่อต้องการเปลี่ยนฐานข้อมูลหลัก ให้อัปเดตพื้นที่ทํางานหลักจากตัวควบคุมแหล่งข้อมูลโดยใช้ ปุ่ม อัปเดต บนแผงควบคุมต้นทางใน Fabric

จัดการข้อมูลแบบคงที่ด้วยสคริปต์หลังการปรับใช้

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

1. จากฐานข้อมูล SQL ใน Fabric ที่เชื่อมต่อกับตัวควบคุมแหล่งที่มา ให้ระบุหรือสร้างตารางที่คุณต้องการจัดการข้อมูลแบบคงที่ ตัวอย่างเช่น คุณอาจมี dbo.Colors ตารางที่แอปพลิเคชันของคุณใช้ และมีชุดค่าที่รู้จักซึ่งไม่เปลี่ยนแปลงบ่อยนัก

2. สร้าง คิวรี ใหม่ในตัวแก้ไขฐานข้อมูล SQL ใน Fabric ในตัวแก้ไขแบบสอบถาม ให้เพิ่ม MERGE คําสั่งเพื่อจัดการเนื้อหาของ Colors ตาราง เช่น:

   MERGE dbo.Colors AS target
   USING (VALUES
       (1, 'Red'),
       (2, 'Green'),
       (3, 'Blue')
   ) AS source (Id, Name)
   ON target.Id = source.Id
   WHEN MATCHED THEN
       UPDATE SET Name = source.Name
   WHEN NOT MATCHED BY TARGET THEN
       INSERT (Id, Name) VALUES (source.Id, source.Name)
   WHEN NOT MATCHED BY SOURCE THEN
       DELETE;
   

3. เปลี่ยนชื่อคิวรีเป็น Post-Deployment-StaticData.sql และย้ายไปยังคิวรีที่ใช้ร่วมกัน

4. เมื่ออยู่ในคิวรีที่ใช้ร่วมกัน ให้เลือกเมนู ... สําหรับคิวรี และเลือก ตั้งเป็นสคริปต์หลังการปรับใช้

คิวรีนี้จะทํางานโดยอัตโนมัติโดยเป็นส่วนหนึ่งของการอัปเดตใดๆ จากการควบคุมแหล่งที่มาหรือการปรับใช้ไปป์ไลน์การปรับใช้ ดังนั้นคุณจึงสามารถจัดการข้อมูลแบบคงที่ใน Colors ตารางได้โดยใช้การควบคุมแหล่งที่มา คุณสามารถแก้ไขคิวรีในตัวแก้ไขคิวรี Fabric และยอมรับการเปลี่ยนแปลงการควบคุมแหล่งที่มาเพื่อจัดการการเปลี่ยนแปลงข้อมูลแบบคงที่เมื่อเวลาผ่านไป นอกจากนี้ เนื่องจากสคริปต์ก่อนการปรับใช้และหลังการปรับใช้จะรวมอยู่ในโครงการ SQL คุณยังสามารถแก้ไขแบบสอบถามจากเครื่องภายในเครื่องของคุณโดยใช้ Visual Studio Code หรือเครื่องมือโครงการ SQL อื่นๆ จากนั้นยอมรับการเปลี่ยนแปลงเหล่านั้นไปยังการควบคุมแหล่งที่มา เรียนรู้เพิ่มเติมเกี่ยวกับสคริปต์ก่อนการปรับใช้และหลังการปรับใช้ในเอกสารประกอบโครงการ SQL

เนื้อหาที่เกี่ยวข้อง

• ฐานข้อมูล SQL ใน Microsoft Fabric
• บทช่วยสอน: การจัดการวงจรชีวิตใน Fabric
• ภาพรวมของโครงการ SQL
• เครื่องมือโครงการ SQL