หมายเหตุ
การเข้าถึงหน้านี้ต้องได้รับการอนุญาต คุณสามารถลอง ลงชื่อเข้าใช้หรือเปลี่ยนไดเรกทอรีได้
การเข้าถึงหน้านี้ต้องได้รับการอนุญาต คุณสามารถลองเปลี่ยนไดเรกทอรีได้
นําไปใช้กับ:✅ จุดสิ้นสุดการวิเคราะห์ SQL และ Warehouse ใน Microsoft Fabric
ในบทความนี้ คุณจะได้เรียนรู้วิธีการสืบค้นข้อมูลที่อ่านจากไฟล์ Parquet โดยใช้ Fabric คลังข้อมูล หรือจุดสิ้นสุดการวิเคราะห์ SQL
ด้วยการใช้ฟังก์ชันใน OPENROWSET Fabric คลังข้อมูล หรือจุดสิ้นสุดการวิเคราะห์ SQL คุณสามารถคิวรีเนื้อหาของไฟล์ Parquet ได้โดยระบุ URL ไปยังไฟล์ ไวยากรณ์ของ OPENROWSET ฟังก์ชันคือ:
OPENROWSET(BULK {{parquet-file-url}})
[ WITH ( {{result set column schema}} ) ]
วิธีที่ OPENROWSET จัดการกับสคีมา
ฟังก์ชันจะใช้ OPENROWSET การอนุมานสคีมาอัตโนมัติเพื่อระบุชื่อคอลัมน์และชนิดข้อมูลโดยตรงจากไฟล์ Parquet ที่อ้างอิง
ฟังก์ชันจะ OPENROWSET อ่านข้อมูลเมตาของคอลัมน์จากไฟล์เอง คุณจึงสามารถคิวรีข้อมูลได้โดยไม่ต้องกําหนด Schema อย่างชัดเจน
เมื่อคุณอ้างอิงไฟล์ Parquet หลายไฟล์ ฟังก์ชันจะ OPENROWSET อนุมานสคีมาจากไฟล์แรกที่เข้าถึง ด้วยเหตุนี้ Schema ที่อนุมานอาจละเว้นคอลัมน์ที่ไม่มีอยู่ในไฟล์นั้น แม้ว่าคอลัมน์เหล่านั้นจะอยู่ในไฟล์อื่นก็ตาม ลักษณะการทํางานนี้อาจนําไปสู่คอลัมน์ที่หายไปหรือชนิดข้อมูลที่ไม่คาดคิดในผลลัพธ์คิวรี
เพื่อให้แน่ใจว่ามี Schema ที่คาดเดาได้และกําหนดได้ ให้กําหนดชื่อคอลัมน์และชนิดข้อมูลอย่างชัดเจนโดยใช้ WITH ส่วนคําสั่งใน OPENROWSET ฟังก์ชัน ใช้ข้อกําหนด Schema ที่ชัดเจนเมื่อคุณคิวรีหลายไฟล์ หรือเมื่อจําเป็นต้องมีโครงสร้างคอลัมน์ที่สอดคล้องกันในทุกไฟล์
อ่านไฟล์ปาร์เก้ด้วย OPENROWSET
วิธีที่ง่ายที่สุดในการดูเนื้อหาของไฟล์ Parquet คือการระบุ URL ของไฟล์ไปยัง OPENROWSET ฟังก์ชันโดยตรง
ตัวอย่างต่อไปนี้แสดงวิธีการอ่านไฟล์ Parquet โดยระบุ URL แบบเต็มใน OPENROWSET คําสั่ง:
SELECT TOP 10 *
FROM OPENROWSET(
BULK 'https://<storage account>.blob.core.windows.net/public/<subfolder>/<file name>.parquet'
);
ในคิวรีนี้:
-
BULKอาร์กิวเมนต์ระบุ URI แบบเต็มของไฟล์ Parquet ในที่เก็บข้อมูล -
OPENROWSETอ่านเนื้อหาของไฟล์และส่งคืนเป็นชุดผลลัพธ์แบบตาราง - ชื่อคอลัมน์และชนิดข้อมูลจะถูกอนุมานโดยอัตโนมัติจากข้อมูลเมตาของไฟล์ Parquet
-
TOP 10ส่วนคําสั่งจํากัดชุดผลลัพธ์เพื่อให้ตรวจสอบข้อมูลได้ง่ายขึ้น
วิธีการนี้มีประโยชน์สําหรับการสํารวจไฟล์ Parquet แต่ละไฟล์อย่างรวดเร็วหรือตรวจสอบเนื้อหาไฟล์ก่อนที่จะใช้เทคนิคการคิวรีขั้นสูง เช่น คําจํากัดความ Schema ที่ชัดเจน การเข้าถึงไฟล์ที่ใช้สัญลักษณ์แทน หรือการกําหนดค่าแหล่งข้อมูลภายนอก
การใช้แหล่งข้อมูล
ตัวอย่างก่อนหน้านี้ระบุ URL แบบเต็มไปยังไฟล์โดยตรงใน OPENROWSET คําสั่ง อีกทางเลือกหนึ่งคือ คุณสามารถกําหนดแหล่งข้อมูลภายนอกที่ชี้ไปยังตําแหน่งรากของที่เก็บข้อมูลของคุณ แล้วอ้างอิงไฟล์โดยใช้เส้นทางสัมพัทธ์
การใช้แหล่งข้อมูลภายนอกช่วยลดความยุ่งยากในการสืบค้น ปรับปรุงความสามารถในการอ่าน และช่วยให้คุณสามารถจัดการตําแหน่งที่เก็บข้อมูลได้จากส่วนกลาง หากจุดสิ้นสุดที่เก็บข้อมูลมีการเปลี่ยนแปลง คุณจะต้องอัปเดตข้อกําหนดแหล่งข้อมูลเท่านั้น ไม่ใช่ทุกคิวรีที่อ้างอิง
ตัวอย่างต่อไปนี้สร้างแหล่งข้อมูลภายนอกที่ชี้ไปยังโฟลเดอร์ที่มีไฟล์ข้อมูล:
CREATE EXTERNAL DATA SOURCE sample_data_source
WITH ( LOCATION = 'https://<storage account>.blob.core.windows.net/public/<subfolder>' );
หลังจากที่คุณสร้างแหล่งข้อมูลภายนอกแล้ว ให้อ้างอิงแหล่งข้อมูลนั้นใน OPENROWSET ฟังก์ชันและระบุเส้นทางที่สัมพันธ์กับตําแหน่งที่ตั้งของแหล่งข้อมูล:
SELECT TOP 10 *
FROM OPENROWSET(
BULK '<subfolder>/<file name>.parquet',
DATA_SOURCE = 'sample_data_source'
) as rows;
ในตัวอย่าง DATA_SOURCE นี้ พารามิเตอร์จะแนะนําให้ OPENROWSET แก้ไขเส้นทางไฟล์ที่สัมพันธ์กับแหล่งข้อมูลภายนอก
ใช้แหล่งข้อมูลภายนอกเมื่อคุณคิวรีไฟล์จากบัญชีที่เก็บข้อมูลหรือคอนเทนเนอร์เดียวกันบ่อยๆ วิธีนี้ส่งเสริมการนํากลับมาใช้ใหม่ ปรับปรุงการบํารุงรักษา และทําให้คําจํากัดความของคิวรีกระชับ
ระบุ Schema อย่างชัดเจน
โดยค่าเริ่มต้น OPENROWSET จะใช้การอนุมาน Schema อัตโนมัติเพื่อกําหนดชื่อคอลัมน์และชนิดข้อมูลจากไฟล์ต้นฉบับ อย่างไรก็ตาม ในหลายสถานการณ์ คุณอาจต้องการกําหนด Schema อย่างชัดเจน เช่น เมื่อสอบถามไฟล์หลายไฟล์ ตรวจสอบให้แน่ใจว่า Schema ที่เสถียร หรือเลือกเฉพาะชุดย่อยของคอลัมน์
ใช้ส่วน WITH คําสั่ง in OPENROWSET เพื่อระบุคอลัมน์ที่จะอ่านและชนิดข้อมูลในชุดผลลัพธ์
ตัวอย่างต่อไปนี้สาธิตวิธีการกําหนด Schema อย่างชัดเจนเมื่ออ่านข้อมูลจากแฟ้ม Parquet:
SELECT TOP 10 *
FROM OPENROWSET(
BULK '<subfolder>/<file name>.parquet',
DATA_SOURCE = 'sample_data_source'
) WITH ( date_rep date, cases int, geo_id varchar(6) );
ในตัวอย่าง WITH นี้ ส่วนคําสั่งจะกําหนด Schema ผลลัพธ์โดยการระบุ:
- ชื่อคอลัมน์ (
date_rep,cases, )geo_id - ชนิดข้อมูลที่จะนําไปใช้กับแต่ละคอลัมน์ในผลลัพธ์แบบสอบถาม
เฉพาะคอลัมน์ที่แสดงในส่วน WITH คําสั่งเท่านั้นที่จะถูกส่งกลับ แม้ว่าไฟล์ Parquet จะมีคอลัมน์เพิ่มเติมก็ตาม วิธีการนี้ช่วยลดปริมาณข้อมูลที่อ่านและควบคุมรูปร่างของชุดผลลัพธ์
คําจํากัดความของ Schema ที่ชัดเจนมีความสําคัญอย่างยิ่งเมื่อ:
- การสืบค้นหลายไฟล์ที่ไม่มีชุดคอลัมน์เหมือนกัน
- คุณต้องการ Schema ที่กําหนดและเสถียรในการดําเนินการคิวรี
- คุณต้องการแทนที่ชนิดข้อมูลที่อนุมานหรือบังคับใช้ชนิดข้อมูลที่เฉพาะเจาะจง
- ไฟล์ต้นฉบับอาจพัฒนาไปตามกาลเวลาด้วยคอลัมน์ที่เพิ่มหรือคอลัมน์เสริม
เมื่อคุณกําหนด Schema OPENROWSET อย่างชัดเจน จะไม่อาศัยการอนุมาน Schema แต่จะใช้คําจํากัดความคอลัมน์ที่คุณระบุในส่วน WITH คําสั่งแทน เพื่อให้มั่นใจว่าผลลัพธ์คิวรีที่สอดคล้องกันและคาดเดาได้
สืบค้นชุดไฟล์ปาร์เก้ด้วย OPENROWSET
ฟังก์ชันนี้ OPENROWSET สนับสนุนการสืบค้นไฟล์หลายไฟล์ในคําสั่งเดียว โดยอนุญาตให้คุณระบุเส้นทางไฟล์ที่มีอักขระตัวแทน (*)
สัญลักษณ์ตัวแทนช่วยให้คุณสามารถกําหนดรูปแบบ URI ที่แสดงถึงชุดของไฟล์หรือโฟลเดอร์แทนที่จะเป็นไฟล์เดียว เมื่อใช้สัญลักษณ์ตัวแทนในเส้นทางไฟล์ ไฟล์ทั้งหมดที่ตรงกับรูปแบบ URI ที่ระบุจะถูกอ่านและรวมเป็นชุดผลลัพธ์เดียว
วิธีนี้มักใช้เมื่อสอบถามข้อมูลที่แบ่งพาร์ติชัน เช่น ไฟล์ที่จัดระเบียบตามวันที่ ภูมิภาค หรือโครงสร้างโฟลเดอร์ตามลําดับชั้นอื่นๆ
ตัวอย่างเช่น คุณสามารถใช้สัญลักษณ์ตัวแทนเพื่อ:
- สืบค้นไฟล์ทั้งหมดภายในโฟลเดอร์ที่ระบุ
- สืบค้นไฟล์ในโฟลเดอร์ย่อยหลายโฟลเดอร์
- แฟ้มแบบสอบถามที่ใช้รูปแบบการตั้งชื่อร่วมกัน
SELECT *
FROM OPENROWSET(
BULK '/Files/puYear=*/puMonth=*/*.snappy.parquet',
DATA_SOURCE = 'YellowTaxi'
);
ในตัวอย่างนี้ อักขระตัวแทน (*) สั่งให้เซอร์วิสอ่านไฟล์ Parquet ทั้งหมดที่ตรงกับโฟลเดอร์และรูปแบบชื่อไฟล์ที่ระบุ
รูปแบบไฟล์ที่ใช้ Wildcard เป็นวิธีที่ยืดหยุ่นและปรับขนาดได้ในการสืบค้นคอลเลกชันไฟล์ขนาดใหญ่โดยตรงจากที่เก็บข้อมูลโดยไม่จําเป็นต้องทราบชื่อไฟล์ที่แน่นอน
Note
ตัวอย่างนี้ใช้ เส้นทางสัมพัทธ์ที่ไม่มีแหล่งข้อมูล ซึ่งทํางานเมื่อสืบค้นไฟล์ใน Lakehouse ของคุณผ่านตําแหน่งข้อมูลการวิเคราะห์ SQL ใน Fabric คลังข้อมูล คุณต้อง:
- ใช้เส้นทางแบบ สัมบูรณ์ ไปยังไฟล์ หรือ
- ระบุ URL ราก ในแหล่งข้อมูลภายนอก และอ้างอิงใน
OPENROWSETคําสั่งโดยใช้DATA_SOURCEตัวเลือก
สืบค้นข้อมูลที่แบ่งพาร์ติชันด้วย OPENROWSET
การแบ่งพาร์ติชันชุดข้อมูลที่จัดเก็บไว้ในที่จัดเก็บข้อมูลดิบเป็นโฟลเดอร์ย่อยช่วยปรับปรุงประสิทธิภาพและองค์กร
รูปแบบทั่วไปคือการแบ่งพาร์ติชันแบบ Hive หรือ Hadoop โดยที่ชื่อโฟลเดอร์จะเข้ารหัสค่าพาร์ติชัน เช่น ปี เดือน หรือภูมิภาค
ชุดข้อมูลตัวอย่างที่ใช้ในตัวอย่างนี้จะถูกแบ่งพาร์ติชันเป็นโฟลเดอร์ย่อยแยกต่างหากตามปีการรับสินค้า (puYear) และเดือนการรับสินค้า (puMonth) ฟังก์ชันนี้ OPENROWSET สามารถอ่านข้อมูลที่จัดระเบียบได้โดยตรงโดยใช้รูปแบบการแบ่งพาร์ติชันนี้
ตัวอย่างต่อไปนี้สาธิตวิธีการสืบค้นข้อมูล Parquet ที่แบ่งพาร์ติชันและแยกค่าพาร์ติชันจากเส้นทางไฟล์ โดยส่งคืนข้อมูลการเดินทางในช่วงสามเดือนแรกของปี 2017:
SELECT
CAST( nyc.filepath(2) AS INT), *
FROM
OPENROWSET(
BULK '/Files/puYear=*/puMonth=*/*.snappy.parquet',
DATA_SOURCE = 'YellowTaxi'
) AS nyc
WHERE
nyc.filepath(1) = '2017'
AND nyc.filepath(2) IN (1, 2, 3);
อ่านประเภทที่ซับซ้อนด้วย OPENROWSET
Fabric คลังข้อมูล และตําแหน่งข้อมูลการวิเคราะห์ SQL สามารถอ่านคอลัมน์ Parquet ที่มีชนิดที่ซับซ้อน เช่น โครงสร้างหรือเรกคอร์ด และอาร์เรย์หรือฟิลด์ซ้ํา เมื่อคุณฉายภาพคอลัมน์เหล่านี้ผ่าน OPENROWSETคิวรีจะส่งคืนค่าจากคอลัมน์ที่ซับซ้อนเหล่านี้เป็นข้อความ JSON และแสดงเป็นคอลัมน์ varchar :
- โครงสร้าง (เรกคอร์ด) จะถูกส่งคืนเป็นออบเจ็กต์ JSON ตัวอย่างเช่น
{"a":1,"b":"x"}. - อาร์เรย์ (ฟิลด์ที่ซ้ํากัน) จะถูกส่งกลับเป็นอาร์เรย์ JSON ตัวอย่างเช่น
[1,2,3].
ตัวอย่างต่อไปนี้แสดงวิธีการอ่านทั้งโครงสร้างและอาร์เรย์จากไฟล์ Parquet เดียวกัน และส่งคืนเป็นข้อความ JSON ออบเจ็กต์ JSON และคอลัมน์อาร์เรย์ถูกฉายเป็น varchar(max)
SELECT
StructCol, -- JSON object (for example, {"id":123,"name":"Ada","tags":["ml","sql"]})
ArrayCol -- JSON array (for example, [11,12,13])
FROM
OPENROWSET(
BULK '/Files/parquet/nested/complexExample.parquet',
DATA_SOURCE = 'MyDataSource')
WITH ( -- Project complex Parquet columns as VARCHAR to receive JSON text.
StructCol VARCHAR(MAX),
ArrayCol VARCHAR(MAX) );
เนื้อหาของทุกค่าที่ซ้อนกันจะถูกส่งคืนเป็นข้อความ JSON
| สตรัคคอล | อาร์เรย์คอล |
|---|---|
{"id":123,"name":"Ada","tags":["ml","sql"]} |
[11,12,13] |
{"id":456,"name":"Nik","tags":["dw","ai"]} |
[21,22] |
- ใช้ varchar(8000) หรือประเภทที่ใหญ่กว่า เช่น varchar(max) เพื่อรองรับเพย์โหลด JSON ขนาดใหญ่ที่ส่งคืนจากคอลัมน์ Parquet ที่ซับซ้อนอย่างปลอดภัย
- คุณสามารถฉายภาพเขตข้อมูลที่ซับซ้อนเพิ่มเติม เช่น โครงสร้างที่ซ้อนกันหรืออาร์เรย์ของโครงสร้าง โดยการเพิ่มคอลัมน์ varchar เพิ่มเติมในส่วน
WITHคําสั่ง แต่ละฟิลด์ที่ซับซ้อนจะส่งคืนเป็นข้อความ JSON
เข้าถึงคุณสมบัติหรือองค์ประกอบของชนิดที่ซ้อนกัน
ในหลายกรณี คุณไม่จําเป็นต้องใช้ประเภทที่ซับซ้อนทั้งหมดเป็น JSON คุณต้องมีคุณสมบัติหรือองค์ประกอบเฉพาะสําหรับการกรอง การรวม หรือการวิเคราะห์
คุณสามารถเข้าถึงคุณสมบัติหรือองค์ประกอบเหล่านี้ได้สามวิธี:
- ใช้ฟังก์ชัน JSON - ใช้
JSON_VALUE(สเกลาร์) หรือJSON_QUERY(วัตถุ/อาร์เรย์) เหนือข้อความ JSON ที่ส่งคืนจากคอลัมน์ที่ซับซ้อน - ชื่อคอลัมน์เส้นทางจุด (structs) - ระบุ
.ชื่อคอลัมน์ที่คั่น (ตัวอย่างเช่น[Struct.prop] TYPE) ในส่วนWITHคําสั่งเพื่อฉายเขตข้อมูลที่ซ้อนกันของโครงสร้างไปยังคอลัมน์สเกลาร์โดยตรง - เส้นทาง JSON หลังจากประเภท - ระบุนิพจน์เส้นทาง JSON หลังประเภทในส่วน
WITHคําสั่ง (เช่นCol INT '$.Struct.prop') เพื่อแยกค่าสเกลาร์ที่ซ้อนกัน
ตัวอย่างต่อไปนี้แสดงวิธีการเข้าถึงฟิลด์ที่ซ้อนกันใน Parquet:
SELECT
-- Raw complex values (JSON text)
UserStruct, -- for example, {"id":123,"name":"Ada","scores":[11,12,13]}
ScoresArray, -- for example, [11,12,13]
-- Access struct fields via JSON_VALUE
JSON_VALUE(UserStruct, '$.id') AS UserId_json,
JSON_VALUE(UserStruct, '$.name') AS UserName_json,
-- Access array elements via JSON_VALUE (0-based)
JSON_VALUE(ScoresArray, '$[0]') AS Score1,
JSON_VALUE(ScoresArray, '$[1]') AS Score2,
JSON_VALUE(ScoresArray, '$[2]') AS Score3
FROM
OPENROWSET(
BULK '/Files/parquet/nested/complexExample.parquet',
DATA_SOURCE = 'MyDataSource',
FORMAT = 'PARQUET'
)
WITH (
-- Complex columns as JSON text
UserStruct VARCHAR(8000) '$.UserStruct',
ScoresArray VARCHAR(8000) '$.ScoresArray',
-- Option A: JSON path after type
UserId INT '$.UserStruct.id',
UserName VARCHAR(200) '$.UserStruct.name',
-- Option B: Dot-path column names
[UserStruct.id] INT,
[UserStruct.name] VARCHAR(200)
) AS r;
ตารางต่อไปนี้แสดงผลลัพธ์ตัวอย่างที่ส่งกลับโดยคิวรีที่ฉายทั้งคอลัมน์ดิบที่ซับซ้อนและคุณสมบัติที่แยกออกมาโดยใช้วิธีการที่แตกต่างกัน:
UserStruct |
ScoresArray |
UserId_fromJsonValue |
UserName_fromJsonValue |
UserId |
UserName |
UserStruct.id |
UserStruct.name |
|---|---|---|---|---|---|---|---|
{"id":123,"name":"Ada","scores":[11,12,13]} |
[11,12,13] |
123 | Ada |
123 | Ada |
123 | Ada |
{"id":456,"name":"Nik","scores":[21,22,23]} |
[21,22,23] |
456 | Nik |
456 | Nik |
456 | Nik |
ขยายอาร์เรย์
ไฟล์ Parquet อาจมีอาร์เรย์ที่มีจํานวนองค์ประกอบที่แปรผันในอาร์เรย์ ซึ่งการเข้าถึงค่าโดยดัชนีที่ฮาร์ดโค้ดไม่ใช่ทางออกที่ดี ตัวอย่างของไฟล์ Parquet ประเภทนี้แสดงในตารางต่อไปนี้:
| รหัส | อาร์เรย์ |
|---|---|
| 1 | [11,12,13] |
| 2 | [21,22] |
ในกรณีนี้ คุณสามารถขยายอาร์เรย์และรวมองค์ประกอบกับแถวหลักได้โดยใช้OPENJSON เมื่อคอลัมน์ Parquet มีอาร์เรย์ (ตัวอย่างเช่น [1,2,3]) คุณอาจต้องการทําให้แบน (ขยาย) องค์ประกอบของอาร์เรย์เพื่อให้แต่ละรายการอาร์เรย์ปรากฏบนแถวที่แยกจากกันควบคู่ไปกับข้อมูลแถวหลักเดิม
คุณสามารถทําได้โดยนําไปใช้ CROSS APPLY OPENJSON(...) กับข้อความ JSON ที่ส่งคืนจากคอลัมน์อาร์เรย์
SELECT
r.Id, -- Example parent column (if present in your file)
r.Array, -- Raw JSON array text
a.Element -- Flattened scalar value from the array
FROM
OPENROWSET(
BULK '/Files/parquet/nested/justSimpleArray.parquet',
DATA_SOURCE = 'MyDataSource'
)
WITH ( Id INT, Array VARCHAR(MAX) )
AS r
CROSS APPLY OPENJSON(r.Array)
WITH (Element INT '$' ) AS a;
OPENROWSET ฉายภาพคอลัมน์อาร์เรย์ (Array) เป็นอาร์เรย์ JSON และส่งคืนหนึ่งแถวต่อองค์ประกอบอาร์เรย์ คุณจึงสามารถรวมค่าอาร์เรย์กับคอลัมน์หลัก (เช่น Id) ผลลัพธ์ของแบบสอบถามนี้อาจมีลักษณะดังนี้
| รหัส | อาร์เรย์ | องค์ ประกอบ |
|---|---|---|
| 1 | [11,12,13] |
11 |
| 1 | [11,12,13] |
12 |
| 1 | [11,12,13] |
13 |
| 2 | [21,22,23] |
21 |
| 2 | [21,22,23] |
22 |
สําหรับอาร์เรย์ของวัตถุ ให้แทนที่ WITH ส่วนคําสั่งภายใน OPENJSON เพื่อแมปคุณสมบัติของวัตถุ ตัวอย่างเช่น:
CROSS APPLY OPENJSON(r.Array)
WITH (
ItemId INT,
ItemName VARCHAR(200) ) AS a
การแม็ปชนิด
ไฟล์ Parquet มีคําอธิบายประเภทสําหรับทุกคอลัมน์
ตารางต่อไปนี้อธิบายวิธีที่ชนิด Parquet แมปกับชนิดดั้งเดิมของ SQL ที่ OPENROWSET ฟังก์ชันส่งกลับ
| ประเภทปาร์เก้ | ประเภทตรรกะของไม้ปาร์เก้ (คําอธิบายประกอบ) | ชนิดข้อมูล SQL |
|---|---|---|
| บูลีน | บิต | |
| ไบนารี / BYTE_ARRAY | varbinary | |
| คู่ | เลขทศนิยม | |
| ลอย | จริง | |
| อินที 32 | Int | |
| อินที 64 | bigint | |
| รุ่น 96 | วันที่และเวลา 2 | |
| FIXED_LEN_BYTE_ARRAY | ไบ นารี | |
| ไบ นารี | ยูทีเอฟ 8 | วาร์ชาร์ * |
| ไบ นารี | เชือก | วาร์ชาร์ * |
| ไบ นารี | ENUM | วาร์ชาร์ * |
| FIXED_LEN_BYTE_ARRAY | ยูอี | ตัวระบุที่ไม่ซ้ํากัน |
| ไบ นารี | ทศนิยม | ทศนิยม |
| ไบ นารี | JSON | varchar (สูงสุด) * |
| ไบ นารี | BSON | ไม่รองรับ |
| FIXED_LEN_BYTE_ARRAY | ทศนิยม | ทศนิยม |
| BYTE_ARRAY | ช่วงเวลา | ไม่รองรับ |
| อินที 32 | INT(8, จริง) | smallint |
| อินที 32 | INT(16, จริง) | smallint |
| อินที 32 | INT(32, จริง) | Int |
| อินที 32 | INT(8, เท็จ) | tinyint |
| อินที 32 | INT(16, เท็จ) | Int |
| อินที 32 | INT(32, เท็จ) | bigint |
| อินที 32 | วันที่ | วันที่ |
| อินที 32 | ทศนิยม | ทศนิยม |
| อินที 32 | เวลา (มิลลิ) | เวลา |
| อินที 64 | INT(64, จริง) | bigint |
| อินที 64 | INT(64, เท็จ) | ทศนิยม(20,0) |
| อินที 64 | ทศนิยม | ทศนิยม |
| อินที 64 | เวลา (ไมโคร) | เวลา |
| อินที 64 | เวลา (นาโน) | ไม่รองรับ |
| อินที 64 | TIMESTAMP (ปรับให้เป็นมาตรฐานเป็น utc) (MILLIS / MICROS) | วันที่และเวลา 2 |
| อินที 64 | TIMESTAMP (ไม่ทําให้เป็นมาตรฐานเป็น utc) (MILLIS / MICROS) | บิจินต์ ** |
| อินที 64 | การประทับเวลา (นาโน) | ไม่รองรับ |
| ประเภทที่ซับซ้อน | รายการ | varchar(max) ที่ต่อเนื่องเป็น JSON |
| ประเภทที่ซับซ้อน | แผนที่ | varchar(max) ที่ต่อเนื่องเป็น JSON |
* (การเปรียบเทียบ UTF8)
** คุณควรปรับค่า bigint อย่างชัดเจนด้วยออฟเซ็ตเขตเวลาก่อนที่จะแปลงเป็นค่าวันที่และเวลา