1#[cfg(test)]
2use std::borrow::Cow;
3use std::sync::Arc;
4
5#[cfg(feature = "profile")]
6use std::sync::atomic::{AtomicUsize, Ordering};
7
8#[cfg(feature = "profile")]
10pub static RESOLVE_AND_PUT_COUNT: AtomicUsize = AtomicUsize::new(0);
11#[cfg(feature = "profile")]
13pub static PREDICATE_EVALUATIONS: AtomicUsize = AtomicUsize::new(0);
14#[cfg(feature = "profile")]
16pub static PREDICATE_FAILS: AtomicUsize = AtomicUsize::new(0);
17#[cfg(feature = "profile")]
19pub static PREDICATE_UNDECIDED: AtomicUsize = AtomicUsize::new(0);
20#[cfg(feature = "profile")]
22pub static IS_PRED_TRUE: AtomicUsize = AtomicUsize::new(0);
23#[cfg(feature = "profile")]
25pub static IS_PRED_FALSE: AtomicUsize = AtomicUsize::new(0);
26
27use arrow::datatypes::{Field as ArrowField, Schema};
28use arrow::record_batch::RecordBatch;
29use rustc_hash::FxHashMap as HashMap;
30
31use smallvec::SmallVec;
32
33use crate::columnar::ColumnBuilder;
34use crate::decoder::ColumnarSink;
35use crate::engine::predicate::{PredicateState, RowBuffer};
36use crate::plan::{ExecutionPlan, FieldType, FilterPredicate};
37use crate::value::Value;
38use crate::Result;
39
40pub struct TableBuilder {
44 pub(crate) columns: Vec<ColumnBuilder>,
45 pub(crate) field_index: HashMap<String, usize>,
46 pub(crate) column_order: Vec<String>,
47 pub(crate) row_count: usize,
48 pub(crate) estimated_rows: usize,
49 pub(crate) plan: Arc<ExecutionPlan>,
50 pub(crate) row_dirty: Vec<u64>,
55 pub(crate) frozen: Option<std::sync::Arc<crate::schema::FrozenSchema>>,
59 pub(crate) unknown_error: Option<String>,
60 pub(crate) row_buf: Option<Box<RowBuffer>>,
64 pub(crate) ordinal_expect: Vec<Option<(u32, Vec<u8>)>>,
69 pub(crate) current_ordinal: u32,
72}
73
74impl TableBuilder {
75 pub fn new() -> Self {
76 Self {
77 columns: Vec::new(),
78 field_index: HashMap::default(),
79 column_order: Vec::new(),
80 row_count: 0,
81 estimated_rows: 0,
82 plan: Arc::new(ExecutionPlan::new()),
83 row_dirty: Vec::new(),
84 frozen: None,
85 unknown_error: None,
86 row_buf: None,
87 ordinal_expect: Vec::new(),
88 current_ordinal: 0,
89 }
90 }
91
92 pub fn with_capacity(cap: usize) -> Self {
93 Self {
94 columns: Vec::new(),
95 field_index: HashMap::default(),
96 column_order: Vec::new(),
97 row_count: 0,
98 estimated_rows: cap,
99 plan: Arc::new(ExecutionPlan::new()),
100 row_dirty: Vec::new(),
101 frozen: None,
102 unknown_error: None,
103 row_buf: None,
104 ordinal_expect: Vec::new(),
105 current_ordinal: 0,
106 }
107 }
108
109 pub fn with_plan(cap: usize, plan: Arc<ExecutionPlan>) -> Self {
110 Self {
111 columns: Vec::new(),
112 field_index: HashMap::default(),
113 column_order: Vec::new(),
114 row_count: 0,
115 estimated_rows: cap,
116 plan: Arc::clone(&plan),
117 row_dirty: Vec::new(),
118 frozen: None,
119 unknown_error: None,
120 row_buf: if plan.filter.is_some() {
121 Some(Box::new(RowBuffer {
122 fields: SmallVec::new(),
123 state: PredicateState::Undecided,
124 predicate_mask: SmallVec::new(),
125 direct: false,
126 predicate_ordinal: None,
127 buffer_worthwhile: true,
128 pred_names: SmallVec::new(),
129 }))
130 } else {
131 None
132 },
133 ordinal_expect: Vec::new(),
134 current_ordinal: 0,
135 }
136 }
137
138 pub fn ensure_schema(&mut self, schema: &crate::schema::FrozenSchema) -> Result<()> {
144 for (slot, name) in schema.column_names().iter().enumerate() {
145 let name_str: &str = name;
146 if self.field_index.contains_key(name_str) {
147 continue; }
149 let ty = schema.column_types()[slot].clone();
150 let col = ColumnBuilder::with_capacity(self.estimated_rows, &ty);
151 self.columns.push(col);
152 self.field_index
153 .insert(name_str.to_string(), self.columns.len() - 1);
154 self.column_order.push(name_str.to_string());
155 }
156 let words = self.columns.len().div_ceil(64);
158 self.row_dirty.resize(words, 0);
159 self.frozen = Some(std::sync::Arc::new(schema.clone()));
164 Ok(())
165 }
166
167 pub(crate) fn get_column(&self, name: &str) -> Option<&ColumnBuilder> {
169 self.field_index.get(name).map(|&i| &self.columns[i])
170 }
171
172 pub(crate) fn get_column_mut(&mut self, name: &str) -> Option<&mut ColumnBuilder> {
174 if let Some(&i) = self.field_index.get(name) {
175 Some(&mut self.columns[i])
176 } else {
177 None
178 }
179 }
180
181 pub(crate) fn bytes_used(&self) -> usize {
182 self.columns.iter().map(|c| c.bytes_used()).sum::<usize>()
183 + self.column_order.iter().map(|s| s.len()).sum::<usize>()
184 + self.row_dirty.len() * 8
185 }
186
187 pub(crate) fn split_off(&mut self, n: usize) -> Self {
193 assert!(n <= self.row_count, "split_off beyond row_count");
194 assert!(n > 0);
195 let mut other = Self {
196 columns: Vec::with_capacity(self.columns.len()),
197 field_index: self.field_index.clone(),
198 column_order: self.column_order.clone(),
199 row_count: n,
200 estimated_rows: n,
201 plan: Arc::clone(&self.plan),
202 row_dirty: vec![0; self.columns.len().div_ceil(64)],
203 frozen: self.frozen.clone(),
204 unknown_error: None,
205 row_buf: if self.plan.filter.is_some() {
206 Some(Box::new(RowBuffer {
207 fields: SmallVec::new(),
208 state: PredicateState::Undecided,
209 predicate_mask: self
210 .row_buf
211 .as_ref()
212 .map_or_else(SmallVec::new, |b| b.predicate_mask.clone()),
213 direct: false,
214 predicate_ordinal: None,
215 buffer_worthwhile: true,
216 pred_names: self
217 .row_buf
218 .as_ref()
219 .map_or_else(SmallVec::new, |b| b.pred_names.clone()),
220 }))
221 } else {
222 None
223 },
224 ordinal_expect: Vec::new(),
225 current_ordinal: 0,
226 };
227 for (idx, col) in self.columns.iter_mut().enumerate() {
228 let drain = col.split_off(n);
229 other.columns.push(drain);
230 let _ = idx;
232 }
233 self.row_count -= n;
234 self.row_dirty = vec![0; self.columns.len().div_ceil(64)];
236 other
238 }
239
240 pub(crate) fn take_column(&mut self, name: &str) -> Option<ColumnBuilder> {
243 let idx = self.field_index.remove(name)?;
244 let new_len = self.columns.len().div_ceil(64);
249 self.row_dirty.resize(new_len, 0);
250 self.row_dirty.fill(0);
252 let _ = idx; let last = self.columns.len() - 1;
256 let col = if idx == last {
257 self.columns.pop().unwrap()
258 } else {
259 let col = self.columns.swap_remove(idx);
260 let old_last = self.columns.len(); let moved_name = self.field_index.iter().find_map(|(k, &v)| {
265 if v == old_last {
266 Some(k.clone())
267 } else {
268 None
269 }
270 });
271 if let Some(k) = moved_name {
272 self.field_index.insert(k, idx);
273 }
274 col
275 };
276 Some(col)
277 }
278
279 pub fn num_rows(&self) -> usize {
280 self.row_count
281 }
282
283 pub fn num_columns(&self) -> usize {
284 self.column_order.len()
285 }
286
287 pub fn column_names(&self) -> &[String] {
288 &self.column_order
289 }
290
291 pub fn column_diagnostics(&self) -> Vec<(String, usize, usize)> {
293 self.column_order
294 .iter()
295 .map(|name| {
296 let idx = self.field_index[name];
297 let col = &self.columns[idx];
298 (name.clone(), col.bytes_used(), col.capacity_bytes())
299 })
300 .collect()
301 }
302
303 pub fn estimated_rows(&self) -> usize {
305 self.estimated_rows
306 }
307
308 pub fn finish(&mut self) -> Result<RecordBatch> {
312 ColumnarSink::finish(self)
313 }
314
315 pub fn reset(&mut self) {
317 self.columns.clear();
318 self.field_index.clear();
319 self.column_order.clear();
320 self.row_dirty.fill(0);
321 self.row_count = 0;
322 if let Some(ref mut buf) = self.row_buf {
323 buf.fields.clear();
324 buf.state = PredicateState::Undecided;
325 }
326 self.unknown_error = None;
328 }
329
330 pub fn normalize(&mut self) {
333 for b in &mut self.columns {
334 while b.len() > self.row_count {
335 b.pop();
336 }
337 }
338 self.row_dirty.fill(0);
340 }
341
342 pub fn auto_dict_upgrade(&mut self) {
345 if self.plan.auto_dict {
346 let max_ratio = self.plan.dict_threshold.unwrap_or(0.05);
347 let max_size = self.plan.dict_max_size.unwrap_or(256);
348 for b in &mut self.columns {
349 b.try_upgrade_to_dict(512, max_ratio, max_size);
350 }
351 }
352 }
353
354 pub fn sort_columns(&mut self) {
358 if self.plan.schema_order.is_empty() {
359 return;
360 }
361 let order = &self.plan.schema_order;
362 let rank = |name: &String| order.iter().position(|n| n == name).unwrap_or(usize::MAX);
363 self.column_order.sort_by_key(rank);
364 }
365
366 pub(crate) fn schema_insert_index(&self, name: &str) -> usize {
367 let order = &self.plan.schema_order;
368 if order.is_empty() {
369 return self.column_order.len();
370 }
371 let pos = order.iter().position(|n| n == name);
372 match pos {
373 Some(p) => self
374 .column_order
375 .iter()
376 .position(|existing| {
377 order
378 .iter()
379 .position(|n| n == existing)
380 .is_some_and(|ep| ep > p)
381 })
382 .unwrap_or(self.column_order.len()),
383 None => self.column_order.len(),
384 }
385 }
386
387 fn ensure_column_idx(&mut self, name: &str) -> usize {
391 if let Some(&idx) = self.field_index.get(name) {
392 return idx;
393 }
394 if self.frozen.is_some() {
401 if let Some(frozen) = &self.frozen {
404 if self.unknown_error.is_none() {
405 self.unknown_error = Some(format!(
406 "unknown field {:?} not in frozen schema ({} columns, exact={}); pass schema=[...] with full column list or use full-scan discovery",
407 name,
408 frozen.num_columns(),
409 frozen.is_exact()
410 ));
411 }
412 }
413 return 0;
415 }
416 let est = self.estimated_rows.max(64);
417 let col_type = self.plan.column_type(name);
418 let mut b = ColumnBuilder::with_capacity(est, &col_type);
419 let backfill = if self.row_buf.as_ref().is_some_and(|b| b.direct) {
424 self.row_count.saturating_sub(1)
425 } else {
426 self.row_count
427 };
428 for _ in 0..backfill {
429 b.push(None);
430 }
431 let idx = self.columns.len();
432 self.columns.push(b);
433 self.field_index.insert(name.to_owned(), idx);
434 let needed = self.columns.len().div_ceil(64);
436 if self.row_dirty.len() < needed {
437 self.row_dirty.resize(needed, 0);
438 }
439 let order_idx = self.schema_insert_index(name);
440 self.column_order.insert(order_idx, name.to_owned());
441 idx
442 }
443
444 #[inline]
447 fn push_field_resolved(&mut self, resolved_name: &str, value: Value<'_>) {
448 if self.frozen.is_some() && !self.field_index.contains_key(resolved_name) {
455 if let Some(frozen) = &self.frozen {
456 if self.unknown_error.is_none() {
457 self.unknown_error = Some(format!(
458 "unknown field {:?} not in frozen schema ({} columns, exact={}); pass schema=[...] with full column list or use full-scan discovery",
459 resolved_name,
460 frozen.num_columns(),
461 frozen.is_exact()
462 ));
463 }
464 }
465 return;
466 }
467 let idx = self.ensure_column_idx(resolved_name);
468 if self.row_count == 0 {
470 let ord = self.current_ordinal as usize;
471 if ord >= self.ordinal_expect.len() {
472 self.ordinal_expect.resize_with(ord + 1, || None);
473 }
474 self.ordinal_expect[ord] = Some((idx as u32, resolved_name.as_bytes().to_vec()));
475 }
476 self.current_ordinal += 1;
477 let word = idx / 64;
478 let bit = idx % 64;
479 self.row_dirty[word] |= 1u64 << bit;
480 let b = &mut self.columns[idx];
481 let row_count = self.row_count;
482 if b.len() > row_count {
483 b.pop();
484 }
485 b.push_value(value);
486 }
487
488 #[inline]
491 fn push_field(&mut self, name: &str, value: Value<'_>) {
492 if self.plan.field_map.is_empty() && self.plan.drop_fields.is_empty() {
495 self.push_field_resolved(name, value);
496 return;
497 }
498 if let Some(idx) = Self::resolve_and_slot(&self.plan, &self.field_index, name) {
501 if self.row_count == 0 {
503 let ord = self.current_ordinal as usize;
504 if ord >= self.ordinal_expect.len() {
505 self.ordinal_expect.resize_with(ord + 1, || None);
506 }
507 let resolved = self.plan.resolve_field(name).unwrap_or(name);
509 self.ordinal_expect[ord] = Some((idx as u32, resolved.as_bytes().to_vec()));
510 }
511 self.current_ordinal += 1;
512 let word = idx / 64;
513 let bit = idx % 64;
514 self.row_dirty[word] |= 1u64 << bit;
515 let b = &mut self.columns[idx];
516 let row_count = self.row_count;
517 if b.len() > row_count {
518 b.pop();
519 }
520 b.push_value(value);
521 } else {
522 if let Some(resolved) = self.plan.resolve_field(name) {
525 let owned = resolved.to_owned();
526 self.push_field_resolved(&owned, value);
527 }
528 }
529 }
530
531 #[inline]
536 fn resolve_and_slot(
537 plan: &ExecutionPlan,
538 field_index: &HashMap<String, usize>,
539 name: &str,
540 ) -> Option<usize> {
541 let resolved = plan.resolve_field(name)?;
542 field_index.get(resolved).copied()
543 }
544
545 #[doc(hidden)]
549 pub fn advance_row(&mut self) {
550 self.row_count += 1;
551 }
552
553 fn finish_row(&mut self) {
558 let ncols = self.columns.len();
560 let full_words = ncols / 64;
562 let rem_bits = ncols % 64;
563 let is_full = (0..full_words).all(|w| self.row_dirty[w] == u64::MAX)
564 && (rem_bits == 0
565 || self.row_dirty.get(full_words).copied().unwrap_or(0) == (1u64 << rem_bits) - 1);
566 if is_full {
567 self.row_dirty.fill(0);
568 } else {
569 for (i, b) in self.columns.iter_mut().enumerate() {
570 let word = i / 64;
571 let bit = i % 64;
572 let is_set = (self.row_dirty[word] >> bit) & 1 == 1;
573 if !is_set {
574 b.push(None);
575 }
576 }
577 self.row_dirty.fill(0);
578 }
579
580 if let Some(ref filter) = self.plan.filter {
581 if !filter.check(&self.columns, &self.field_index, self.row_count, &self.plan) {
582 for b in &mut self.columns {
583 b.pop();
584 }
585 return;
586 }
587 }
588
589 self.row_count += 1;
590 }
591
592 fn build_predicate_mask(&mut self) {
596 let buf = match self.row_buf {
597 Some(ref mut b) => b,
598 None => return,
599 };
600 if !buf.pred_names.is_empty() {
601 return; }
603 let mut names: SmallVec<[String; 4]> = SmallVec::new();
605 if let Some(ref f) = self.plan.filter.clone() {
606 Self::collect_predicate_field_names(f, &self.plan, &mut names);
607 }
608 buf.pred_names.clone_from(&names);
610 let ncols = self.columns.len();
612 let words = ncols.div_ceil(64);
613 buf.predicate_mask.resize(words, 0);
614 for name in &names {
616 if let Some(&slot) = self.field_index.get(name.as_str()) {
617 let word = slot / 64;
618 let bit = slot % 64;
619 if word < buf.predicate_mask.len() {
620 buf.predicate_mask[word] |= 1u64 << bit;
621 }
622 }
623 }
624 }
625
626 #[inline]
631 fn mark_predicate_slot(&mut self, slot: u32) {
632 if self.plan.filter.is_none() {
633 return;
634 }
635 let needs_build = self.row_buf.as_ref().is_some_and(|buf| {
639 let word = slot as usize / 64;
640 let bit = slot as usize % 64;
641 if word < buf.predicate_mask.len() && (buf.predicate_mask[word] >> bit) & 1 == 1 {
642 return false; }
644 buf.pred_names.is_empty() });
646 if needs_build {
647 self.build_predicate_mask();
648 }
649 if let Some(ref buf) = self.row_buf {
651 let word = slot as usize / 64;
652 let bit = slot as usize % 64;
653 if word < buf.predicate_mask.len() && (buf.predicate_mask[word] >> bit) & 1 == 1 {
654 return; }
656 }
657 if let Some(col_name) = self.column_order.get(slot as usize) {
660 let is_pred = self
661 .row_buf
662 .as_ref()
663 .is_some_and(|buf| buf.pred_names.iter().any(|n| n == col_name));
664 if is_pred {
665 let buf = self.row_buf.as_mut().unwrap();
666 let word = slot as usize / 64;
667 let bit = slot as usize % 64;
668 if word >= buf.predicate_mask.len() {
669 buf.predicate_mask.resize(word + 1, 0);
670 }
671 buf.predicate_mask[word] |= 1u64 << bit;
672 }
673 }
674 }
675
676 fn collect_predicate_field_names(
677 pred: &FilterPredicate,
678 plan: &ExecutionPlan,
679 names: &mut SmallVec<[String; 4]>,
680 ) {
681 match pred {
682 FilterPredicate::Equal { field, .. } | FilterPredicate::NotEqual { field, .. } => {
683 let resolved = plan.resolve_field(field).unwrap_or(field);
684 names.push(resolved.to_string());
685 }
686 FilterPredicate::Compare {
687 field_a, field_b, ..
688 } => {
689 for f in [field_a, field_b] {
690 let resolved = plan.resolve_field(f).unwrap_or(f);
691 names.push(resolved.to_string());
692 }
693 }
694 FilterPredicate::And(a, b) | FilterPredicate::Or(a, b) => {
695 Self::collect_predicate_field_names(a, plan, names);
696 Self::collect_predicate_field_names(b, plan, names);
697 }
698 FilterPredicate::Not(inner) => Self::collect_predicate_field_names(inner, plan, names),
699 }
700 }
701
702 #[inline]
703 fn is_predicate_slot(&self, slot: u32) -> bool {
704 self.row_buf.as_ref().is_some_and(|b| {
705 let word = slot as usize / 64;
706 let bit = slot as usize % 64;
707 word < b.predicate_mask.len() && (b.predicate_mask[word] >> bit) & 1 == 1
708 })
709 }
710
711 fn get_buffered_value(&self, field: &str) -> Option<&Value<'static>> {
712 let buf = self.row_buf.as_ref()?;
713 let resolved = self.plan.resolve_field(field)?;
714 let slot = *self.field_index.get(resolved)? as u32;
715 for (s, v) in buf.fields.iter().rev() {
716 if *s == slot {
717 return Some(v);
718 }
719 }
720 None
721 }
722
723 fn get_buffered_str(&self, field: &str) -> Option<String> {
724 match self.get_buffered_value(field) {
725 Some(Value::Str(s)) => Some(s.to_string()),
726 Some(Value::Int64(i)) => Some(i.to_string()),
727 Some(Value::Float64(f)) => Some(f.to_string()),
728 Some(Value::Bool(b)) => Some(b.to_string()),
729 Some(v) => Some(format!("{:?}", v)),
730 None => None,
731 }
732 }
733
734 fn evaluate_predicate_state(&self) -> PredicateState {
735 let Some(ref pred) = self.plan.filter else {
736 return PredicateState::Pass;
737 };
738 #[cfg(feature = "profile")]
739 {
740 crate::engine::PREDICATE_EVALUATIONS.fetch_add(1, Ordering::Relaxed);
741 }
742 let result = Self::eval_predicate(pred, self);
743 #[cfg(feature = "profile")]
744 match result {
745 PredicateState::Fail => {
746 crate::engine::PREDICATE_FAILS.fetch_add(1, Ordering::Relaxed);
747 }
748 PredicateState::Undecided => {
749 crate::engine::PREDICATE_UNDECIDED.fetch_add(1, Ordering::Relaxed);
750 }
751 _ => {}
752 }
753 result
754 }
755
756 fn eval_predicate(pred: &FilterPredicate, tb: &TableBuilder) -> PredicateState {
757 match pred {
758 FilterPredicate::Equal { field, value } => match tb.get_buffered_str(field) {
759 Some(actual) => {
760 if actual == *value {
761 PredicateState::Pass
762 } else {
763 PredicateState::Fail
764 }
765 }
766 None => PredicateState::Undecided,
767 },
768 FilterPredicate::NotEqual { field, value } => match tb.get_buffered_str(field) {
769 Some(actual) => {
770 if actual != *value {
771 PredicateState::Pass
772 } else {
773 PredicateState::Fail
774 }
775 }
776 None => PredicateState::Undecided,
777 },
778 FilterPredicate::Compare {
779 field_a,
780 op,
781 field_b,
782 } => {
783 let normalize = |field: &str, value: &Value<'static>| {
784 let field = tb.plan.resolve_field(field).unwrap_or(field);
785 match tb.plan.column_type(field) {
786 FieldType::Int64 => match value.as_str() {
787 Some(s) => lexical::parse::<i64, _>(s.as_bytes())
788 .ok()
789 .map(Value::Int64),
790 _ => Some(value.clone()),
791 },
792 FieldType::Float64 => match value.as_str() {
793 Some(s) => lexical::parse::<f64, _>(s.as_bytes())
794 .ok()
795 .map(Value::Float64),
796 _ => Some(value.clone()),
797 },
798 FieldType::Boolean => match value.as_str() {
799 Some(s) => s.parse::<bool>().ok().map(Value::Bool),
800 _ => Some(value.clone()),
801 },
802 FieldType::Date32 => match value.as_str() {
803 Some(s) => crate::columnar::parse_date32(s).map(Value::Date32),
804 _ => Some(value.clone()),
805 },
806 FieldType::Timestamp(unit) => match value.as_str() {
807 Some(s) => {
808 crate::columnar::parse_timestamp(s, unit).map(Value::Timestamp)
809 }
810 _ => Some(value.clone()),
811 },
812 FieldType::String | FieldType::Dictionary => Some(value.clone()),
813 }
814 };
815 let va = tb
816 .get_buffered_value(field_a)
817 .and_then(|value| normalize(field_a, value));
818 let vb = tb
819 .get_buffered_value(field_b)
820 .and_then(|value| normalize(field_b, value));
821 match (va, vb) {
822 (Some(ref a), Some(ref b)) => {
823 let ord = match (a, b) {
824 (crate::value::Value::Int64(ai), crate::value::Value::Int64(bi)) => {
825 Some(ai.cmp(bi))
826 }
827 (
828 crate::value::Value::Float64(af),
829 crate::value::Value::Float64(bf),
830 ) => af.partial_cmp(bf),
831 (crate::value::Value::Int64(ai), crate::value::Value::Float64(bf)) => {
832 (*ai as f64).partial_cmp(bf)
833 }
834 (crate::value::Value::Float64(af), crate::value::Value::Int64(bi)) => {
835 af.partial_cmp(&(*bi as f64))
836 }
837 (crate::value::Value::Str(a), crate::value::Value::Str(b)) => {
838 let resolved_a =
839 tb.plan.resolve_field(field_a).unwrap_or(field_a.as_str());
840 let resolved_b =
841 tb.plan.resolve_field(field_b).unwrap_or(field_b.as_str());
842 let type_a = tb.plan.field_types.get(resolved_a);
843 let type_b = tb.plan.field_types.get(resolved_b);
844 match (type_a, type_b) {
845 (
846 Some(crate::plan::FieldType::Int64),
847 Some(crate::plan::FieldType::Int64),
848 ) => {
849 let ai: i64 =
850 lexical::parse(a.as_bytes()).ok().unwrap_or(0);
851 let bi: i64 =
852 lexical::parse(b.as_bytes()).ok().unwrap_or(0);
853 Some(ai.cmp(&bi))
854 }
855 (
856 Some(crate::plan::FieldType::Float64),
857 Some(crate::plan::FieldType::Float64),
858 ) => {
859 let af: f64 =
860 lexical::parse(a.as_bytes()).ok().unwrap_or(0.0);
861 let bf: f64 =
862 lexical::parse(b.as_bytes()).ok().unwrap_or(0.0);
863 af.partial_cmp(&bf)
864 }
865 (
866 Some(crate::plan::FieldType::Int64),
867 Some(crate::plan::FieldType::Float64),
868 ) => {
869 let ai: f64 = lexical::parse::<i64, _>(a.as_bytes())
870 .ok()
871 .unwrap_or(0)
872 as f64;
873 let bf: f64 =
874 lexical::parse(b.as_bytes()).ok().unwrap_or(0.0);
875 ai.partial_cmp(&bf)
876 }
877 (
878 Some(crate::plan::FieldType::Float64),
879 Some(crate::plan::FieldType::Int64),
880 ) => {
881 let af: f64 =
882 lexical::parse(a.as_bytes()).ok().unwrap_or(0.0);
883 let bi: f64 = lexical::parse::<i64, _>(b.as_bytes())
884 .ok()
885 .unwrap_or(0)
886 as f64;
887 af.partial_cmp(&bi)
888 }
889 (Some(_), None) | (None, Some(_)) => None,
892 (None, None) => Some(a.cmp(b)),
894 (
896 Some(crate::plan::FieldType::Timestamp(ua)),
897 Some(crate::plan::FieldType::Timestamp(ub)),
898 ) => {
899 let ta = crate::columnar::parse_timestamp(a.as_ref(), *ua);
900 let tb_val =
901 crate::columnar::parse_timestamp(b.as_ref(), *ub);
902 match (ta, tb_val) {
903 (Some(ai), Some(bi)) => Some(ai.cmp(&bi)),
904 _ => None,
905 }
906 }
907 (
909 Some(crate::plan::FieldType::Date32),
910 Some(crate::plan::FieldType::Date32),
911 ) => {
912 let da = crate::columnar::parse_date32(a.as_ref());
913 let db = crate::columnar::parse_date32(b.as_ref());
914 match (da, db) {
915 (Some(ai), Some(bi)) => Some(ai.cmp(&bi)),
916 _ => None,
917 }
918 }
919 _ => None,
921 }
922 }
923 (crate::value::Value::Bool(a), crate::value::Value::Bool(b)) => {
924 Some(a.cmp(b))
925 }
926 _ => {
927 let av = format!("{:?}", a);
928 let bv = format!("{:?}", b);
929 Some(av.cmp(&bv))
930 }
931 };
932 let pass = ord.is_some_and(|ord| match op {
933 crate::plan::CompareOp::Gt => ord == std::cmp::Ordering::Greater,
934 crate::plan::CompareOp::Lt => ord == std::cmp::Ordering::Less,
935 crate::plan::CompareOp::Ge => ord != std::cmp::Ordering::Less,
936 crate::plan::CompareOp::Le => ord != std::cmp::Ordering::Greater,
937 crate::plan::CompareOp::Eq => ord == std::cmp::Ordering::Equal,
938 crate::plan::CompareOp::Ne => ord != std::cmp::Ordering::Equal,
939 });
940 if pass {
941 PredicateState::Pass
942 } else {
943 PredicateState::Fail
944 }
945 }
946 _ => PredicateState::Undecided,
947 }
948 }
949 FilterPredicate::And(a, b) => {
950 let sa = Self::eval_predicate(a, tb);
951 let sb = Self::eval_predicate(b, tb);
952 match (sa, sb) {
953 (PredicateState::Fail, _) | (_, PredicateState::Fail) => PredicateState::Fail,
954 (PredicateState::Pass, PredicateState::Pass) => PredicateState::Pass,
955 _ => PredicateState::Undecided,
956 }
957 }
958 FilterPredicate::Or(a, b) => {
959 let sa = Self::eval_predicate(a, tb);
960 let sb = Self::eval_predicate(b, tb);
961 match (sa, sb) {
962 (PredicateState::Pass, _) | (_, PredicateState::Pass) => PredicateState::Pass,
963 (PredicateState::Fail, PredicateState::Fail) => PredicateState::Fail,
964 _ => PredicateState::Undecided,
965 }
966 }
967 FilterPredicate::Not(inner) => match Self::eval_predicate(inner, tb) {
968 PredicateState::Pass => PredicateState::Fail,
969 PredicateState::Fail => PredicateState::Pass,
970 PredicateState::Undecided => PredicateState::Undecided,
971 },
972 }
973 }
974
975 fn drain_buffered(&mut self, pass: bool) {
976 let buf = match self.row_buf {
977 Some(ref mut b) => b,
978 None => return,
979 };
980 if pass {
981 let ncols = self.columns.len();
985 let words = ncols.div_ceil(64);
986 if self.row_dirty.len() < words {
987 self.row_dirty.resize(words, 0);
988 }
989 let mut seen: u64 = 0;
990 let mut seen_extra: SmallVec<[u64; 1]> = SmallVec::new();
991 if words > 1 {
992 seen_extra.resize(words - 1, 0);
993 }
994 for &(slot, ref val) in buf.fields.iter().rev() {
995 let word = slot as usize / 64;
996 let bit = slot as usize % 64;
997 let mask = 1u64 << bit;
998 let already = if word == 0 {
999 seen & mask != 0
1000 } else {
1001 seen_extra.get(word - 1).is_some_and(|w| w & mask != 0)
1002 };
1003 if already {
1004 continue;
1005 }
1006 if word == 0 {
1007 seen |= mask;
1008 } else if let Some(w) = seen_extra.get_mut(word - 1) {
1009 *w |= mask;
1010 }
1011 self.row_dirty[word] |= mask;
1012 let b = &mut self.columns[slot as usize];
1013 if b.len() > self.row_count {
1014 b.pop();
1015 }
1016 b.push_value(val.clone());
1017 }
1018 if !buf.direct {
1023 let ncols = self.columns.len();
1024 let full_words = ncols / 64;
1025 let rem_bits = ncols % 64;
1026 let is_full = (0..full_words).all(|w| self.row_dirty[w] == u64::MAX)
1027 && (rem_bits == 0
1028 || self.row_dirty.get(full_words).copied().unwrap_or(0)
1029 == (1u64 << rem_bits) - 1);
1030 if is_full {
1031 self.row_dirty.fill(0);
1032 } else {
1033 for (i, b) in self.columns.iter_mut().enumerate() {
1034 let word = i / 64;
1035 let bit = i % 64;
1036 let is_set = (self.row_dirty[word] >> bit) & 1 == 1;
1037 if !is_set {
1038 b.push(None);
1039 }
1040 }
1041 self.row_dirty.fill(0);
1042 }
1043 } else {
1044 }
1047 self.row_count += 1;
1048 } else {
1049 buf.fields.clear();
1051 self.row_dirty.fill(0);
1052 }
1053 if !buf.fields.is_empty() {
1055 buf.fields.clear();
1056 }
1057 buf.state = PredicateState::Undecided;
1058 }
1059
1060 fn evaluate_against_null(&self) -> PredicateState {
1061 let Some(ref pred) = self.plan.filter else {
1066 return PredicateState::Pass;
1067 };
1068 Self::eval_predicate_with_null(pred, self)
1069 }
1070
1071 fn eval_predicate_with_null(pred: &FilterPredicate, tb: &TableBuilder) -> PredicateState {
1072 match pred {
1073 FilterPredicate::Equal { field, value } => match tb.get_buffered_str(field) {
1074 Some(actual) => {
1075 if actual == *value {
1076 PredicateState::Pass
1077 } else {
1078 PredicateState::Fail
1079 }
1080 }
1081 None => PredicateState::Fail, },
1083 FilterPredicate::NotEqual { field, value } => match tb.get_buffered_str(field) {
1084 Some(actual) => {
1085 if actual != *value {
1086 PredicateState::Pass
1087 } else {
1088 PredicateState::Fail
1089 }
1090 }
1091 None => PredicateState::Pass, },
1093 FilterPredicate::Compare { .. } => {
1094 match Self::eval_predicate(pred, tb) {
1096 PredicateState::Undecided => PredicateState::Fail,
1097 other => other,
1098 }
1099 }
1100 FilterPredicate::And(a, b) => {
1101 let sa = Self::eval_predicate_with_null(a, tb);
1102 let sb = Self::eval_predicate_with_null(b, tb);
1103 match (sa, sb) {
1104 (PredicateState::Fail, _) | (_, PredicateState::Fail) => PredicateState::Fail,
1105 (PredicateState::Pass, PredicateState::Pass) => PredicateState::Pass,
1106 _ => PredicateState::Undecided, }
1108 }
1109 FilterPredicate::Or(a, b) => {
1110 let sa = Self::eval_predicate_with_null(a, tb);
1111 let sb = Self::eval_predicate_with_null(b, tb);
1112 match (sa, sb) {
1113 (PredicateState::Pass, _) | (_, PredicateState::Pass) => PredicateState::Pass,
1114 (PredicateState::Fail, PredicateState::Fail) => PredicateState::Fail,
1115 _ => PredicateState::Fail,
1116 }
1117 }
1118 FilterPredicate::Not(inner) => match Self::eval_predicate_with_null(inner, tb) {
1119 PredicateState::Pass => PredicateState::Fail,
1120 PredicateState::Fail => PredicateState::Pass,
1121 PredicateState::Undecided => PredicateState::Fail, },
1123 }
1124 }
1125
1126 fn null_fill_missing(&mut self) {
1129 let ncols = self.columns.len();
1130 let full_words = ncols / 64;
1131 let rem_bits = ncols % 64;
1132 let is_full = (0..full_words).all(|w| self.row_dirty[w] == u64::MAX)
1133 && (rem_bits == 0
1134 || self.row_dirty.get(full_words).copied().unwrap_or(0) == (1u64 << rem_bits) - 1);
1135 if is_full {
1136 self.row_dirty.fill(0);
1137 } else {
1138 for (i, b) in self.columns.iter_mut().enumerate() {
1139 let word = i / 64;
1140 let bit = i % 64;
1141 let is_set = (self.row_dirty[word] >> bit) & 1 == 1;
1142 if !is_set {
1143 b.push(None);
1144 }
1145 }
1146 self.row_dirty.fill(0);
1147 }
1148 }
1151}
1152
1153impl Default for TableBuilder {
1154 fn default() -> Self {
1155 Self::new()
1156 }
1157}
1158
1159impl ColumnarSink for TableBuilder {
1160 #[inline]
1161 fn begin_row(&mut self) {
1162 self.current_ordinal = 0;
1163 if let Some(ref mut buf) = self.row_buf {
1164 if buf.predicate_ordinal.is_some() && buf.buffer_worthwhile && self.row_count > 0 {
1170 let ncols = self
1173 .frozen
1174 .as_ref()
1175 .map(|f| f.num_columns() as u32)
1176 .or_else(|| {
1177 (!self.plan.schema_order.is_empty())
1178 .then(|| self.plan.schema_order.len() as u32)
1179 })
1180 .unwrap_or(self.columns.len() as u32);
1181 if let Some(ordinal) = buf.predicate_ordinal {
1182 if ordinal >= ncols * 4 / 5 {
1183 buf.buffer_worthwhile = false;
1184 }
1185 }
1186 }
1187 buf.fields.clear();
1188 buf.state = PredicateState::Undecided;
1189 buf.direct = false;
1190 }
1191 }
1192
1193 #[inline]
1194 fn put_field(&mut self, name: &str, value: Value<'_>) {
1195 if self.plan.filter.is_none() {
1196 self.push_field(name, value);
1197 return;
1198 }
1199 let buf_worthwhile = self.row_buf.as_ref().is_none_or(|b| b.buffer_worthwhile);
1201 if !buf_worthwhile {
1202 self.push_field(name, value);
1203 return;
1204 }
1205 let resolved = match self.plan.resolve_field(name) {
1207 Some(r) => r.to_owned(),
1208 None => return,
1209 };
1210 if self.frozen.is_some()
1212 && !self.field_index.contains_key(&resolved)
1213 && self.unknown_error.is_none()
1214 {
1215 if let Some(ref frozen) = self.frozen {
1216 if !frozen.column_names().iter().any(|n| n.as_ref() == resolved) {
1217 self.unknown_error = Some(format!(
1218 "unknown field {:?} not in frozen schema ({} columns, exact={}); pass schema=[...]",
1219 resolved,
1220 frozen.num_columns(),
1221 frozen.is_exact()
1222 ));
1223 return;
1224 }
1225 }
1226 }
1227 let slot = self.ensure_column_idx(&resolved) as u32;
1228 self.mark_predicate_slot(slot);
1229 let val_static: Value<'static> = value.into_static();
1230 let is_pred = self.is_predicate_slot(slot);
1231 #[cfg(feature = "profile")]
1232 if is_pred {
1233 crate::engine::IS_PRED_TRUE.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
1234 } else {
1235 crate::engine::IS_PRED_FALSE.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
1236 }
1237 if let Some(ref mut buf) = self.row_buf {
1239 if let Some(pos) = buf.fields.iter().position(|(s, _)| *s == slot) {
1240 buf.fields[pos].1 = val_static;
1241 } else {
1242 buf.fields.push((slot, val_static));
1243 }
1244 }
1245 if is_pred {
1246 if let Some(ref mut buf) = self.row_buf {
1248 if buf.predicate_ordinal.is_none() {
1249 buf.predicate_ordinal = Some(slot);
1250 }
1251 }
1252 let state = self.evaluate_predicate_state();
1253 if let Some(ref mut buf) = self.row_buf {
1254 buf.state = state;
1255 }
1256 }
1257 }
1258
1259 #[inline]
1260 fn end_row(&mut self) {
1261 if self.plan.filter.is_none() {
1262 self.finish_row();
1263 return;
1264 }
1265 let buf_worthwhile = self.row_buf.as_ref().is_none_or(|b| b.buffer_worthwhile);
1268 if !buf_worthwhile {
1269 self.finish_row();
1273 return;
1274 }
1275 let (state, direct) = self
1277 .row_buf
1278 .as_ref()
1279 .map_or((PredicateState::Pass, false), |b| (b.state, b.direct));
1280 if direct {
1281 self.null_fill_missing();
1283 return;
1284 }
1285 let state = if state == PredicateState::Undecided {
1286 self.evaluate_against_null()
1287 } else {
1288 state
1289 };
1290 let pass = state == PredicateState::Pass;
1291 self.drain_buffered(pass);
1292 }
1293
1294 #[inline]
1295 fn wants(&self, name: &str) -> bool {
1296 self.resolve(name).is_some()
1297 }
1298
1299 #[inline]
1300 fn resolve<'a>(&'a self, name: &'a str) -> Option<&'a str> {
1301 self.plan.resolve_field(name)
1302 }
1303
1304 #[inline]
1305 fn put_field_resolved(&mut self, resolved_name: &str, value: Value<'_>) {
1306 if self.plan.filter.is_none() {
1307 self.push_field_resolved(resolved_name, value);
1308 return;
1309 }
1310 let buf_worthwhile = self.row_buf.as_ref().is_none_or(|b| b.buffer_worthwhile);
1312 if !buf_worthwhile {
1313 self.push_field_resolved(resolved_name, value);
1314 return;
1315 }
1316 if self.frozen.is_some() && !self.field_index.contains_key(resolved_name) {
1318 if let Some(ref frozen) = self.frozen {
1319 if !frozen
1320 .column_names()
1321 .iter()
1322 .any(|n| n.as_ref() == resolved_name)
1323 {
1324 if self.unknown_error.is_none() {
1325 self.unknown_error = Some(format!(
1326 "unknown field {:?} not in frozen schema ({} columns, exact={}); pass schema=[...]",
1327 resolved_name,
1328 frozen.num_columns(),
1329 frozen.is_exact()
1330 ));
1331 }
1332 return;
1333 }
1334 }
1335 }
1336 let slot = self.ensure_column_idx(resolved_name) as u32;
1337 self.mark_predicate_slot(slot);
1338 let val_static: Value<'static> = value.into_static();
1339 let is_pred = self.is_predicate_slot(slot);
1340 #[cfg(feature = "profile")]
1341 if is_pred {
1342 crate::engine::IS_PRED_TRUE.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
1343 } else {
1344 crate::engine::IS_PRED_FALSE.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
1345 }
1346 if let Some(ref mut buf) = self.row_buf {
1347 if let Some(pos) = buf.fields.iter().position(|(s, _)| *s == slot) {
1348 buf.fields[pos].1 = val_static;
1349 } else {
1350 buf.fields.push((slot, val_static));
1351 }
1352 }
1353 if is_pred {
1354 if let Some(ref mut buf) = self.row_buf {
1356 if buf.predicate_ordinal.is_none() {
1357 buf.predicate_ordinal = Some(slot);
1358 }
1359 }
1360 let state = self.evaluate_predicate_state();
1361 if let Some(ref mut buf) = self.row_buf {
1362 buf.state = state;
1363 }
1364 }
1365 }
1366
1367 #[inline]
1371 fn put_field_at(&mut self, slot: u32, value: Value<'_>) {
1372 let idx = slot as usize;
1373 if idx >= self.columns.len() {
1374 return;
1377 }
1378 let word = idx / 64;
1379 let bit = idx % 64;
1380 self.row_dirty[word] |= 1u64 << bit;
1381 let b = &mut self.columns[idx];
1382 let row_count = self.row_count;
1383 if b.len() > row_count {
1384 b.pop();
1385 }
1386 b.push_value(value);
1387 }
1388
1389 #[inline]
1390 fn resolve_and_put(&mut self, name: &str, value: Value<'_>) {
1391 #[cfg(feature = "profile")]
1392 RESOLVE_AND_PUT_COUNT.fetch_add(1, Ordering::Relaxed);
1393 if self.plan.filter.is_none() {
1394 if self.plan.field_map.is_empty() && self.plan.drop_fields.is_empty() {
1395 self.push_field_resolved(name, value);
1396 } else {
1397 if let Some(resolved) = self.plan.resolve_field(name) {
1398 let owned = resolved.to_owned();
1399 self.push_field_resolved(&owned, value);
1400 }
1401 }
1402 return;
1403 }
1404 if self.row_buf.as_ref().is_some_and(|b| !b.buffer_worthwhile) {
1406 if self.plan.field_map.is_empty() && self.plan.drop_fields.is_empty() {
1407 self.push_field_resolved(name, value);
1408 } else {
1409 if let Some(resolved) = self.plan.resolve_field(name) {
1410 let owned = resolved.to_owned();
1411 self.push_field_resolved(&owned, value);
1412 }
1413 }
1414 return;
1415 }
1416 if let Some(ref buf) = self.row_buf {
1418 if buf.direct {
1419 let resolved = match self.plan.resolve_field(name) {
1420 Some(r) => r.to_owned(),
1421 None => return, };
1423 if self.frozen.is_some() && !self.field_index.contains_key(resolved.as_str()) {
1424 if let Some(ref frozen) = self.frozen {
1425 if !frozen
1426 .column_names()
1427 .iter()
1428 .any(|n| n.as_ref() == resolved.as_str())
1429 {
1430 if self.unknown_error.is_none() {
1431 self.unknown_error = Some(format!(
1432 "unknown field {:?} not in frozen schema ({} columns, exact={}); pass schema=[...]",
1433 resolved, frozen.num_columns(), frozen.is_exact()
1434 ));
1435 }
1436 return;
1437 }
1438 }
1439 }
1440 self.push_field_resolved(&resolved, value);
1441 return;
1442 }
1443 }
1444 if self.plan.field_map.is_empty() && self.plan.drop_fields.is_empty() {
1446 let resolved = name;
1448 if self.frozen.is_some() && !self.field_index.contains_key(resolved) {
1449 if let Some(ref frozen) = self.frozen {
1450 if !frozen.column_names().iter().any(|n| n.as_ref() == resolved) {
1451 if self.unknown_error.is_none() {
1452 self.unknown_error = Some(format!(
1453 "unknown field {:?} not in frozen schema ({} columns, exact={}); pass schema=[...]",
1454 resolved,
1455 frozen.num_columns(),
1456 frozen.is_exact()
1457 ));
1458 }
1459 return;
1460 }
1461 }
1462 }
1463 let slot = self.ensure_column_idx(resolved) as u32;
1464 self.mark_predicate_slot(slot);
1465 let val_static: Value<'static> = value.into_static();
1466 let is_pred = self.is_predicate_slot(slot);
1467 #[cfg(feature = "profile")]
1468 if is_pred {
1469 crate::engine::IS_PRED_TRUE.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
1470 } else {
1471 crate::engine::IS_PRED_FALSE.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
1472 }
1473 if let Some(ref mut buf) = self.row_buf {
1474 if let Some(pos) = buf.fields.iter().position(|(s, _)| *s == slot) {
1475 buf.fields[pos].1 = val_static;
1476 } else {
1477 buf.fields.push((slot, val_static));
1478 }
1479 }
1480 if is_pred {
1481 if let Some(ref mut buf) = self.row_buf {
1483 if buf.predicate_ordinal.is_none() {
1484 buf.predicate_ordinal = Some(slot);
1485 }
1486 }
1487 let state = self.evaluate_predicate_state();
1488 if let Some(ref mut buf) = self.row_buf {
1489 buf.state = state;
1490 if state == PredicateState::Pass {
1491 buf.direct = true;
1492 }
1493 }
1494 if state == PredicateState::Pass {
1495 self.drain_buffered(true);
1497 }
1498 }
1499 } else {
1500 if let Some(resolved) = self.plan.resolve_field(name) {
1501 let owned = resolved.to_owned();
1502 if self.frozen.is_some() && !self.field_index.contains_key(&owned) {
1503 if let Some(ref frozen) = self.frozen {
1504 if !frozen.column_names().iter().any(|n| n.as_ref() == owned) {
1505 if self.unknown_error.is_none() {
1506 self.unknown_error = Some(format!(
1507 "unknown field {:?} not in frozen schema ({} columns, exact={}); pass schema=[...]",
1508 owned,
1509 frozen.num_columns(),
1510 frozen.is_exact()
1511 ));
1512 }
1513 return;
1514 }
1515 }
1516 }
1517 let slot = self.ensure_column_idx(&owned) as u32;
1518 self.mark_predicate_slot(slot);
1519 let val_static: Value<'static> = value.into_static();
1520 let is_pred = self.is_predicate_slot(slot);
1521 #[cfg(feature = "profile")]
1522 if is_pred {
1523 crate::engine::IS_PRED_TRUE.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
1524 } else {
1525 crate::engine::IS_PRED_FALSE.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
1526 }
1527 if let Some(ref mut buf) = self.row_buf {
1528 if let Some(pos) = buf.fields.iter().position(|(s, _)| *s == slot) {
1529 buf.fields[pos].1 = val_static;
1530 } else {
1531 buf.fields.push((slot, val_static));
1532 }
1533 }
1534 if is_pred {
1535 if let Some(ref mut buf) = self.row_buf {
1537 if buf.predicate_ordinal.is_none() {
1538 buf.predicate_ordinal = Some(slot);
1539 }
1540 }
1541 let state = self.evaluate_predicate_state();
1542 if let Some(ref mut buf) = self.row_buf {
1543 buf.state = state;
1544 }
1545 }
1546 }
1547 }
1548 }
1549
1550 #[inline]
1551 fn row_rejected(&self) -> bool {
1552 self.plan.filter.is_some()
1553 && self
1554 .row_buf
1555 .as_ref()
1556 .is_some_and(|b| b.state == PredicateState::Fail)
1557 }
1558
1559 #[inline]
1560 fn row_satisfied(&self) -> bool {
1561 let mask = self.wanted_mask();
1562 if mask == 0 {
1563 return false;
1564 }
1565 let dirty = self
1567 .row_dirty
1568 .iter()
1569 .copied()
1570 .reduce(|a, b| a | b)
1571 .unwrap_or(0);
1572 (dirty & mask) == mask
1573 }
1574
1575 #[inline]
1576 fn wanted_mask(&self) -> u64 {
1577 if !self.plan.schema_order.is_empty() {
1579 let mut mask = 0u64;
1580 for name in &self.plan.schema_order {
1581 if let Some(&idx) = self.field_index.get(name.as_str()) {
1582 if idx < 64 {
1583 mask |= 1u64 << idx;
1584 }
1585 }
1586 }
1587 mask
1588 } else if self.plan.drop_fields.is_empty() && self.plan.field_map.is_empty() {
1589 0
1591 } else {
1592 let mut mask = 0u64;
1594 for (name, &idx) in &self.field_index {
1595 if idx < 64 && !self.plan.drop_fields.contains(name) {
1596 mask |= 1u64 << idx;
1597 }
1598 }
1599 mask
1600 }
1601 }
1602
1603 #[inline]
1604 fn finish(&mut self) -> Result<RecordBatch> {
1605 if let Some(err) = self.unknown_error.take() {
1606 return Err(crate::Error::Merge(err));
1607 }
1608 self.normalize();
1609
1610 if self.column_order.is_empty() {
1611 let schema = Arc::new(Schema::empty());
1612 return Ok(RecordBatch::new_empty(schema));
1613 }
1614
1615 self.auto_dict_upgrade();
1616 self.sort_columns();
1617
1618 let mut fields = Vec::with_capacity(self.column_order.len());
1619 let mut arrays = Vec::with_capacity(self.column_order.len());
1620 for name in &self.column_order {
1622 if let Some(&idx) = self.field_index.get(name.as_str()) {
1623 let b = &mut self.columns[idx];
1624 fields.push(ArrowField::new(name.as_str(), b.arrow_datatype(), true));
1625 arrays.push(b.to_arrow_array()?);
1626 }
1627 }
1628
1629 let schema = Arc::new(Schema::new(fields));
1630 Ok(RecordBatch::try_new(schema, arrays)?)
1631 }
1632
1633 #[inline]
1634 fn expect_slot(&self, ordinal: u32) -> Option<(u32, &[u8])> {
1635 self.ordinal_expect
1636 .get(ordinal as usize)
1637 .and_then(|entry| entry.as_ref())
1638 .map(|(slot, raw)| (*slot, raw.as_slice()))
1639 }
1640
1641 #[inline]
1642 fn record_slot(&mut self, ordinal: u32, slot: u32, raw_name: &[u8]) {
1643 let idx = ordinal as usize;
1644 if idx >= self.ordinal_expect.len() {
1645 self.ordinal_expect.resize_with(idx + 1, || None);
1646 }
1647 self.ordinal_expect[idx] = Some((slot, raw_name.to_vec()));
1648 }
1649
1650 #[inline]
1651 fn layout_broken(&mut self, ordinal: u32) {
1652 if let Some(entry) = self.ordinal_expect.get_mut(ordinal as usize) {
1653 *entry = None;
1654 }
1655 }
1656
1657 #[inline]
1658 fn reset_child_ordinal(&mut self) {
1659 self.current_ordinal = 0;
1660 }
1661}
1662
1663#[cfg(test)]
1668mod tests {
1669 use super::*;
1670 use crate::columnar::ColumnBuilder;
1671 use crate::decoder::{ColumnarSink, RecordParser, Splitter};
1672 use crate::plan::{CompareOp, ExecutionPlan, FieldType, FilterPredicate};
1673 use crate::value::Value;
1674 use crate::Result;
1675 use arrow::array::{Array, AsArray};
1676
1677 struct LineParser;
1680
1681 impl RecordParser for LineParser {
1682 fn validate(&self, bytes: &[u8]) -> Result<()> {
1683 simdutf8::basic::from_utf8(bytes)?;
1684 Ok(())
1685 }
1686
1687 fn parse_chunk(&self, bytes: &[u8], sink: &mut dyn ColumnarSink) -> Result<()> {
1688 let text = std::str::from_utf8(bytes).map_err(|e| crate::Error::Plan(e.to_string()))?;
1689 for line in text.lines() {
1690 if line.is_empty() {
1691 continue;
1692 }
1693 sink.begin_row();
1694 for token in line.split_whitespace() {
1695 if let Some((k, v)) = token.split_once('=') {
1696 sink.put_field(k, Value::Str(Cow::Borrowed(v)));
1697 }
1698 }
1699 sink.end_row();
1700 }
1701 Ok(())
1702 }
1703 }
1704
1705 struct LineSplitter;
1706
1707 impl Splitter for LineSplitter {
1708 fn next_record_start(&self, bytes: &[u8], from: usize) -> Option<usize> {
1709 if from >= bytes.len() {
1710 return None;
1711 }
1712 let start = if bytes[from] == b'\n' { from + 1 } else { from };
1714 if start >= bytes.len() {
1715 return None;
1716 }
1717 memchr::memchr(b'\n', &bytes[start..]).map(|rel| start + rel + 1)
1718 }
1719
1720 fn find_split_points(&self, bytes: &[u8], max_chunks: usize) -> Vec<usize> {
1721 if max_chunks <= 1 || bytes.is_empty() {
1722 return vec![0, bytes.len()];
1723 }
1724 let mut points = vec![0usize];
1725 let mut last = 0;
1726 for (i, &b) in bytes.iter().enumerate() {
1727 if b == b'\n' {
1728 let next = i + 1;
1729 if next > last && points.len() < max_chunks {
1730 points.push(next);
1731 last = next;
1732 }
1733 }
1734 }
1735 if *points.last().unwrap() != bytes.len() {
1736 points.push(bytes.len());
1737 }
1738 points
1739 }
1740
1741 fn estimate_bytes_per_row(&self, sample: &[u8]) -> usize {
1742 let newline_count = sample.iter().filter(|&&b| b == b'\n').count().max(1);
1743 (sample.len() / newline_count).max(1)
1744 }
1745 }
1746
1747 fn parse_bytes(bytes: &[u8], plan: ExecutionPlan) -> TableBuilder {
1748 let mut sink = TableBuilder::with_plan((bytes.len() / 16).max(4), Arc::new(plan));
1749 LineParser.parse_chunk(bytes, &mut sink).unwrap();
1750 sink
1751 }
1752
1753 #[test]
1754 fn test_extend_no_duplicates() {
1755 let e1 = parse_bytes(b"A=1 B=2\n", ExecutionPlan::new());
1756 let mut merged = TableBuilder::new();
1757 merged.extend(e1).unwrap();
1758 assert_eq!(merged.num_rows(), 1);
1759 for col in &merged.columns {
1760 assert_eq!(col.len(), merged.num_rows(), "column length mismatch");
1761 }
1762 }
1763
1764 #[test]
1765 fn test_multi_chunk_same_as_single() {
1766 let data = b"A=1\nA=2\nA=3\n";
1767 let single = parse_bytes(data, ExecutionPlan::new());
1768 assert_eq!(single.num_rows(), 3);
1769
1770 let splitter = LineSplitter;
1771 let points = splitter.find_split_points(data, 2);
1772 let mut merged = TableBuilder::new();
1773 for w in points.windows(2) {
1774 let chunk = &data[w[0]..w[1]];
1775 let engine = parse_bytes(chunk, ExecutionPlan::new());
1776 merged.extend(engine).unwrap();
1777 }
1778 assert_eq!(merged.num_rows(), single.num_rows());
1779 }
1780
1781 #[test]
1782 fn test_last_write_wins_duplicate_field() {
1783 let engine = parse_bytes(b"X=10 X=20\n", ExecutionPlan::new());
1784 assert_eq!(engine.num_rows(), 1);
1785 let col = engine.get_column("X").unwrap();
1786 assert_eq!(col.as_str_vec(), vec![Some("20".into())]);
1787 }
1788
1789 #[test]
1790 fn test_build_plan_rename() {
1791 let mut plan = ExecutionPlan::new();
1792 plan.field_map.insert("X".to_string(), "Y".to_string());
1793 let engine = parse_bytes(b"X=hello\n", plan);
1794 assert_eq!(engine.num_rows(), 1);
1795 assert!(engine.get_column("Y").is_some());
1796 assert!(engine.get_column("X").is_none());
1797 assert_eq!(
1798 engine.get_column("Y").unwrap().as_str_vec(),
1799 vec![Some("hello".into())]
1800 );
1801 }
1802
1803 #[test]
1804 fn test_build_plan_drop() {
1805 let mut plan = ExecutionPlan::new();
1806 plan.drop_fields.insert("X".to_string());
1807 let engine = parse_bytes(b"X=hello Y=world\n", plan);
1808 assert_eq!(engine.num_rows(), 1);
1809 assert!(engine.get_column("X").is_none());
1810 assert!(engine.get_column("Y").is_some());
1811 }
1812
1813 #[test]
1814 fn test_build_plan_filter_ne() {
1815 let mut plan = ExecutionPlan::new();
1816 plan.filter = Some(FilterPredicate::NotEqual {
1817 field: "X".to_string(),
1818 value: "42".to_string(),
1819 });
1820 let engine = parse_bytes(b"X=10\nX=42\nX=30\n", plan);
1821 assert_eq!(engine.num_rows(), 2);
1822 let col = engine.get_column("X").unwrap();
1823 assert_eq!(col.as_str_vec(), vec![Some("10".into()), Some("30".into())]);
1824 }
1825
1826 #[test]
1827 fn test_build_plan_filter_eq() {
1828 let mut plan = ExecutionPlan::new();
1829 plan.filter = Some(FilterPredicate::Equal {
1830 field: "X".to_string(),
1831 value: "10".to_string(),
1832 });
1833 let engine = parse_bytes(b"X=10\nX=20\nX=10\n", plan);
1834 assert_eq!(engine.num_rows(), 2);
1835 let col = engine.get_column("X").unwrap();
1836 assert_eq!(col.as_str_vec(), vec![Some("10".into()), Some("10".into())]);
1837 }
1838
1839 #[test]
1840 fn test_build_plan_filter_missing_field() {
1841 let mut plan = ExecutionPlan::new();
1842 plan.filter = Some(FilterPredicate::NotEqual {
1843 field: "X".to_string(),
1844 value: "10".to_string(),
1845 });
1846 let engine = parse_bytes(b"X=10\nY=99\n", plan);
1847 assert_eq!(engine.num_rows(), 1);
1848 let col = engine.get_column("Y").unwrap();
1849 assert_eq!(col.as_str_vec(), vec![Some("99".into())]);
1850 }
1851
1852 #[test]
1853 fn test_typed_int64_column() {
1854 let mut plan = ExecutionPlan::new();
1855 plan.field_types.insert("X".to_string(), FieldType::Int64);
1856 let engine = parse_bytes(b"X=42\nX=bad\nX=100\n", plan);
1857 assert_eq!(engine.num_rows(), 3);
1858 if let ColumnBuilder::Int64(v) = engine.get_column("X").unwrap() {
1859 assert_eq!(v.get(0), Some(42));
1860 assert_eq!(v.get(1), None);
1861 assert_eq!(v.get(2), Some(100));
1862 } else {
1863 panic!("expected Int64 builder");
1864 }
1865 }
1866
1867 #[test]
1868 fn test_typed_float64_column() {
1869 let mut plan = ExecutionPlan::new();
1870 plan.field_types.insert("X".to_string(), FieldType::Float64);
1871 let engine = parse_bytes(b"X=1.5\n", plan);
1872 if let ColumnBuilder::Float64(v) = engine.get_column("X").unwrap() {
1873 assert!((v.get(0).unwrap() - 1.5).abs() < 1e-9);
1874 } else {
1875 panic!("expected Float64 builder");
1876 }
1877 }
1878
1879 #[test]
1880 fn test_dictionary_column() {
1881 let mut plan = ExecutionPlan::new();
1882 plan.dictionary_columns.insert("P".to_string());
1883 let engine = parse_bytes(b"P=Widget\nP=Gadget\nP=Widget\n", plan);
1884 assert_eq!(engine.num_rows(), 3);
1885 if let ColumnBuilder::Dictionary { codes, dict, .. } = engine.get_column("P").unwrap() {
1886 assert_eq!(dict.len(), 2);
1887 assert_eq!(
1888 codes.iter().map(|o| o.copied()).collect::<Vec<_>>(),
1889 vec![Some(0), Some(1), Some(0)]
1890 );
1891 } else {
1892 panic!("expected Dictionary builder");
1893 }
1894 }
1895
1896 #[test]
1897 fn test_ragged_late_chunk_column_debut() {
1898 let e1 = parse_bytes(b"A=1 B=2\nA=3\n", ExecutionPlan::new());
1899 let e2 = parse_bytes(b"B=4 C=5\n", ExecutionPlan::new());
1900 let mut merged = TableBuilder::new();
1901 merged.extend(e1).unwrap();
1902 merged.extend(e2).unwrap();
1903
1904 assert_eq!(
1905 merged.get_column("A").unwrap().as_str_vec(),
1906 vec![Some("1".into()), Some("3".into()), None]
1907 );
1908 assert_eq!(
1909 merged.get_column("B").unwrap().as_str_vec(),
1910 vec![Some("2".into()), None, Some("4".into())]
1911 );
1912 assert_eq!(
1913 merged.get_column("C").unwrap().as_str_vec(),
1914 vec![None, None, Some("5".into())]
1915 );
1916 }
1917
1918 #[test]
1919 fn test_auto_dict_upgrade_only_post_merge() {
1920 let mut plan = ExecutionPlan::new();
1921 plan.auto_dict = true;
1922 let a = parse_bytes(b"P=x\nP=y\n", plan.clone());
1923 let b = parse_bytes(b"P=x\nP=y\n", plan.clone());
1924 let mut merged = TableBuilder::with_plan(64, Arc::new(plan));
1925 merged.extend(a).unwrap();
1926 merged.extend(b).unwrap();
1927 merged.auto_dict_upgrade();
1928 assert_eq!(merged.num_rows(), 4);
1929 }
1930
1931 #[test]
1932 fn test_extend_string_dictionary_promotes_not_panics() {
1933 let mut e1 = parse_bytes(b"P=x\n", ExecutionPlan::new());
1934 let mut plan = ExecutionPlan::new();
1935 plan.dictionary_columns.insert("P".to_string());
1936 let e2 = parse_bytes(b"P=x\n", plan);
1937 e1.extend(e2).expect("String/Dictionary must reconcile");
1939 assert!(matches!(
1940 e1.get_column("P").unwrap(),
1941 crate::columnar::ColumnBuilder::Dictionary { .. }
1942 ));
1943 }
1944
1945 #[test]
1946 fn test_extend_irreconcilable_variants_error_not_panic() {
1947 let mut e1 = parse_bytes(b"S=x\n", ExecutionPlan::new());
1948 let mut plan = ExecutionPlan::new();
1949 plan.field_types.insert("S".to_string(), FieldType::Int64);
1950 let e2 = parse_bytes(b"S=7\n", plan);
1951 let result = e1.extend(e2);
1952 match result {
1953 Err(crate::Error::Merge(msg)) => {
1954 assert!(msg.contains("'S'"), "error should name the column: {msg}");
1955 }
1956 other => panic!("String/Int64 mismatch must return Merge error, got {other:?}"),
1957 }
1958 }
1959
1960 #[test]
1961 fn test_compare_filter_via_arrow_compute() {
1962 use crate::arrow_export::apply_compare_filter;
1963
1964 let mut plan = ExecutionPlan::new();
1965 plan.filter = Some(FilterPredicate::Compare {
1966 field_a: "A".to_string(),
1967 op: CompareOp::Gt,
1968 field_b: "B".to_string(),
1969 });
1970 let mut engine = parse_bytes(b"A=3 B=1\nA=2 B=2\nA=5 B=4\n", plan);
1971 let batch = engine.finish().unwrap();
1972 let filtered = apply_compare_filter(
1973 batch,
1974 &FilterPredicate::Compare {
1975 field_a: "A".to_string(),
1976 op: CompareOp::Gt,
1977 field_b: "B".to_string(),
1978 },
1979 )
1980 .unwrap();
1981 assert_eq!(filtered.num_rows(), 2);
1982 let a = filtered.column_by_name("A").unwrap().as_string::<i32>();
1983 assert_eq!(a.value(0), "3");
1984 assert_eq!(a.value(1), "5");
1985 }
1986
1987 #[test]
1988 fn test_row_dirty_is_full_edge_cases() {
1989 for ncols in [1, 63, 64, 65, 127, 128, 129] {
1992 let mut tb = TableBuilder::new();
1993 for i in 0..ncols {
1994 let name = format!("col{i}");
1995 tb.field_index.insert(name.clone(), i);
1996 tb.columns.push(crate::columnar::ColumnBuilder::String(
1997 crate::columnar::StrColumn::default(),
1998 ));
1999 tb.column_order.push(name);
2000 }
2001 tb.row_dirty = vec![0; ncols.div_ceil(64)];
2003 for i in 0..ncols {
2005 let word = i / 64;
2006 let bit = i % 64;
2007 tb.row_dirty[word] |= 1u64 << bit;
2008 }
2009 let full_words = ncols / 64;
2010 let rem = ncols % 64;
2011 let is_full = (0..full_words).all(|w| tb.row_dirty[w] == u64::MAX)
2012 && (rem == 0
2013 || tb.row_dirty.get(full_words).copied().unwrap_or(0) == (1u64 << rem) - 1);
2014 assert!(
2015 is_full,
2016 "ncols={ncols} should be full, row_dirty={:?}",
2017 tb.row_dirty
2018 );
2019 if ncols > 0 {
2021 let word = (ncols - 1) / 64;
2022 let bit = (ncols - 1) % 64;
2023 tb.row_dirty[word] &= !(1u64 << bit);
2024 let is_full2 = (0..full_words).all(|w| tb.row_dirty[w] == u64::MAX)
2025 && (rem == 0
2026 || tb.row_dirty.get(full_words).copied().unwrap_or(0) == (1u64 << rem) - 1);
2027 assert!(
2028 !is_full2,
2029 "ncols={ncols} should not be full after clearing one bit"
2030 );
2031 }
2032 }
2033 }
2034
2035 #[test]
2036 fn test_finish_twice_does_not_panic() {
2037 let mut tb = parse_bytes(b"A=1 B=2\nA=3 B=4\n", ExecutionPlan::new());
2040 let batch1 = tb.finish().unwrap();
2041 assert_eq!(batch1.num_rows(), 2);
2042 let batch2 = tb.finish().unwrap();
2044 assert_eq!(batch2.num_rows(), 0);
2045 }
2046
2047 #[test]
2048 fn test_c2_compound_reorder() {
2049 let data = b"A=1 B=2\nA=2 B=2\nA=1 B=3\nA=2 B=3\n";
2052 let make_filter = |a: &str, va: &str, b: &str, vb: &str| -> ExecutionPlan {
2053 let mut plan = ExecutionPlan::new();
2054 plan.filter = Some(FilterPredicate::And(
2055 Box::new(FilterPredicate::Equal {
2056 field: a.to_string(),
2057 value: va.to_string(),
2058 }),
2059 Box::new(FilterPredicate::Equal {
2060 field: b.to_string(),
2061 value: vb.to_string(),
2062 }),
2063 ));
2064 plan
2065 };
2066 let r1 = parse_bytes(data, make_filter("A", "1", "B", "2"));
2067 let r2 = parse_bytes(data, make_filter("B", "2", "A", "1"));
2068 assert_eq!(
2069 r1.num_rows(),
2070 r2.num_rows(),
2071 "C2 reorder must produce identical results"
2072 );
2073 assert_eq!(r1.num_rows(), 1); }
2075
2076 #[test]
2077 fn test_c2_or_reorder() {
2078 let data = b"A=1 B=2\nA=2 B=2\nA=3 B=3\n";
2083 let make_filter = |a: &str, va: &str, b: &str, vb: &str| -> ExecutionPlan {
2084 let mut plan = ExecutionPlan::new();
2085 plan.filter = Some(FilterPredicate::Or(
2086 Box::new(FilterPredicate::Equal {
2087 field: a.to_string(),
2088 value: va.to_string(),
2089 }),
2090 Box::new(FilterPredicate::Equal {
2091 field: b.to_string(),
2092 value: vb.to_string(),
2093 }),
2094 ));
2095 plan
2096 };
2097 let r1 = parse_bytes(data, make_filter("A", "1", "B", "3"));
2098 let r2 = parse_bytes(data, make_filter("B", "3", "A", "1"));
2099 assert_eq!(
2100 r1.num_rows(),
2101 r2.num_rows(),
2102 "Or reorder must produce identical results"
2103 );
2104 assert_eq!(r1.num_rows(), 2); }
2106
2107 #[test]
2108 fn test_predicate_slot_created_after_mask_build() {
2109 let data = b"A=1 B=ok\nA=2 B=ok\nA=3 B=ok\n";
2117 let mut plan = ExecutionPlan::new();
2118 plan.filter = Some(FilterPredicate::Equal {
2119 field: "B".to_string(),
2120 value: "reject".to_string(),
2121 });
2122 let engine = parse_bytes(data, plan);
2123 assert_eq!(
2124 engine.num_rows(),
2125 0,
2126 "all rows should be rejected (B != reject)"
2127 );
2128
2129 let data2 = b"A=1 B=ok\nA=2 B=reject\nA=3 B=ok\n";
2131 let mut plan2 = ExecutionPlan::new();
2132 plan2.filter = Some(FilterPredicate::Equal {
2133 field: "B".to_string(),
2134 value: "ok".to_string(),
2135 });
2136 let engine2 = parse_bytes(data2, plan2);
2137 assert_eq!(engine2.num_rows(), 2, "rows 1 and 3 pass (B == ok)");
2138 let col = engine2.get_column("A").unwrap();
2139 assert_eq!(col.as_str_vec(), vec![Some("1".into()), Some("3".into())]);
2140 }
2141
2142 #[test]
2143 fn test_predicate_first_via_resolve_and_put() {
2144 let mut plan = ExecutionPlan::new();
2147 plan.filter = Some(FilterPredicate::Equal {
2148 field: "B".to_string(),
2149 value: "reject".to_string(),
2150 });
2151 let mut tb = TableBuilder::with_plan(16, Arc::new(plan));
2152 tb.begin_row();
2154 tb.resolve_and_put("A", Value::Str(Cow::Borrowed("1")));
2155 tb.resolve_and_put("B", Value::Str(Cow::Borrowed("ok")));
2156 tb.end_row();
2157 tb.begin_row();
2159 tb.resolve_and_put("A", Value::Str(Cow::Borrowed("2")));
2160 tb.resolve_and_put("B", Value::Str(Cow::Borrowed("reject")));
2161 tb.end_row();
2162 tb.begin_row();
2164 tb.resolve_and_put("A", Value::Str(Cow::Borrowed("3")));
2165 tb.resolve_and_put("B", Value::Str(Cow::Borrowed("ok")));
2166 tb.end_row();
2167 let batch = tb.finish().unwrap();
2168 assert_eq!(batch.num_rows(), 1, "only row 2 (B==reject) should pass");
2169 }
2170
2171 #[test]
2172 fn test_owned_cow_values_survive_buffered_filter() {
2173 let mut plan = ExecutionPlan::new();
2182 plan.filter = Some(FilterPredicate::Equal {
2183 field: "B".to_string(),
2184 value: "ok".to_string(),
2185 });
2186 let mut tb = TableBuilder::with_plan(16, Arc::new(plan));
2187 for i in 0..50 {
2188 tb.begin_row();
2189 let a = Cow::Owned(format!("value-{i}-unescaped"));
2191 let b = Cow::Owned(if i % 2 == 0 {
2192 "ok".to_string()
2193 } else {
2194 "no".to_string()
2195 });
2196 tb.resolve_and_put("A", Value::Str(a));
2197 tb.resolve_and_put("B", Value::Str(b));
2198 tb.end_row();
2199 }
2200 assert_eq!(tb.num_rows(), 25, "even rows pass (B == ok)");
2201 let col = tb.get_column("A").unwrap();
2202 let vals = col.as_str_vec();
2203 assert_eq!(vals.len(), 25);
2204 assert_eq!(vals[0], Some("value-0-unescaped".to_string()));
2205 assert_eq!(vals[24], Some("value-48-unescaped".to_string()));
2206 }
2207
2208 #[test]
2209 fn test_predicate_first_skip_via_resolve_and_put() {
2210 let mut plan = ExecutionPlan::new();
2214 plan.filter = Some(FilterPredicate::Equal {
2215 field: "A".to_string(),
2216 value: "999".to_string(),
2217 });
2218 let mut tb = TableBuilder::with_plan(16, Arc::new(plan));
2219 for _i in 0..100 {
2220 tb.begin_row();
2221 tb.resolve_and_put("A", Value::Str(Cow::Borrowed("0")));
2222 tb.resolve_and_put("B", Value::Str(Cow::Borrowed("x")));
2223 tb.resolve_and_put("C", Value::Str(Cow::Borrowed("y")));
2224 tb.end_row();
2225 }
2226 let batch = tb.finish().unwrap();
2227 assert_eq!(
2228 batch.num_rows(),
2229 0,
2230 "all rows should be rejected (A=0 != 999)"
2231 );
2232 }
2233
2234 #[test]
2235 fn test_sparse_column_predicate_skip() {
2236 let mut plan = ExecutionPlan::new();
2245 plan.filter = Some(FilterPredicate::Equal {
2246 field: "A".to_string(),
2247 value: "reject".to_string(),
2248 });
2249 let mut tb = TableBuilder::with_plan(128, Arc::new(plan));
2250 for i in 0..100 {
2251 tb.begin_row();
2252 tb.resolve_and_put("A", Value::Str(Cow::Borrowed("ok")));
2253 tb.resolve_and_put("B", Value::Str(Cow::Borrowed("x")));
2254 tb.resolve_and_put("C", Value::Str(Cow::Borrowed("y")));
2255 if i >= 50 {
2256 tb.resolve_and_put("D", Value::Str(Cow::Borrowed("z")));
2257 }
2258 tb.end_row();
2259 }
2260 let batch = tb.finish().unwrap();
2261 assert_eq!(batch.num_rows(), 0, "all rows rejected (A=ok != reject)");
2262 }
2263
2264 #[test]
2265 fn test_sparse_column_predicate_pass() {
2266 let mut plan = ExecutionPlan::new();
2269 plan.filter = Some(FilterPredicate::Equal {
2270 field: "A".to_string(),
2271 value: "ok".to_string(),
2272 });
2273 let mut tb = TableBuilder::with_plan(128, Arc::new(plan));
2274 for _i in 0..100 {
2275 tb.begin_row();
2276 tb.resolve_and_put("A", Value::Str(Cow::Borrowed("ok")));
2277 tb.resolve_and_put("B", Value::Str(Cow::Borrowed("x")));
2278 tb.resolve_and_put("C", Value::Str(Cow::Borrowed("y")));
2279 if _i >= 50 {
2280 tb.resolve_and_put("D", Value::Str(Cow::Borrowed("z")));
2281 }
2282 tb.end_row();
2283 }
2284 let batch = tb.finish().unwrap();
2285 assert_eq!(batch.num_rows(), 100, "all rows pass (A=ok == ok)");
2286 if let Some(col) = batch.column_by_name("D") {
2288 let arr = col.as_string::<i32>();
2289 for i in 0..50 {
2290 assert!(arr.is_null(i), "row {} should have D=null", i);
2291 }
2292 for i in 50..100 {
2293 assert!(
2294 !arr.is_null(i),
2295 "row {} should not be null (D len={}, total rows={})",
2296 i,
2297 arr.len(),
2298 batch.num_rows()
2299 );
2300 assert_eq!(arr.value(i), "z", "rows 50+ should have D=z");
2301 }
2302 } else {
2303 panic!("D column should exist");
2304 }
2305 }
2306
2307 #[test]
2308 fn test_sparse_late_predicate_ordinal() {
2309 let mut plan = ExecutionPlan::new();
2313 plan.filter = Some(FilterPredicate::Equal {
2314 field: "E".to_string(),
2315 value: "999".to_string(),
2316 });
2317 let mut tb = TableBuilder::with_plan(128, Arc::new(plan));
2318 for _i in 0..30 {
2320 tb.begin_row();
2321 tb.resolve_and_put("A", Value::Str(Cow::Borrowed("x")));
2322 tb.resolve_and_put("B", Value::Str(Cow::Borrowed("y")));
2323 tb.end_row();
2324 }
2325 for _i in 30..100 {
2327 tb.begin_row();
2328 tb.resolve_and_put("A", Value::Str(Cow::Borrowed("x")));
2329 tb.resolve_and_put("B", Value::Str(Cow::Borrowed("y")));
2330 tb.resolve_and_put("C", Value::Str(Cow::Borrowed("c")));
2331 tb.resolve_and_put("D", Value::Str(Cow::Borrowed("d")));
2332 tb.resolve_and_put("E", Value::Str(Cow::Borrowed("e")));
2333 tb.end_row();
2334 }
2335 let batch = tb.finish().unwrap();
2336 assert_eq!(batch.num_rows(), 0, "all rows rejected (E=\"e\" != 999)");
2338 }
2339
2340 #[test]
2341 fn raw_name_helpers_apply_rename_and_drop() {
2342 use crate::decoder::ColumnarSink;
2343
2344 let plan = ExecutionPlan::new()
2345 .rename("raw", "renamed")
2346 .drop("ignored");
2347 let mut tb = TableBuilder::with_plan(2, Arc::new(plan));
2348 tb.begin_row();
2349 tb.resolve_and_put_raw(b"raw", Value::Str(Cow::Borrowed("value")));
2350 tb.resolve_and_put_raw(b"ignored", Value::Str(Cow::Borrowed("not stored")));
2351 tb.put_row(&[("other", Value::Str(Cow::Borrowed("also stored")))]);
2352 tb.end_row();
2353
2354 assert_eq!(tb.column_names(), &["renamed", "other"]);
2355 assert_eq!(tb.resolve_raw(b"raw"), Some("renamed"));
2356 }
2357}