calamine

 
 

ไลบรารี Rust แท้สำหรับสเปรดชีต

อ่าน XLS, XLSX, XLSM, XLSB, ODS และอื่น ๆ ด้วยการแปลงข้อมูลแบบไม่มีการคัดลอกใน Rust.

calamine คืออะไร?

calamine เป็นไลบรารี Rust แท้ที่มีประสิทธิภาพสูงสำหรับการอ่านและทำการ deserialize ไฟล์สเปรดชีต Excel และ OpenDocument มันรองรับรูปแบบเช่น XLS, XLSX, XLSM, XLSB, ODS และอื่น ๆ โดยมุ่งเน้นการสกัดข้อมูลที่เร็ว ปลอดภัย และไม่มีการคัดลอกข้อมูล (zero-copy) ถูกออกแบบเพื่อความน่าเชื่อถือและการพึ่งพาน้อยที่สุด calamine ไม่ใช้ไลบรารีระบบภายนอกและพึ่งพาเพียงการทำงานของ Rust เท่านั้น API ของมันทำให้ผู้พัฒนาสามารถสกัดค่าของเซลล์ได้อย่างมีประสิทธิภาพ จัดการโครงการ VBA และแยกสูตรได้โดยไม่ต้องตั้งค่าซับซ้อนหรือภาระการทำงานในขณะรันไทม์

ไลบรารีนี้โดดเด่นในแอปพลิเคชันที่ต้องการประสิทธิภาพสูง โดยให้การประมวลผลที่เร็วกว่าอย่างมีนัยสำคัญเมื่อเทียบกับทางเลือกใน Python, C# และ Go ด้วยการรวม Serde ในตัว calamine ทำให้สามารถแมปข้อมูลสเปรดชีตไปยังโครงสร้าง Rust ได้อย่างราบรื่น รองรับการโหลดแบบ lazy สำหรับไฟล์ขนาดใหญ่ การกำหนดแถวหัวตาราง และคุณลักษณะเสริมเช่นการสนับสนุนวันที่/เวลาแบบ chrono และการสกัดข้อมูลรูปภาพ ไม่ว่าคุณจะสร้างเครื่องมือ CLI, backend เว็บ หรือระบบฝังตัว calamine จะมอบประสิทธิภาพที่มั่นคงและคาดการณ์ได้บนทุกแพลตฟอร์ม

Previous Next

เริ่มต้นใช้งาน calamine

เพื่อเริ่มใช้ calamine ให้เพิ่มมันลงในโปรเจกต์ Rust ของคุณผ่าน Cargo. คุณสามารถติดตั้งโดยตรงโดยใช้ cargo add calamine หรือเพิ่มการพึ่งพาในไฟล์ Cargo.toml ของคุณด้วยตนเอง. ไลบรารีนี้พร้อมใช้งานบน crates.io และซอร์สโค้ดของมันโฮสต์บน GitHub ของ calamine. สำหรับการใช้งานขั้นสูง ให้เปิดใช้งานฟีเจอร์เสริมเช่น chrono สำหรับการสนับสนุนวันที่/เวลา หรือ picture สำหรับการสกัดข้อมูลรูปภาพ. ไลบรารีนี้คอมไพล์ได้อย่างราบรื่นบน Rust เวอร์ชันเสถียรและไม่ต้องการไบนารีหรือไลบรารีระบบภายนอก.

ติดตั้ง calamine ผ่าน Cargo

cargo add calamine

การแปลงข้อมูลสเปรดชีตโดยใช้ Serde

calamine ให้การรวม Serde ที่ทรงพลังสำหรับการแมปข้อมูลสเปรดชีตโดยตรงไปยังโครงสร้าง Rust. โดยใช้ RangeDeserializerBuilder นักพัฒนาสามารถกำหนดโมเดลข้อมูลที่มีประเภทอย่างเข้มงวดและทำการ deserialize แถวโดยอัตโนมัติเป็นบันทึกที่มีโครงสร้าง. ไลบรารีนี้รวมฟังก์ชันช่วยเหลือเช่น deserialize_as_f64_or_none และ deserialize_as_f64_or_string เพื่อจัดการคอลัมน์ที่มีประเภทผสมอย่างราบรื่น. วิธีนี้รับประกันความปลอดภัยของประเภท, ลดโค้ดซ้ำซ้อน, และเปิดใช้งานการตรวจสอบความถูกต้องของโครงสร้างข้อมูลในช่วงคอมไพล์. มันมีประโยชน์อย่างยิ่งสำหรับ pipelines ข้อมูล, เครื่องมือรายงาน, และแอปพลิเคชัน ETL ที่ความน่าเชื่อถือและประสิทธิภาพเป็นสิ่งสำคัญ.

แปลงแถวสเปรดชีตเป็นโครงสร้างของ Rust

use calamine::{deserialize_as_f64_or_none, open_workbook, RangeDeserializerBuilder, Reader, Xlsx};
use serde::Deserialize;

#[derive(Deserialize)]
struct Record {
    metric: String,
    #[serde(deserialize_with = "deserialize_as_f64_or_none")]
    value: Option,
}

let mut excel: Xlsx<_> = open_workbook("file.xlsx")?;
let range = excel.worksheet_range("Sheet1")?;
let iter = RangeDeserializerBuilder::with_headers(&["metric", "value"]).from_range(&range)?;
for result in iter {
    let record: Record = result?;
    println!("{:?}", record);
}

การสกัดโครงการ VBA และสูตร

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

สกัดโค้ด VBA และชื่อที่กำหนดไว้

use calamine::{open_workbook_auto, Reader};

let mut workbook = open_workbook_auto("file.xlsx")?;
if let Ok(Some(vba)) = workbook.vba_project() {
    let module = vba.get_module("Module1").unwrap();
    println!("{}", module);
    for ref in vba.get_references() {
        if ref.is_missing() { println!("Broken: {}", ref.name); }
    }
}
for (name, formula) in workbook.defined_names() {
    println!("{}: {}", name, formula);
}

การโหลดแบบขี้เกียจและการจัดการไฟล์ขนาดใหญ่

calamine รองรับการโหลดแบบ lazy สำหรับไฟล์ XLSX และ XLSB ทำให้สามารถประมวลผลสเปรดชีตขนาดใหญ่ได้อย่างมีประสิทธิภาพโดยไม่ต้องโหลดทุกชีตเข้าสู่หน่วยความจำพร้อมกัน โดยการกำหนดแถวหัวตารางและใช้การวนซ้ำแบบช่วง นักพัฒนาสามารถลดการใช้หน่วยความจำและเพิ่มอัตราการทำงานได้สูงสุด ฟีเจอร์นี้มีคุณค่าเป็นพิเศษสำหรับฟังก์ชันแบบ serverless, เครื่องมือ CLI, และการปรับใช้แบบฝังที่ทรัพยากรจำกัด การทดสอบเบนช์มาร์คแสดงให้เห็นว่า calamine สามารถอ่านข้อมูลมากกว่า 1 ล้านแถวด้วยการใช้หน่วยความจำขั้นต่ำเมื่อเทียบกับทางเลือกเช่น openpyxl และ ClosedXML ทำให้เป็นตัวเลือกที่เหมาะสำหรับสายงานการนำเข้าข้อมูลขนาดใหญ่

ประมวลผลสเปรดชีตขนาดใหญ่อย่างมีประสิทธิภาพ

use calamine::{open_workbook, Reader, Xlsx};

let mut excel: Xlsx<_> = open_workbook("large.xlsx")?;
let range = excel
    .worksheet_range("Sheet1")?
    .expect("Sheet not found");

for row in range.rows() {
    // Process row without loading entire file
    process_row(row);
}

การเพิ่มประสิทธิภาพและการวัดผล

calamine ให้ประสิทธิภาพที่ยอดเยี่ยม โดยประมวลผลเซลล์ 41 ล้านเซลล์ภายในเวลาไม่ถึง 25 วินาที—เหนือกว่าไลบรารีของ Python, C#, และ Go ถึง 9.4 เท่า การออกแบบแบบ zero-copy และการจัดสรร heap ขั้นต่ำช่วยลดการใช้ CPU และหน่วยความจำอย่างมีนัยสำคัญ การทดสอบบนไฟล์ XLSX ขนาด 186 MB แสดงให้เห็นว่า calamine ใช้การอ่านจากดิสก์เพียง 186 MB เท่านั้น เทียบกับ 1.5 GB ของ excelize พฤติกรรมหน่วยความจำที่กำหนดได้และแรงกดดัน GC ต่ำทำให้ไลบรารีนี้เหมาะสำหรับแอปพลิเคชันแบบเรียลไทม์และที่ต้องการความหน่วงต่ำ นักพัฒนาจะได้รับประโยชน์จากการใช้ทรัพยากรที่คาดการณ์ได้และอัตราการส่งผ่านที่สม่ำเสมอในงานที่หลากหลาย

 ไทย