sas7bdat 0.2.0

Rust library + CLI for decoding SAS7BDAT datasets and streaming them to modern formats.
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

use crate::dataset::{MissingLiteral, TaggedMissing};
use std::borrow::Cow;
use time::{Duration, OffsetDateTime};

/// Represents a single cell value produced by the SAS reader.
#[derive(Debug, Clone, PartialEq)]
pub enum CellValue<'a> {
    /// 64-bit floating point number.
    Float(f64),
    /// 32-bit signed integer.
    Int32(i32),
    /// 64-bit signed integer.
    Int64(i64),
    /// Arbitrary precision numeric represented as string to preserve formatting.
    NumericString(Cow<'a, str>),
    /// UTF-8 string converted from the source encoding.
    Str(Cow<'a, str>),
    /// Raw bytes when decoding into UTF-8 is deferred.
    Bytes(Cow<'a, [u8]>),
    /// SAS datetime value mapped to `OffsetDateTime`.
    DateTime(OffsetDateTime),
    /// SAS date value mapped to midnight UTC.
    Date(OffsetDateTime),
    /// SAS time value represented as duration since midnight.
    Time(Duration),
    /// Missing value with additional context.
    Missing(MissingValue),
}

impl CellValue<'_> {
    #[must_use]
    pub fn into_owned(self) -> CellValue<'static> {
        match self {
            CellValue::Float(v) => CellValue::Float(v),
            CellValue::Int32(v) => CellValue::Int32(v),
            CellValue::Int64(v) => CellValue::Int64(v),
            CellValue::NumericString(s) => CellValue::NumericString(Cow::Owned(s.into_owned())),
            CellValue::Str(s) => CellValue::Str(Cow::Owned(s.into_owned())),
            CellValue::Bytes(bytes) => CellValue::Bytes(Cow::Owned(bytes.into_owned())),
            CellValue::DateTime(dt) => CellValue::DateTime(dt),
            CellValue::Date(dt) => CellValue::Date(dt),
            CellValue::Time(duration) => CellValue::Time(duration),
            CellValue::Missing(missing) => CellValue::Missing(missing),
        }
    }
}

/// Variants of missing values encountered in SAS datasets.
#[derive(Debug, Clone, PartialEq)]
pub enum MissingValue {
    /// System missing represented by `.` in SAS.
    System,
    /// Missing value tagged with a letter (`.A`-`.Z`) or other sentinel.
    Tagged(TaggedMissing),
    /// Missing due to explicit range definition.
    Range {
        lower: MissingLiteral,
        upper: MissingLiteral,
    },
}

impl MissingValue {
    #[must_use]
    pub const fn system() -> Self {
        Self::System
    }
}