1pub mod csv;
17pub mod images;
18pub mod merges;
19pub mod shared_strings;
20pub mod sheet_meta;
21pub mod source;
22pub mod stream;
23pub mod styles;
24pub mod workbook;
25
26use std::path::Path;
27use std::sync::Arc;
28
29use crate::column::ColumnDef;
30use crate::error::{ExcelError, Result};
31use crate::header::{HeaderAnalysis, HeaderMap, HeaderOptions};
32use crate::model::{DynamicRow, ExcelRow, RowData};
33use crate::value::CellValue;
34
35pub use crate::value::CellImage;
36pub use csv::CsvReader;
37pub use images::{
38 ExtractedImages, extract_all_images, extract_embedded_images, extract_images_of_sheet,
39 extract_wps_cellimages, parse_dispimg_id,
40};
41pub use merges::MergeRange;
42pub use sheet_meta::{CfRule, Comment, ConditionalFormat, DataValidation, Hyperlink};
43pub use shared_strings::SharedStrings;
44pub use source::{EntryReader, ZipSource};
45pub use stream::SheetStream;
46pub use styles::{CellStyle, Styles};
47pub use workbook::SheetInfo;
48
49#[derive(Clone)]
53pub struct ComputedColumn {
54 pub def: ColumnDef,
56 expr: Arc<dyn for<'a> Fn(&RowData<'a>) -> CellValue + Send + Sync>,
57}
58
59impl ComputedColumn {
60 pub fn new<F>(def: ColumnDef, expr: F) -> Self
61 where
62 F: for<'a> Fn(&RowData<'a>) -> CellValue + Send + Sync + 'static,
63 {
64 Self {
65 def,
66 expr: Arc::new(expr),
67 }
68 }
69
70 pub fn eval<'a>(&self, row: &RowData<'a>) -> CellValue {
72 (self.expr)(row)
73 }
74
75 pub fn header(&self) -> &str {
76 &self.def.header
77 }
78}
79
80impl std::fmt::Debug for ComputedColumn {
81 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
82 f.debug_struct("ComputedColumn")
83 .field("def", &self.def)
84 .finish_non_exhaustive()
85 }
86}
87
88#[derive(Clone)]
90pub struct RowFilter(Arc<dyn for<'a> Fn(&RowData<'a>) -> bool + Send + Sync>);
91
92impl RowFilter {
93 pub fn new<F>(f: F) -> Self
94 where
95 F: for<'a> Fn(&RowData<'a>) -> bool + Send + Sync + 'static,
96 {
97 Self(Arc::new(f))
98 }
99
100 pub fn keep<'a>(&self, row: &RowData<'a>) -> bool {
102 (self.0)(row)
103 }
104}
105
106impl std::fmt::Debug for RowFilter {
107 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
108 f.write_str("RowFilter")
109 }
110}
111
112#[derive(Debug, Clone, PartialEq, Eq)]
114pub enum SheetSelector {
115 First,
117 Index(u32),
119 Name(String),
121 Names(Vec<String>),
123 All,
125}
126
127impl SheetSelector {
128 pub fn name(name: impl Into<String>) -> Self {
129 SheetSelector::Name(name.into())
130 }
131
132 pub fn names<I, S>(names: I) -> Self
133 where
134 I: IntoIterator<Item = S>,
135 S: Into<String>,
136 {
137 SheetSelector::Names(names.into_iter().map(Into::into).collect())
138 }
139}
140
141#[derive(Debug, Clone)]
143pub struct ReadOptions {
144 pub header: HeaderOptions,
146 pub max_rows: Option<u64>,
148 pub skip_empty_rows: bool,
150 pub read_images: bool,
152 pub image_columns: Option<Vec<u16>>,
154 pub read_merges: bool,
160 pub fill_merged: bool,
162 pub read_hyperlinks: bool,
164 pub read_comments: bool,
166 pub read_validations: bool,
168 pub read_conditional_formats: bool,
170 pub computed: Vec<ComputedColumn>,
172 pub row_filter: Option<RowFilter>,
174 pub trim_text: bool,
176}
177
178impl Default for ReadOptions {
179 fn default() -> Self {
180 Self {
181 header: HeaderOptions::default(),
182 max_rows: None,
183 skip_empty_rows: true,
184 read_images: false,
185 image_columns: None,
186 read_merges: false,
187 fill_merged: true,
188 read_hyperlinks: false,
189 read_comments: false,
190 read_validations: false,
191 read_conditional_formats: false,
192 computed: Vec::new(),
193 row_filter: None,
194 trim_text: true,
195 }
196 }
197}
198
199impl ReadOptions {
200 pub fn new() -> Self {
201 Self::default()
202 }
203
204 pub fn header_options(mut self, header: HeaderOptions) -> Self {
205 self.header = header;
206 self
207 }
208
209 pub fn header_row(mut self, row_index: u32) -> Self {
210 self.header.row_index = row_index;
211 self
212 }
213
214 pub fn header_span(mut self, span: u32) -> Self {
215 self.header.row_span = span.max(1);
216 self
217 }
218
219 pub fn max_rows(mut self, rows: u64) -> Self {
220 self.max_rows = Some(rows);
221 self
222 }
223
224 pub fn with_images(mut self) -> Self {
226 self.read_images = true;
227 self
228 }
229
230 pub fn image_columns(mut self, cols: Vec<u16>) -> Self {
232 self.image_columns = Some(cols);
233 self
234 }
235
236 pub fn with_merges(mut self) -> Self {
240 self.read_merges = true;
241 self.fill_merged = true;
242 self
243 }
244
245 pub fn without_merges(mut self) -> Self {
247 self.read_merges = false;
248 self
249 }
250
251 pub fn merges_exposed_only(mut self) -> Self {
253 self.read_merges = true;
254 self.fill_merged = false;
255 self
256 }
257
258 pub fn with_hyperlinks(mut self) -> Self {
260 self.read_hyperlinks = true;
261 self
262 }
263
264 pub fn with_comments(mut self) -> Self {
266 self.read_comments = true;
267 self
268 }
269
270 pub fn with_validations(mut self) -> Self {
272 self.read_validations = true;
273 self
274 }
275
276 pub fn with_conditional_formats(mut self) -> Self {
278 self.read_conditional_formats = true;
279 self
280 }
281
282 pub fn computed<F>(mut self, def: ColumnDef, expr: F) -> Self
294 where
295 F: for<'a> Fn(&RowData<'a>) -> CellValue + Send + Sync + 'static,
296 {
297 self.computed.push(ComputedColumn::new(def, expr));
298 self
299 }
300
301 pub fn row_filter<F>(mut self, f: F) -> Self
311 where
312 F: for<'a> Fn(&RowData<'a>) -> bool + Send + Sync + 'static,
313 {
314 self.row_filter = Some(RowFilter::new(f));
315 self
316 }
317
318 pub fn skip_empty_rows(mut self, skip: bool) -> Self {
319 self.skip_empty_rows = skip;
320 self
321 }
322
323 pub fn trim_text(mut self, trim: bool) -> Self {
324 self.trim_text = trim;
325 self
326 }
327}
328
329pub struct ExcelReader {
331 source: ZipSource,
332 sheets: Vec<SheetInfo>,
333 date_1904: bool,
334 shared: Arc<SharedStrings>,
335 styles: Arc<Styles>,
336}
337
338impl ExcelReader {
339 pub fn open<P: AsRef<Path>>(path: P) -> Result<Self> {
341 Self::from_source(ZipSource::open(path)?)
342 }
343
344 pub fn from_bytes(bytes: Vec<u8>) -> Result<Self> {
346 Self::from_source(ZipSource::from_bytes(bytes))
347 }
348
349 pub fn from_source(source: ZipSource) -> Result<Self> {
351 let (sheets, date_1904) = workbook::load_sheets(&source)?;
352 let shared = match source.entry_reader("xl/sharedStrings.xml") {
354 Ok(reader) => SharedStrings::parse(std::io::BufReader::new(reader))?,
355 Err(_) => SharedStrings::empty(),
356 };
357 let styles = match source.entry_reader("xl/styles.xml") {
358 Ok(reader) => Styles::parse(std::io::BufReader::new(reader))?,
359 Err(_) => Styles::empty(),
360 };
361 Ok(Self {
362 source,
363 sheets,
364 date_1904,
365 shared: Arc::new(shared),
366 styles: Arc::new(styles),
367 })
368 }
369
370 pub fn source(&self) -> &ZipSource {
371 &self.source
372 }
373
374 pub fn sheets(&self) -> &[SheetInfo] {
375 &self.sheets
376 }
377
378 pub fn sheet_names(&self) -> Vec<String> {
379 self.sheets.iter().map(|s| s.name.clone()).collect()
380 }
381
382 pub fn date_1904(&self) -> bool {
383 self.date_1904
384 }
385
386 pub fn shared_strings(&self) -> &SharedStrings {
387 &self.shared
388 }
389
390 pub fn styles(&self) -> &Styles {
392 &self.styles
393 }
394
395 pub fn select(&self, selector: &SheetSelector) -> Result<Vec<&SheetInfo>> {
397 let found: Vec<&SheetInfo> = match selector {
398 SheetSelector::First => self.sheets.first().into_iter().collect(),
399 SheetSelector::Index(i) => self.sheets.iter().filter(|s| s.index == *i).collect(),
400 SheetSelector::Name(name) => self.sheets.iter().filter(|s| &s.name == name).collect(),
401 SheetSelector::Names(names) => names
402 .iter()
403 .map(|n| {
404 self.sheets
405 .iter()
406 .find(|s| &s.name == n)
407 .ok_or_else(|| ExcelError::SheetNotFound(n.clone()))
408 })
409 .collect::<Result<Vec<_>>>()?,
410 SheetSelector::All => self.sheets.iter().collect(),
411 };
412 if found.is_empty() {
413 return Err(ExcelError::SheetNotFound(match selector {
414 SheetSelector::First => "第一个工作表".to_string(),
415 SheetSelector::Index(i) => format!("下标 {i}"),
416 SheetSelector::Name(n) => n.clone(),
417 SheetSelector::Names(n) => n.join("、"),
418 SheetSelector::All => "任意工作表".to_string(),
419 }));
420 }
421 Ok(found)
422 }
423
424 pub fn stream(
426 &self,
427 selector: SheetSelector,
428 defs: &[ColumnDef],
429 options: ReadOptions,
430 ) -> Result<SheetStream> {
431 let sheets = self.select(&selector)?;
432 let sheet = sheets[0];
433 self.stream_sheet(sheet, defs, options)
434 }
435
436 pub fn stream_sheet(
438 &self,
439 sheet: &SheetInfo,
440 defs: &[ColumnDef],
441 options: ReadOptions,
442 ) -> Result<SheetStream> {
443 SheetStream::new(
444 self.source.clone(),
445 &sheet.path,
446 &sheet.name,
447 self.date_1904,
448 self.shared.clone(),
449 self.styles.clone(),
450 defs,
451 options,
452 )
453 }
454
455 pub fn analyze_header(
457 &self,
458 selector: &SheetSelector,
459 defs: &[ColumnDef],
460 options: ReadOptions,
461 ) -> Result<HeaderAnalysis> {
462 let sheets = self.select(selector)?;
463 let mut stream = self.stream_sheet(sheets[0], defs, options)?;
464 let _ = stream.next_row()?;
466 Ok(stream
467 .header_analysis()
468 .unwrap_or_else(|| HeaderMap::dynamic(Vec::new()).analysis()))
469 }
470
471 pub fn analyze_all_headers(
473 &self,
474 defs: &[ColumnDef],
475 options: ReadOptions,
476 ) -> Result<Vec<(String, HeaderAnalysis)>> {
477 let mut out = Vec::with_capacity(self.sheets.len());
478 for sheet in &self.sheets {
479 let mut stream = self.stream_sheet(sheet, defs, options.clone())?;
480 let _ = stream.next_row()?;
481 let analysis = stream
482 .header_analysis()
483 .unwrap_or_else(|| HeaderMap::dynamic(Vec::new()).analysis());
484 out.push((sheet.name.clone(), analysis));
485 }
486 Ok(out)
487 }
488
489 pub fn merge_ranges(&self, selector: &SheetSelector) -> Result<Vec<MergeRange>> {
493 let mut out = Vec::new();
494 for sheet in self.select(selector)? {
495 let wants = sheet_meta::MetaWants {
496 merges: true,
497 ..Default::default()
498 };
499 out.extend(sheet_meta::load_sheet_meta(&self.source, &sheet.path, wants)?.merges);
500 }
501 Ok(out)
502 }
503
504 pub fn hyperlinks(&self, selector: &SheetSelector) -> Result<Vec<Hyperlink>> {
506 let mut out = Vec::new();
507 for sheet in self.select(selector)? {
508 let wants = sheet_meta::MetaWants {
509 hyperlinks: true,
510 ..Default::default()
511 };
512 out.extend(sheet_meta::load_sheet_meta(&self.source, &sheet.path, wants)?.hyperlinks);
513 }
514 Ok(out)
515 }
516
517 pub fn validations(&self, selector: &SheetSelector) -> Result<Vec<sheet_meta::DataValidation>> {
519 let mut out = Vec::new();
520 for sheet in self.select(selector)? {
521 let wants = sheet_meta::MetaWants {
522 validations: true,
523 ..Default::default()
524 };
525 out.extend(sheet_meta::load_sheet_meta(&self.source, &sheet.path, wants)?.validations);
526 }
527 Ok(out)
528 }
529
530 pub fn conditional_formats(
532 &self,
533 selector: &SheetSelector,
534 ) -> Result<Vec<sheet_meta::ConditionalFormat>> {
535 let mut out = Vec::new();
536 for sheet in self.select(selector)? {
537 let wants = sheet_meta::MetaWants {
538 conditional_formats: true,
539 ..Default::default()
540 };
541 out.extend(
542 sheet_meta::load_sheet_meta(&self.source, &sheet.path, wants)?
543 .conditional_formats,
544 );
545 }
546 Ok(out)
547 }
548
549 pub fn read_dynamic(
554 &self,
555 selector: &SheetSelector,
556 options: ReadOptions,
557 ) -> Result<(Vec<String>, Vec<DynamicRow>)> {
558 let sheets = self.select(selector)?;
559 let mut stream = self.stream_sheet(sheets[0], &[], options)?;
560 let mut rows = Vec::new();
561 while let Some(row) = stream.next_row()? {
562 let dynamic = DynamicRow::from_row(&row)
563 .map_err(|e| ExcelError::Other(format!("动态行解析失败:{}", e.len())))?;
564 rows.push(dynamic);
565 }
566 let headers = stream
567 .header()
568 .map(|h| h.file_headers.clone())
569 .unwrap_or_default();
570 Ok((headers, rows))
571 }
572
573 pub fn comments(&self, selector: &SheetSelector) -> Result<Vec<Comment>> {
577 let mut out = Vec::new();
578 for sheet in self.select(selector)? {
579 out.extend(sheet_meta::load_comments(&self.source, &sheet.path)?);
580 }
581 Ok(out)
582 }
583}