#[cfg(feature = "sql")]
pub mod sql;
#[cfg(feature = "sql")]
pub mod table;
use crate::fold::Fold;
use crate::part::{attrs, Part};
use crate::types::AttrValue;
use anyhow::{bail, Result};
use arrow::array::{
ArrayRef, BinaryArray, BinaryBuilder, BooleanBuilder, Float64Builder, Int32Array, Int64Builder,
StringArray, StringBuilder, TimestampNanosecondBuilder, UInt64Builder,
};
use arrow::datatypes::{DataType, Field, Schema, SchemaRef, TimeUnit};
use arrow::record_batch::{RecordBatch, RecordBatchOptions};
use std::collections::{BTreeMap, BTreeSet};
use std::sync::Arc;
pub const BATCH_ROWS: usize = 8192;
pub const BATCH_BYTES: usize = crate::scan::DEFAULT_MAX_RECONSTRUCTED_BYTES as usize;
pub const F_ID: &str = "id";
pub const F_BODY: &str = "body";
fn type_name(tag: u8) -> &'static str {
match tag {
0 => "str",
1 => "int",
2 => "float",
3 => "bool",
4 => "uint",
5 => "binary",
6 => "timestamp_ns",
7 => "null",
_ => "unknown",
}
}
fn arrow_type(tag: u8) -> DataType {
match tag {
0 => DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8)),
1 => DataType::Int64,
2 => DataType::Float64,
3 => DataType::Boolean,
4 => DataType::UInt64,
5 => DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Binary)),
6 => DataType::Timestamp(TimeUnit::Nanosecond, Some("UTC".into())),
7 => DataType::Boolean,
_ => DataType::Null,
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Cmp {
Eq,
Ne,
Lt,
LtEq,
Gt,
GtEq,
}
fn zone_disproves(op: Cmp, val: &AttrValue, zone: &(AttrValue, AttrValue)) -> bool {
use std::cmp::Ordering::{Equal, Greater, Less};
fn ord(a: &AttrValue, b: &AttrValue) -> Option<std::cmp::Ordering> {
match (a, b) {
(AttrValue::Int(x), AttrValue::Int(y)) => Some(x.cmp(y)),
(AttrValue::Float(x), AttrValue::Float(y)) => x.partial_cmp(y),
(AttrValue::Bool(x), AttrValue::Bool(y)) => Some(x.cmp(y)),
(AttrValue::UInt(x), AttrValue::UInt(y)) => Some(x.cmp(y)),
(AttrValue::TimestampNs(x), AttrValue::TimestampNs(y)) => Some(x.cmp(y)),
_ => None,
}
}
let (min, max) = zone;
let (Some(lo), Some(hi)) = (ord(val, min), ord(val, max)) else {
return false;
};
match op {
Cmp::Eq => lo == Less || hi == Greater,
Cmp::Ne => lo == Equal && hi == Equal,
Cmp::Lt => lo != Greater, Cmp::LtEq => lo == Less, Cmp::Gt => hi != Less, Cmp::GtEq => hi == Greater, }
}
#[derive(Clone, Debug)]
pub struct Pred {
pub field: usize,
pub op: Cmp,
pub val: AttrValue,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct ScanStats {
pub planning_duration_ns: u64,
pub execution_duration_ns: u64,
pub rows: usize,
pub batches: usize,
pub columns_decoded: usize,
pub fold_reads: usize,
pub rows_filtered: usize,
pub rows_hidden: usize,
pub batches_skipped: usize,
pub shadowed_occurrences: usize,
}
impl ScanStats {
pub fn since(&self, prev: ScanStats) -> ScanStats {
ScanStats {
planning_duration_ns: self.planning_duration_ns - prev.planning_duration_ns,
execution_duration_ns: self.execution_duration_ns - prev.execution_duration_ns,
rows: self.rows - prev.rows,
batches: self.batches - prev.batches,
columns_decoded: self.columns_decoded - prev.columns_decoded,
fold_reads: self.fold_reads - prev.fold_reads,
rows_filtered: self.rows_filtered - prev.rows_filtered,
rows_hidden: self.rows_hidden - prev.rows_hidden,
batches_skipped: self.batches_skipped - prev.batches_skipped,
shadowed_occurrences: self.shadowed_occurrences - prev.shadowed_occurrences,
}
}
pub fn add(&mut self, o: ScanStats) {
self.planning_duration_ns =
self.planning_duration_ns.saturating_add(o.planning_duration_ns);
self.execution_duration_ns =
self.execution_duration_ns.saturating_add(o.execution_duration_ns);
self.rows += o.rows;
self.batches += o.batches;
self.columns_decoded += o.columns_decoded;
self.fold_reads += o.fold_reads;
self.rows_filtered += o.rows_filtered;
self.rows_hidden += o.rows_hidden;
self.batches_skipped += o.batches_skipped;
self.shadowed_occurrences += o.shadowed_occurrences;
}
}
pub struct Lens {
schema: SchemaRef,
binding: Vec<Binding>,
visible: Vec<(Arc<Part>, Arc<Vec<usize>>)>,
}
#[derive(Clone)]
enum Binding {
Id,
Content(String),
Attr(String, u8),
}
fn content_field(name: &str) -> String {
if name == crate::types::BODY_CONTENT {
F_BODY.to_string()
} else {
format!("content.{name}")
}
}
impl Lens {
pub fn new(parts: &[Arc<Part>]) -> Result<Lens> {
let visibility = crate::store::read::visibility(parts)?;
let mut tags: BTreeMap<String, BTreeSet<u8>> = BTreeMap::new();
for p in parts {
if !p.has_columns() {
continue;
}
for (key, tag, _, _) in attrs::read_meta(p)? {
tags.entry(key).or_default().insert(tag);
}
}
let mut content_names = BTreeSet::new();
for p in parts {
for content in p.content_meta()?.iter() {
content_names.insert(content.name.clone());
}
}
let mut fields = vec![Field::new(F_ID, DataType::Utf8, false)];
let mut binding = vec![Binding::Id];
let mut used: std::collections::HashSet<String> =
[F_ID].into_iter().map(String::from).collect();
for name in content_names {
let field = content_field(&name);
if !used.insert(field.clone()) {
bail!("content {name:?} maps to duplicate query field {field:?}");
}
fields.push(Field::new(&field, DataType::Binary, true));
binding.push(Binding::Content(name));
}
for (key, ts) in &tags {
for &t in ts {
let mut name = if ts.len() == 1 && t != 7 {
key.clone()
} else {
format!("{key}#{}", type_name(t))
};
if used.contains(&name) {
name = format!("{key}#{}", type_name(t));
}
let mut n = 2usize;
while used.contains(&name) {
name = format!("{key}#{}#{n}", type_name(t));
n += 1;
}
used.insert(name.clone());
fields.push(Field::new(&name, arrow_type(t), true));
binding.push(Binding::Attr(key.clone(), t));
}
}
let visible =
parts.iter().cloned().zip(visibility.rows.into_iter().map(Arc::new)).collect();
Ok(Lens { schema: Arc::new(Schema::new(fields)), binding, visible })
}
pub fn schema(&self) -> SchemaRef {
self.schema.clone()
}
pub fn project(&self, names: &[&str]) -> Result<Vec<usize>> {
names
.iter()
.map(|n| {
self.schema
.index_of(n)
.map_err(|_| anyhow::anyhow!("no column {n:?} in this store"))
})
.collect()
}
pub(crate) fn projection_reads_content(&self, projection: &[usize]) -> bool {
projection.iter().any(|&f| matches!(self.binding.get(f), Some(Binding::Content(_))))
}
pub fn scan(
&self,
part: &Arc<Part>,
fold: Option<&Arc<Fold>>,
projection: &[usize],
preds: &[Pred],
) -> Result<PartScan> {
let proj: Vec<usize> = projection.to_vec();
for &f in &proj {
if f >= self.binding.len() {
bail!("projection names field {f}, past the end of the schema");
}
}
if self.projection_reads_content(&proj) && fold.is_none() {
bail!("a content column was projected but no fold was supplied to read it from");
}
let fields: Vec<Field> = proj.iter().map(|&f| self.schema.field(f).clone()).collect();
let out_schema = Arc::new(Schema::new(fields));
let meta = if part.has_columns() { attrs::read_meta(part)? } else { Vec::new() };
let mut cols: Vec<Col> = Vec::with_capacity(proj.len());
let mut decoded = 0usize;
for &f in &proj {
match &self.binding[f] {
Binding::Id => cols.push(Col::Id),
Binding::Content(name) => cols.push(Col::Content(name.clone())),
Binding::Attr(key, tag) => {
let want = (key.clone(), *tag);
match meta.iter().position(|(k, t, _, _)| *k == want.0 && *t == want.1) {
Some(c) => {
let (_, tag, occ, kind) = meta[c].clone();
decoded += 1;
cols.push(Col::Attr {
tag,
rids: attrs::rids(part, c, occ, kind)?,
val: part.column_values(c)?,
dict: if tag == 0 {
attrs::read_dict(part, c)?
} else {
Default::default()
},
binary_dict: if tag == 5 {
attrs::read_binary_dict(part, c)?
} else {
Default::default()
},
});
}
None => cols.push(Col::Missing(self.schema.field(f).data_type().clone())),
}
}
}
}
let mut tests: Vec<Test> = Vec::with_capacity(preds.len());
for p_ in preds {
let Some(Binding::Attr(key, tag)) = self.binding.get(p_.field).cloned() else {
continue; };
let Some(c) = meta.iter().position(|(k, t, _, _)| *k == key && *t == tag) else {
tests.push(Test::Never);
continue;
};
if let Some(zone) = part.zone(c)? {
if zone_disproves(p_.op, &p_.val, &zone) {
tests.push(Test::Never);
continue;
}
}
let (_, tag, occ, kind) = meta[c].clone();
let rids = attrs::rids(part, c, occ, kind)?;
let k = match (&p_.val, tag) {
(AttrValue::Str(v), 0) => {
let dict = attrs::read_dict(part, c)?;
match dict.binary_search_by(|d| d.as_str().cmp(v.as_str())) {
Ok(i) => Key::Ord { k: i as u32, exact: true },
Err(i) => Key::Ord { k: i as u32, exact: false },
}
}
(AttrValue::Int(v), 1) => Key::Int(*v),
(AttrValue::Float(v), 2) => Key::Float(*v),
(AttrValue::Bool(v), 3) => Key::Bool(*v),
(AttrValue::UInt(v), 4) => Key::UInt(*v),
(AttrValue::Bytes(v), 5) => {
let dict = attrs::read_binary_dict(part, c)?;
match dict.binary_search(v) {
Ok(i) => Key::Ord { k: i as u32, exact: true },
Err(i) => Key::Ord { k: i as u32, exact: false },
}
}
(AttrValue::TimestampNs(v), 6) => Key::TimestampNs(*v),
(AttrValue::Null, 7) => Key::Null,
_ => {
tests.push(Test::Present { rids });
continue;
}
};
tests.push(Test::Col { tag, rids, val: part.column_values(c)?, op: p_.op, key: k });
}
let ids = if cols.iter().any(|c| matches!(c, Col::Id)) {
part.ids()?
} else {
Arc::new(Vec::new())
};
let visible = self
.visible
.iter()
.find(|(p, _)| Arc::ptr_eq(p, part))
.map(|(_, rows)| rows.clone())
.ok_or_else(|| anyhow::anyhow!("part is not a member of this lens"))?;
Ok(PartScan {
n: part.len(),
part: part.clone(),
fold: fold.cloned(),
schema: out_schema,
cols,
ids,
row: 0,
stats: ScanStats { columns_decoded: decoded, ..ScanStats::default() },
fetch: None,
tests,
visible,
})
}
}
enum Test {
Never,
Present {
rids: Arc<Vec<u32>>,
},
Col {
tag: u8,
rids: Arc<Vec<u32>>,
val: Arc<Vec<u8>>,
op: Cmp,
key: Key,
},
}
#[derive(Clone, Copy)]
enum Key {
Ord {
k: u32,
exact: bool,
},
Int(i64),
Float(f64),
Bool(bool),
UInt(u64),
TimestampNs(i64),
Null,
}
#[inline]
fn cmp_ok<T: PartialOrd>(op: Cmp, v: T, k: T) -> bool {
match op {
Cmp::Eq => v == k,
Cmp::Ne => v != k,
Cmp::Lt => v < k,
Cmp::LtEq => v <= k,
Cmp::Gt => v > k,
Cmp::GtEq => v >= k,
}
}
type ColTest<'a> = (&'a u8, &'a Arc<Vec<u8>>, &'a Cmp, &'a Key);
impl Test {
fn mark(&self, lo: usize, hi: usize, out: &mut [bool]) {
let (rids, body): (&Arc<Vec<u32>>, Option<ColTest<'_>>) = match self {
Test::Never => return,
Test::Present { rids } => (rids, None),
Test::Col { tag, rids, val, op, key } => (rids, Some((tag, val, op, key))),
};
let mut k = rids.partition_point(|&x| (x as usize) < lo);
while k < rids.len() && (rids[k] as usize) < hi {
let slot = rids[k] as usize - lo;
let ok = match body {
None => true,
Some((tag, val, op, key)) => {
let w = attrs::width(*tag);
let o = k * w;
if o + w > val.len() {
true } else {
match (*tag, key) {
(0, Key::Ord { k: kk, exact }) => {
let v = u32::from_le_bytes(val[o..o + 4].try_into().unwrap());
if *exact {
cmp_ok(*op, v, *kk)
} else {
match op {
Cmp::Eq => false,
Cmp::Ne => true,
Cmp::Lt | Cmp::LtEq => v < *kk,
Cmp::Gt | Cmp::GtEq => v >= *kk,
}
}
}
(1, Key::Int(kk)) => cmp_ok(
*op,
i64::from_le_bytes(val[o..o + 8].try_into().unwrap()),
*kk,
),
(2, Key::Float(kk)) => cmp_ok(
*op,
f64::from_bits(u64::from_le_bytes(
val[o..o + 8].try_into().unwrap(),
)),
*kk,
),
(3, Key::Bool(kk)) => cmp_ok(*op, val[o] != 0, *kk),
(4, Key::UInt(kk)) => cmp_ok(
*op,
u64::from_le_bytes(val[o..o + 8].try_into().unwrap()),
*kk,
),
(5, Key::Ord { k: kk, exact }) => {
let v = u32::from_le_bytes(val[o..o + 4].try_into().unwrap());
if *exact {
cmp_ok(*op, v, *kk)
} else {
match op {
Cmp::Eq => false,
Cmp::Ne => true,
Cmp::Lt | Cmp::LtEq => v < *kk,
Cmp::Gt | Cmp::GtEq => v >= *kk,
}
}
}
(6, Key::TimestampNs(kk)) => cmp_ok(
*op,
i64::from_le_bytes(val[o..o + 8].try_into().unwrap()),
*kk,
),
(7, Key::Null) => matches!(op, Cmp::Eq),
_ => true, }
}
}
};
if ok {
out[slot] = true;
}
k += 1;
}
}
}
enum Col {
Id,
Content(String),
Attr {
tag: u8,
rids: Arc<Vec<u32>>,
val: Arc<Vec<u8>>,
dict: Arc<Vec<String>>,
binary_dict: Arc<Vec<Vec<u8>>>,
},
Missing(DataType),
}
pub struct PartScan {
part: Arc<Part>,
fold: Option<Arc<Fold>>,
schema: SchemaRef,
cols: Vec<Col>,
ids: Arc<Vec<String>>,
row: usize,
n: usize,
stats: ScanStats,
fetch: Option<usize>,
tests: Vec<Test>,
visible: Arc<Vec<usize>>,
}
impl PartScan {
pub fn schema(&self) -> SchemaRef {
self.schema.clone()
}
pub fn stats(&self) -> ScanStats {
self.stats
}
pub fn rows_remaining(&self) -> usize {
self.n - self.row
}
pub fn with_fetch(mut self, n: Option<usize>) -> Self {
self.fetch = n;
self
}
fn select(&self, lo: usize, cap: usize) -> Vec<usize> {
let n = cap - lo;
let start = self.visible.partition_point(|&row| row < lo);
let visible: Vec<usize> = self.visible[start..]
.iter()
.take_while(|&&row| row < cap)
.map(|&row| row - lo)
.collect();
if self.tests.is_empty() {
return visible;
}
let mut keep = vec![false; n];
for &row in &visible {
keep[row] = true;
}
let mut scratch = vec![false; n];
for t in &self.tests {
if matches!(t, Test::Never) {
return Vec::new();
}
scratch.iter_mut().for_each(|b| *b = false);
t.mark(lo, cap, &mut scratch);
for i in 0..n {
keep[i] &= scratch[i];
}
}
(0..n).filter(|&i| keep[i]).collect()
}
pub fn next_batch(&mut self) -> Result<Option<RecordBatch>> {
if self.fetch.is_some_and(|f| self.stats.rows >= f) {
return Ok(None);
}
let end = self.n;
if self.row >= end {
return Ok(None);
}
let (lo, take) = loop {
if self.row >= end {
return Ok(None);
}
let lo = self.row;
let cap = (lo + BATCH_ROWS).min(end);
let take = self.select(lo, cap);
if take.is_empty() {
let first = self.visible.partition_point(|&row| row < lo);
let visible = self.visible.partition_point(|&row| row < cap) - first;
self.stats.rows_hidden += (cap - lo) - visible;
self.stats.rows_filtered += visible;
self.stats.batches_skipped += 1;
self.row = cap;
continue;
}
break (lo, take);
};
let mut content_values: Vec<Option<Vec<Option<Vec<u8>>>>> =
self.cols.iter().map(|c| matches!(c, Col::Content(_)).then(Vec::new)).collect();
let mut take = take;
if let Some(fetch) = self.fetch {
take.truncate(fetch - self.stats.rows);
}
if self.cols.iter().any(|c| matches!(c, Col::Content(_))) {
let fold = self.fold.as_ref().expect("checked when the scan was built");
let mut bytes = 0usize;
for (i, &r) in take.iter().enumerate() {
for (c, values) in self.cols.iter().zip(&mut content_values) {
let Col::Content(name) = c else { continue };
let value = self.part.reconstruct_content(lo + r, name, fold)?;
if let Some(b) = &value {
if b.len() > i32::MAX as usize {
bail!(
"content {name:?} at row {} is {} bytes; an Arrow binary column \
cannot exceed 2 GiB. Read it through Store::reconstruct_content.",
lo + r,
b.len()
);
}
bytes += b.len();
self.stats.fold_reads += 1;
}
values.as_mut().expect("content column allocated above").push(value);
}
if bytes >= BATCH_BYTES {
take.truncate(i + 1);
break;
}
}
}
let hi = lo + take.last().copied().map_or(0, |r| r + 1);
let len = take.len();
let first = self.visible.partition_point(|&row| row < lo);
let consumed_visible = self.visible.partition_point(|&row| row < hi) - first;
self.stats.rows_hidden += (hi - lo) - consumed_visible;
self.stats.rows_filtered += consumed_visible - len;
let mut arrays: Vec<ArrayRef> = Vec::with_capacity(self.cols.len());
for (column, values) in self.cols.iter().zip(&content_values) {
arrays.push(match column {
Col::Id => Arc::new(StringArray::from(
take.iter().map(|&r| self.ids[lo + r].as_str()).collect::<Vec<_>>(),
)) as ArrayRef,
Col::Content(_) => {
let mut b = BinaryBuilder::new();
for value in values.as_ref().expect("built above when content is projected") {
match value {
Some(v) => b.append_value(v),
None => b.append_null(),
}
}
Arc::new(b.finish()) as ArrayRef
}
Col::Missing(t) => arrow::array::new_null_array(t, len),
Col::Attr { tag, rids, val, dict, binary_dict } => scatter(
*tag,
rids,
val,
dict,
binary_dict,
lo,
hi,
&take,
&mut self.stats.shadowed_occurrences,
)?,
});
}
self.row = hi;
self.stats.rows += len;
self.stats.batches += 1;
Ok(Some(RecordBatch::try_new_with_options(
self.schema.clone(),
arrays,
&RecordBatchOptions::new().with_row_count(Some(len)),
)?))
}
}
#[allow(clippy::too_many_arguments)]
fn scatter(
tag: u8,
rids: &[u32],
val: &[u8],
dict: &[String],
binary_dict: &[Vec<u8>],
lo: usize,
hi: usize,
take: &[usize],
shadowed: &mut usize,
) -> Result<ArrayRef> {
let span = hi - lo;
let start = rids.partition_point(|&x| (x as usize) < lo);
let mut by_row: Vec<Option<usize>> = vec![None; span];
let mut k = start;
while k < rids.len() && (rids[k] as usize) < hi {
let slot = rids[k] as usize - lo;
if by_row[slot].is_none() {
by_row[slot] = Some(k);
} else {
*shadowed += 1;
}
k += 1;
}
let len = take.len();
let taken: Vec<Option<usize>> = take.iter().map(|&r| by_row[r]).collect();
let w = attrs::width(tag);
let at = |k: usize| -> Result<&[u8]> {
let o = k * w;
if o + w > val.len() {
bail!("column value {k} runs past its section");
}
Ok(&val[o..o + w])
};
Ok(match tag {
0 => {
let keys: Vec<Option<i32>> = taken
.iter()
.map(|t| match *t {
Some(k) => {
let o = k * 4;
if o + 4 > val.len() {
None
} else {
Some(u32::from_le_bytes(val[o..o + 4].try_into().unwrap()) as i32)
}
}
None => None,
})
.collect();
let values = StringArray::from(dict.iter().map(|s| s.as_str()).collect::<Vec<_>>());
Arc::new(arrow::array::DictionaryArray::try_new(
Int32Array::from(keys),
Arc::new(values),
)?) as ArrayRef
}
1 => {
let mut b = Int64Builder::with_capacity(len);
for t in &taken {
match *t {
Some(k) => b.append_value(i64::from_le_bytes(at(k)?.try_into().unwrap())),
None => b.append_null(),
}
}
Arc::new(b.finish())
}
2 => {
let mut b = Float64Builder::with_capacity(len);
for t in &taken {
match *t {
Some(k) => b.append_value(f64::from_bits(u64::from_le_bytes(
at(k)?.try_into().unwrap(),
))),
None => b.append_null(),
}
}
Arc::new(b.finish())
}
3 => {
let mut b = BooleanBuilder::with_capacity(len);
for t in &taken {
match *t {
Some(k) => b.append_value(at(k)?[0] != 0),
None => b.append_null(),
}
}
Arc::new(b.finish())
}
4 => {
let mut b = UInt64Builder::with_capacity(len);
for t in &taken {
match *t {
Some(k) => b.append_value(u64::from_le_bytes(at(k)?.try_into().unwrap())),
None => b.append_null(),
}
}
Arc::new(b.finish())
}
5 => {
let keys: Vec<Option<i32>> = taken
.iter()
.map(|t| match *t {
Some(k) => {
let bytes = at(k).ok()?;
Some(u32::from_le_bytes(bytes.try_into().ok()?) as i32)
}
None => None,
})
.collect();
let values = BinaryArray::from_iter_values(binary_dict.iter().map(Vec::as_slice));
Arc::new(arrow::array::DictionaryArray::try_new(
Int32Array::from(keys),
Arc::new(values),
)?)
}
6 => {
let mut b = TimestampNanosecondBuilder::with_capacity(len).with_timezone("UTC");
for t in &taken {
match *t {
Some(k) => b.append_value(i64::from_le_bytes(at(k)?.try_into().unwrap())),
None => b.append_null(),
}
}
Arc::new(b.finish())
}
7 => {
let mut b = BooleanBuilder::with_capacity(len);
for t in &taken {
match *t {
Some(_) => b.append_value(true),
None => b.append_null(),
}
}
Arc::new(b.finish())
}
t => bail!("unknown attribute type tag {t}"),
})
}
pub fn collect(
parts: &[Arc<Part>],
fold: Option<&Arc<Fold>>,
lens: &Lens,
projection: &[usize],
) -> Result<(Vec<RecordBatch>, ScanStats)> {
collect_where(parts, fold, lens, projection, &[])
}
pub fn collect_where(
parts: &[Arc<Part>],
fold: Option<&Arc<Fold>>,
lens: &Lens,
projection: &[usize],
preds: &[Pred],
) -> Result<(Vec<RecordBatch>, ScanStats)> {
let mut stats = ScanStats::default();
let mut out = Vec::new();
for p in parts {
let mut sc = lens.scan(p, fold, projection, preds)?;
while let Some(b) = sc.next_batch()? {
out.push(b);
}
stats.add(sc.stats());
}
Ok((out, stats))
}
pub fn flatten_strings(a: &ArrayRef) -> Result<ArrayRef> {
use arrow::array::{Array, AsArray};
let d = a
.as_any()
.downcast_ref::<arrow::array::DictionaryArray<arrow::datatypes::Int32Type>>()
.ok_or_else(|| anyhow::anyhow!("not a dictionary column"))?;
let values = d.values().as_string::<i32>();
let mut b = StringBuilder::new();
for i in 0..d.len() {
match d.key(i) {
Some(k) => b.append_value(values.value(k)),
None => b.append_null(),
}
}
Ok(Arc::new(b.finish()))
}