vortex-array 0.54.0

Vortex in memory columnar data format
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: Copyright the Vortex contributors

use std::fmt::{self};

use humansize::{DECIMAL, format_size};

use crate::arrays::ChunkedEncoding;
use crate::display::DisplayOptions;
use crate::{Array, ArrayRef, ArrayVisitor};

pub(super) struct TreeDisplayWrapper(pub(super) ArrayRef);

impl fmt::Display for TreeDisplayWrapper {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut array_fmt = TreeFormatter {
            fmt,
            indent: "".to_string(),
            total_size: None,
        };
        array_fmt.format("root", self.0.clone())
    }
}

pub struct TreeFormatter<'a, 'b: 'a> {
    fmt: &'a mut fmt::Formatter<'b>,
    indent: String,
    total_size: Option<u64>,
}

impl<'a, 'b: 'a> TreeFormatter<'a, 'b> {
    fn format(&mut self, name: &str, array: ArrayRef) -> fmt::Result {
        let nbytes = array.nbytes();
        let total_size = self.total_size.unwrap_or(nbytes);
        writeln!(
            self,
            "{}: {} nbytes={} ({:.2}%)",
            name,
            array.display_as(DisplayOptions::MetadataOnly),
            format_size(nbytes, DECIMAL),
            100_f64 * nbytes as f64 / total_size as f64
        )?;

        self.indent(|i| {
            write!(i, "metadata: ")?;
            array.metadata_fmt(i.fmt)?;
            writeln!(i.fmt)?;

            for buffer in array.buffers() {
                writeln!(
                    i,
                    "buffer (align={}): {} ({:.2}%)",
                    buffer.alignment(),
                    format_size(buffer.len(), DECIMAL),
                    100_f64 * buffer.len() as f64 / nbytes as f64
                )?;
            }

            Ok(())
        })?;

        let old_total_size = self.total_size;
        if array.is_encoding(ChunkedEncoding.id()) {
            // Clear the total size so each chunk is treated as a new root.
            self.total_size = None
        } else {
            self.total_size = Some(nbytes);
        }

        self.indent(|i| {
            for (name, child) in array
                .children_names()
                .into_iter()
                .zip(array.children().into_iter())
            {
                i.format(&name, child)?;
            }
            Ok(())
        })?;

        self.total_size = old_total_size;
        Ok(())
    }

    fn indent<F>(&mut self, indented: F) -> fmt::Result
    where
        F: FnOnce(&mut TreeFormatter) -> fmt::Result,
    {
        let original_ident = self.indent.clone();
        self.indent += "  ";
        let res = indented(self);
        self.indent = original_ident;
        res
    }

    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> fmt::Result {
        write!(self.fmt, "{}{}", self.indent, fmt)
    }
}