xiguaAp6y3/moondelta-core/vendor/parquet does not have a README file

    ParquetError

    pub(all) suberror ParquetError {
    InvalidData(String)
    Unsupported(String)
    Io(String)
    } derive(Eq,
    Debug
    )

    ParquetError::equal

    ParquetError::not_equal

    fn ParquetError::not_equal(x : ParquetError, y : ParquetError) -> Bool

    ParquetError::output

    fn ParquetError::output(self : ParquetError, logger : &Logger) -> Unit

    ParquetError::to_string

    fn ParquetError::to_string(self : ParquetError) -> String

    Column

    pub struct Column {
    name : String
    column_type : ColumnType
    repetition : Repetition
    } derive(Eq,
    Debug
    )

    impl Show for Column

    Column::column_type

    fn Column::column_type(self : Column) -> ColumnType

    Column::equal

    fn Column::equal(Column, Column) -> Bool

    Column::name

    fn Column::name(self : Column) -> String

    Column::not_equal

    fn Column::not_equal(x : Column, y : Column) -> Bool

    Column::output

    fn Column::output(self : Column, logger : &Logger) -> Unit

    Column::repetition

    fn Column::repetition(self : Column) -> Repetition

    Column::to_repr

    Column::to_string

    fn Column::to_string(self : Column) -> String

    ColumnType

    pub(all) enum ColumnType {
    Boolean
    Int32
    Date
    Int64
    TimestampMicros
    TimestampMicros64
    Float
    Double
    String
    Binary
    } derive(Eq,
    Debug
    )

    impl Show for ColumnType

    ColumnType::equal

    fn ColumnType::equal(ColumnType, ColumnType) -> Bool

    ColumnType::not_equal

    fn ColumnType::not_equal(x : ColumnType, y : ColumnType) -> Bool

    ColumnType::output

    fn ColumnType::output(self : ColumnType, logger : &Logger) -> Unit

    ColumnType::to_string

    fn ColumnType::to_string(self : ColumnType) -> String

    LeafColumn

    pub(all) struct LeafColumn {
    path : Array[String]
    column_type : ColumnType
    max_definition_level : Int
    max_repetition_level : Int
    values : Array[Value]
    def_levels : Array[Int]
    rep_levels : Array[Int]
    }

    ParquetColumnData

    pub(all) enum ParquetColumnData {
    Values(Array[Value])
    BooleanValues(Array[Bool])
    Int32Values(Array[Int])
    NullableInt32Values(Array[Int?])
    Int64Values(Array[Int64])
    NullableInt64Values(Array[Int64?])
    TimestampMicrosValues(Array[Int64])
    NullableTimestampMicrosValues(Array[Int64?])
    FloatValues(Array[Float])
    DoubleValues(Array[Double])
    Utf8Values(Array[Bytes])
    NullableUtf8Values(Array[Bytes?])
    BinaryValues(Array[Bytes])
    NullableBinaryValues(Array[Bytes?])
    } derive(Eq,
    Debug
    )

    ParquetColumnData::equal

    ParquetColumnData::length

    fn ParquetColumnData::length(self : ParquetColumnData) -> Int

    ParquetColumnData::not_equal

    fn ParquetColumnData::not_equal(x : ParquetColumnData, y : ParquetColumnData) -> Bool

    ParquetColumnData::output

    fn ParquetColumnData::output(self : ParquetColumnData, logger : &Logger) -> Unit

    ParquetColumnData::to_string

    fn ParquetColumnData::to_string(self : ParquetColumnData) -> String

    ParquetColumnarFile

    pub struct ParquetColumnarFile {
    columns : Array[Column]
    column_data : Array[ParquetColumnData]
    row_count : Int
    column_values_cache : Array[Array[Value]]?
    created_by : String?
    } derive(
    Debug
    )

    ParquetColumnarFile::column_data

    ParquetColumnarFile::column_values

    ParquetColumnarFile::columns

    ParquetColumnarFile::created_by

    fn ParquetColumnarFile::created_by(self : ParquetColumnarFile) -> String?

    ParquetColumnarFile::equal

    ParquetColumnarFile::not_equal

    ParquetColumnarFile::output

    fn ParquetColumnarFile::output(self : ParquetColumnarFile, logger : &Logger) -> Unit

    ParquetColumnarFile::row_count

    fn ParquetColumnarFile::row_count(self : ParquetColumnarFile) -> Int

    ParquetColumnarFile::to_string

    fn ParquetColumnarFile::to_string(self : ParquetColumnarFile) -> String

    ParquetFile

    pub struct ParquetFile {
    columns : Array[Column]
    row_count : Int
    column_data : Array[ParquetColumnData]
    rows_cache : Array[Array[Value]]?
    created_by : String?
    } derive(
    Debug
    )

    impl Eq for ParquetFile
    impl Show for ParquetFile

    ParquetFile::column_data

    fn ParquetFile::column_data(self : ParquetFile) -> Array[ParquetColumnData]

    ParquetFile::columns

    fn ParquetFile::columns(self : ParquetFile) -> Array[Column]

    ParquetFile::created_by

    fn ParquetFile::created_by(self : ParquetFile) -> String?

    ParquetFile::equal

    fn ParquetFile::equal(self : ParquetFile, other : ParquetFile) -> Bool

    ParquetFile::not_equal

    fn ParquetFile::not_equal(x : ParquetFile, y : ParquetFile) -> Bool

    ParquetFile::output

    fn ParquetFile::output(self : ParquetFile, logger : &Logger) -> Unit

    ParquetFile::row_count

    fn ParquetFile::row_count(self : ParquetFile) -> Int

    ParquetFile::rows

    fn ParquetFile::rows(self : ParquetFile) -> Array[Array[Value]]

    ParquetFile::to_string

    fn ParquetFile::to_string(self : ParquetFile) -> String

    Repetition

    pub(all) enum Repetition {
    Required
    Optional
    Repeated
    } derive(Eq,
    Debug
    )

    impl Show for Repetition

    Repetition::equal

    fn Repetition::equal(Repetition, Repetition) -> Bool

    Repetition::not_equal

    fn Repetition::not_equal(x : Repetition, y : Repetition) -> Bool

    Repetition::output

    fn Repetition::output(self : Repetition, logger : &Logger) -> Unit

    Repetition::to_string

    fn Repetition::to_string(self : Repetition) -> String

    Value

    pub(all) enum Value {
    Boolean(Bool)
    Int32(Int)
    Int64(Int64)
    TimestampMicros(Int64)
    Float(Float)
    Double(Double)
    String(String)
    Binary(Bytes)
    Null
    } derive(Eq,
    Debug
    )

    impl Show for Value

    Value::equal

    fn Value::equal(Value, Value) -> Bool

    Value::not_equal

    fn Value::not_equal(x : Value, y : Value) -> Bool

    Value::output

    fn Value::output(self : Value, logger : &Logger) -> Unit

    Value::to_repr

    Value::to_string

    fn Value::to_string(self : Value) -> String

    WriteLeaf

    pub(all) struct WriteLeaf {
    path : Array[String]
    column_type : ColumnType
    max_definition_level : Int
    max_repetition_level : Int
    values : Array[Value]
    def_levels : Array[Int]
    rep_levels : Array[Int]
    }

    WriteNode

    pub(all) struct WriteNode {
    name : String
    repetition : Repetition
    column_type : ColumnType?
    converted_type : Int?
    children : Array[WriteNode]
    }

    converted_type_list

    let converted_type_list : Int

    converted_type_map

    let converted_type_map : Int

    new_column

    fn new_column(name : String, column_type : ColumnType, repetition : Repetition) -> Column

    new_parquet_columnar_file

    fn new_parquet_columnar_file(columns : Array[Column], column_data : Array[ParquetColumnData], row_count : Int, created_by : String?) -> ParquetColumnarFile

    new_parquet_file

    fn new_parquet_file(columns : Array[Column], rows : Array[Array[Value]], created_by : String?) -> ParquetFile

    read_bytes

    fn read_bytes(data : Bytes) -> ParquetFile raise ParquetError

    Read a parquet document from bytes.

    read_bytes_columnar

    fn read_bytes_columnar(data : Bytes) -> ParquetColumnarFile raise ParquetError

    Read a parquet document from bytes without row materialization.

    read_bytes_shredded

    fn read_bytes_shredded(data : Bytes) -> (Array[LeafColumn], Int) raise ParquetError

    全文件 shredded 读取:返回每个叶列的槽位流与总记录数(跨 row group 拼接, 记录边界由 rep==0 标记)。

    read_file

    fn read_file(path : String) -> ParquetFile raise ParquetError

    Read a parquet file from disk.

    read_file_columnar

    fn read_file_columnar(path : String) -> ParquetColumnarFile raise ParquetError

    Read a parquet file from disk without row materialization.

    write_bytes

    fn write_bytes(file : ParquetFile) -> Bytes raise ParquetError

    Encode a parquet document to bytes.

    The current writer supports flat schemas of Int32, Int64, String, and Binary, with Required or Optional repetition.

    write_bytes_shredded

    fn write_bytes_shredded(nodes : Array[WriteNode], leaves : Array[WriteLeaf], num_rows : Int) -> Bytes raise ParquetError

    嵌套写入:nodes 为根的子节点(前序遍历顺序决定列块顺序), leaves 与该前序遍历中的叶顺序一一对应。

    write_file

    fn write_file(path : String, file : ParquetFile) -> Unit raise ParquetError

    Encode a parquet document and write it to disk.