taos-query 0.12.4

Driver for TDengine - a timeseries database and analysis platform
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

use std::ops::Deref;
use std::{fmt::Debug, ops::DerefMut};

use bytes::{Bytes, BytesMut};

pub struct Lengths(pub(super) Bytes);

impl<T: Into<Bytes>> From<T> for Lengths {
    fn from(value: T) -> Self {
        Self(value.into())
    }
}

impl Debug for Lengths {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        Debug::fmt(&self.0, f)
    }
}

impl Lengths {
    /// As a [ColSchema] slice.
    pub fn as_slice(&self) -> &[u32] {
        debug_assert!(self.0.len() % std::mem::size_of::<u32>() == 0);
        unsafe {
            std::slice::from_raw_parts(
                self.0.as_ptr() as *const u32,
                self.0.len() / std::mem::size_of::<u32>(),
            )
        }
    }

    pub unsafe fn get_unchecked(&self, index: usize) -> u32 {
        unsafe {
            std::ptr::read_unaligned(self.0.as_ptr().add(index * std::mem::size_of::<u32>()) as _)
        }
    }

    // /// As a [u8] slice.
    // pub fn as_bytes(&self) -> &[u8] {
    //     &self.0.as_ref()
    // }
}

impl Deref for Lengths {
    type Target = [u32];

    fn deref(&self) -> &Self::Target {
        self.as_slice()
    }
}

pub(crate) struct LengthsMut(BytesMut);

impl<T: Into<BytesMut>> From<T> for LengthsMut {
    fn from(value: T) -> Self {
        Self(value.into())
    }
}

impl Debug for LengthsMut {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        Debug::fmt(self.deref(), f)
    }
}

impl LengthsMut {
    /// Creates a new `LengthsMut` with the specified length `len`.
    ///
    pub fn new(len: usize) -> Self {
        let mut bytes = BytesMut::with_capacity(len * std::mem::size_of::<u32>());
        bytes.resize(len * std::mem::size_of::<u32>(), 0);
        Self(bytes)
    }
    /// As a [i32] slice.
    fn as_slice(&self) -> &[u32] {
        unsafe {
            std::slice::from_raw_parts(
                self.0.as_ptr() as *const u32,
                self.0.len() / std::mem::size_of::<u32>(),
            )
        }
    }
    fn as_slice_mut(&mut self) -> &mut [u32] {
        unsafe {
            std::slice::from_raw_parts_mut(
                self.0.as_ptr() as *mut u32,
                self.0.len() / std::mem::size_of::<u32>(),
            )
        }
    }
    pub fn into_lengths(self) -> Lengths {
        Lengths::from(self.0)
    }
}

impl Deref for LengthsMut {
    type Target = [u32];

    fn deref(&self) -> &Self::Target {
        self.as_slice()
    }
}

impl DerefMut for LengthsMut {
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.as_slice_mut()
    }
}

#[test]
fn test_lengths_mut() {
    let mut lengths = LengthsMut::new(2);
    let lengths = lengths.deref_mut();
    lengths[0] = 1;
    lengths[1] = 2;
    dbg!(lengths);
}