qvd 0.7.0

High-performance library for reading, writing and converting Qlik QVD files with Parquet/Arrow/DataFusion support
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use crate::error::{QvdError, QvdResult};
use crate::header::QvdFieldHeader;
use crate::value::QvdSymbol;

/// Parse symbol table for a single field from the binary buffer.
///
/// The buffer starts at the beginning of the binary section (after XML header).
/// Field's `offset` and `length` are relative to this buffer start.
pub fn read_symbols(buf: &[u8], field: &QvdFieldHeader) -> QvdResult<Vec<QvdSymbol>> {
    let start = field.offset;
    let end = start + field.length;
    if end > buf.len() {
        return Err(QvdError::Format(format!(
            "Symbol table for '{}' exceeds buffer: offset={}, length={}, buf_len={}",
            field.field_name, field.offset, field.length, buf.len()
        )));
    }

    let mut symbols = Vec::with_capacity(field.no_of_symbols);
    let mut i = start;

    while i < end && symbols.len() < field.no_of_symbols {
        let type_byte = buf[i];
        i += 1;

        match type_byte {
            0x01 => {
                // Integer: 4 bytes little-endian
                if i + 4 > end {
                    return Err(QvdError::Format(format!(
                        "Unexpected end of symbol table for '{}' at integer",
                        field.field_name
                    )));
                }
                let val = i32::from_le_bytes([buf[i], buf[i + 1], buf[i + 2], buf[i + 3]]);
                i += 4;
                symbols.push(QvdSymbol::Int(val));
            }
            0x02 => {
                // Double: 8 bytes little-endian
                if i + 8 > end {
                    return Err(QvdError::Format(format!(
                        "Unexpected end of symbol table for '{}' at double",
                        field.field_name
                    )));
                }
                let bytes: [u8; 8] = buf[i..i + 8].try_into().unwrap();
                let val = f64::from_le_bytes(bytes);
                i += 8;
                symbols.push(QvdSymbol::Double(val));
            }
            0x04 => {
                // String: null-terminated
                let str_start = i;
                while i < end && buf[i] != 0 {
                    i += 1;
                }
                let s = String::from_utf8(buf[str_start..i].to_vec())?;
                if i < end {
                    i += 1; // skip null terminator
                }
                symbols.push(QvdSymbol::Text(s));
            }
            0x05 => {
                // Dual Int: 4 bytes integer + null-terminated string
                if i + 4 > end {
                    return Err(QvdError::Format(format!(
                        "Unexpected end of symbol table for '{}' at dual int",
                        field.field_name
                    )));
                }
                let val = i32::from_le_bytes([buf[i], buf[i + 1], buf[i + 2], buf[i + 3]]);
                i += 4;
                let str_start = i;
                while i < end && buf[i] != 0 {
                    i += 1;
                }
                let s = String::from_utf8(buf[str_start..i].to_vec())?;
                if i < end {
                    i += 1; // skip null terminator
                }
                symbols.push(QvdSymbol::DualInt(val, s));
            }
            0x06 => {
                // Dual Double: 8 bytes double + null-terminated string
                if i + 8 > end {
                    return Err(QvdError::Format(format!(
                        "Unexpected end of symbol table for '{}' at dual double",
                        field.field_name
                    )));
                }
                let bytes: [u8; 8] = buf[i..i + 8].try_into().unwrap();
                let val = f64::from_le_bytes(bytes);
                i += 8;
                let str_start = i;
                while i < end && buf[i] != 0 {
                    i += 1;
                }
                let s = String::from_utf8(buf[str_start..i].to_vec())?;
                if i < end {
                    i += 1; // skip null terminator
                }
                symbols.push(QvdSymbol::DualDouble(val, s));
            }
            _ => {
                return Err(QvdError::Format(format!(
                    "Unknown symbol type 0x{:02x} in field '{}' at offset {}",
                    type_byte, field.field_name, i - 1
                )));
            }
        }
    }

    Ok(symbols)
}

/// Serialize symbols back to binary format.
pub fn write_symbols(symbols: &[QvdSymbol]) -> Vec<u8> {
    let total_size: usize = symbols.iter().map(|s| s.binary_size()).sum();
    let mut buf = Vec::with_capacity(total_size);

    for symbol in symbols {
        buf.push(symbol.type_byte());
        match symbol {
            QvdSymbol::Int(v) => {
                buf.extend_from_slice(&v.to_le_bytes());
            }
            QvdSymbol::Double(v) => {
                buf.extend_from_slice(&v.to_le_bytes());
            }
            QvdSymbol::Text(s) => {
                buf.extend_from_slice(s.as_bytes());
                buf.push(0);
            }
            QvdSymbol::DualInt(v, s) => {
                buf.extend_from_slice(&v.to_le_bytes());
                buf.extend_from_slice(s.as_bytes());
                buf.push(0);
            }
            QvdSymbol::DualDouble(v, s) => {
                buf.extend_from_slice(&v.to_le_bytes());
                buf.extend_from_slice(s.as_bytes());
                buf.push(0);
            }
        }
    }

    buf
}