Enum taos_query::common::Ty

#[repr(u8)]
#[non_exhaustive]
pub enum Ty {
    Bool,
    TinyInt,
    SmallInt,
    Int,
    BigInt,
    UTinyInt,
    USmallInt,
    UInt,
    UBigInt,
    Float,
    Double,
    Timestamp,
    VarChar,
    NChar,
    Json,
    // some variants omitted
}

TDengine data type enumeration.

enum	int	sql name	rust type
Null	0	NULL	None
Bool	1	BOOL	bool
TinyInt	2	TINYINT	i8
SmallInt	3	SMALLINT	i16
Int	4	INT	i32
BitInt	5	BIGINT	i64
Float	6	FLOAT	f32
Double	7	DOUBLE	f64
VarChar	8	BINARY/VARCHAR	str/String
Timestamp	9	TIMESTAMP	i64
NChar	10	NCHAR	str/String
UTinyInt	11	TINYINT UNSIGNED	u8
USmallInt	12	SMALLINT UNSIGNED	u16
UInt	13	INT UNSIGNED	u32
UBigInt	14	BIGINT UNSIGNED	u64
Json	15	JSON	serde_json::Value

Note:

• VarChar sql name is BINARY in v2, and VARCHAR in v3.
• Decimal/Blob/MediumBlob is not supported in 2.0/3.0 .

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Bool

The BOOL type in sql, will be represented as bool in Rust.

TinyInt

TINYINT type in sql, will be represented in Rust as i8.

SmallInt

SMALLINT type in sql, will be represented in Rust as i16.

Int

INT type in sql, will be represented in Rust as i32.

BigInt

BIGINT type in sql, will be represented in Rust as i64.

UTinyInt

UTinyInt, tinyint unsigned in sql, u8 in Rust.

USmallInt

12: USmallInt, smallint unsigned in sql, u16 in Rust.

UInt

13: UInt, int unsigned in sql, u32 in Rust.

UBigInt

14: UBigInt, bigint unsigned in sql, u64 in Rust.

Float

6: Float, float type in sql, will be represented in Rust as f32.

Double

7: Double, tinyint type in sql, will be represented in Rust as f64.

Timestamp

9: Timestamp, timestamp type in sql, will be represented as i64 in Rust. But can be deserialized to chrono::naive::NaiveDateTime or String.

VarChar

8: VarChar, binary type in sql for TDengine 2.x, varchar for TDengine 3.x, will be represented in Rust as &str or String. This type of data be deserialized to Vec.

NChar

10: NChar, nchar type in sql, the recommended way in TDengine to store utf-8 String.

Json

15: Json, json tag in sql, will be represented as serde_json::value::Value in Rust.

Implementations

impl Ty

pub const fn is_null(&self) -> bool

Check if the data type is null or not.

pub const fn is_var_type(&self) -> bool

Var type is one of Ty::VarChar, Ty::VarBinary, Ty::NChar.

Examples found in repository

src/helpers/describe.rs (line 28)

    pub fn sql_repr(&self) -> String {
        let ty = self.ty;
        if ty.is_var_type() {
            format!("{} {}({})", self.field, ty, self.length)
        } else {
            format!("{} {}", self.field, self.ty)
        }
    }

src/common/field.rs (line 122)

    pub fn sql_repr(&self) -> String {
        let ty = self.ty();
        if ty.is_var_type() {
            format!("`{}` {}({})", self.name(), ty.name(), self.bytes())
        } else {
            format!("`{}` {}", self.name(), ty.name())
        }
    }
}

impl Display for Field {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let ty = self.ty();
        if ty.is_var_type() {
            write!(f, "`{}` {}({})", self.name(), ty.name(), self.bytes())
        } else {
            write!(f, "`{}` {}", self.name(), ty.name())
        }
    }

src/common/raw/meta.rs (line 335)

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self.alter_type {
            AlterType::AddTag => f.write_fmt(format_args!(
                "ALTER TABLE `{}` ADD TAG {}",
                self.table_name,
                self.field.sql_repr()
            )),
            AlterType::DropTag => f.write_fmt(format_args!(
                "ALTER TABLE `{}` DROP TAG `{}`",
                self.table_name,
                self.field.name()
            )),
            AlterType::RenameTag => f.write_fmt(format_args!(
                "ALTER TABLE `{}` RENAME TAG `{}` `{}`",
                self.table_name,
                self.field.name(),
                self.col_new_name.as_ref().unwrap()
            )),
            AlterType::SetTagValue => {
                f.write_fmt(format_args!(
                    "ALTER TABLE `{}` SET TAG `{}` ",
                    self.table_name,
                    self.field.name()
                ))?;
                if self.col_value_null.unwrap_or(false) {
                    f.write_str("NULL")
                } else if self.field.ty.is_var_type() {
                    f.write_fmt(format_args!("'{}'", self.col_value.as_ref().unwrap()))
                } else {
                    f.write_fmt(format_args!("{}", self.col_value.as_ref().unwrap()))
                }
            }
            AlterType::AddColumn => f.write_fmt(format_args!(
                "ALTER TABLE `{}` ADD COLUMN {}",
                self.table_name,
                self.field.sql_repr()
            )),
            AlterType::DropColumn => f.write_fmt(format_args!(
                "ALTER TABLE `{}` DROP COLUMN `{}`",
                self.table_name,
                self.field.name()
            )),
            AlterType::ModifyColumnLength => f.write_fmt(format_args!(
                "ALTER TABLE `{}` MODIFY COLUMN {}",
                self.table_name,
                self.field.sql_repr(),
            )),
            AlterType::ModifyTagLength => f.write_fmt(format_args!(
                "ALTER TABLE `{}` MODIFY TAG {}",
                self.table_name,
                self.field.sql_repr(),
            )),
            AlterType::ModifyTableOption => todo!(),
            AlterType::RenameColumn => f.write_fmt(format_args!(
                "ALTER TABLE `{}` RENAME COLUMN `{}` `{}`",
                self.table_name,
                self.field.name(),
                self.col_new_name.as_ref().unwrap()
            )),
        }
    }

pub const fn is_json(&self) -> bool

pub const fn is_primitive(&self) -> bool

Is one of boolean/integers/float/double/decimal

Examples found in repository

src/common/raw/views/mod.rs (line 458)

pub fn views_to_raw_block(views: &[ColumnView]) -> Vec<u8> {
    let mut header = super::Header::default();

    header.nrows = views.first().map(|v| v.len()).unwrap_or(0) as _;
    header.ncols = views.len() as _;

    let ncols = views.len();

    let mut bytes = Vec::new();
    bytes.extend(header.as_bytes());

    let schemas = views
        .iter()
        .map(|view| {
            let ty = view.as_ty();
            ColSchema {
                ty,
                len: ty.fixed_length() as _,
            }
        })
        .collect_vec();
    let schema_bytes = unsafe {
        std::slice::from_raw_parts(
            schemas.as_ptr() as *const u8,
            ncols * std::mem::size_of::<ColSchema>(),
        )
    };
    bytes.write_all(schema_bytes).unwrap();

    let length_offset = bytes.len();
    bytes.resize(bytes.len() + ncols * std::mem::size_of::<u32>(), 0);

    let mut lengths = Vec::with_capacity(ncols);
    lengths.resize(ncols, 0);
    for (i, view) in views.iter().enumerate() {
        let cur = bytes.len();
        let n = view.write_raw_into(&mut bytes).unwrap();
        let len = bytes.len();
        debug_assert!(cur + n == len);
        if !view.as_ty().is_primitive() {
            lengths[i] = (n - header.nrows() * 4) as _;
        } else {
            lengths[i] = (header.nrows() * view.as_ty().fixed_length()) as _;
        }
    }
    unsafe {
        (*(bytes.as_mut_ptr() as *mut super::Header)).length = bytes.len() as _;
        std::ptr::copy(
            lengths.as_ptr(),
            bytes.as_mut_ptr().offset(length_offset as isize) as *mut u32,
            lengths.len(),
        );
    }
    bytes
}

pub const fn fixed_length(&self) -> usize

Get fixed length if the type is primitive.

Examples found in repository

src/common/itypes.rs (line 112)

    fn is_primitive(&self) -> bool {
        std::mem::size_of::<Self>() == Self::TY.fixed_length()
    }

    fn fixed_length(&self) -> usize {
        std::mem::size_of::<Self>()
    }

    fn as_timestamp(&self) -> i64 {
        debug_assert!(Self::TY == Ty::Timestamp);
        unimplemented!()
    }

    fn as_var_char(&self) -> &str {
        debug_assert!(Self::TY == Ty::VarChar);
        unimplemented!()
    }

    fn as_nchar(&self) -> &str {
        debug_assert!(Self::TY == Ty::NChar);
        unimplemented!()
    }

    fn as_medium_blob(&self) -> &[u8] {
        debug_assert!(Self::TY == Ty::MediumBlob);
        unimplemented!()
    }

    fn as_blob(&self) -> &[u8] {
        debug_assert!(Self::TY == Ty::Blob);
        unimplemented!()
    }
}

impl<T> IsValue for Option<T>
where
    T: IsValue,
{
    const TY: Ty = T::TY;

    fn is_null(&self) -> bool {
        self.is_none()
    }

    fn is_primitive(&self) -> bool {
        self.as_ref().unwrap().is_primitive()
    }

    fn as_timestamp(&self) -> i64 {
        self.as_ref().unwrap().as_timestamp()
    }

    fn as_var_char(&self) -> &str {
        self.as_ref().unwrap().as_var_char()
    }
    fn as_nchar(&self) -> &str {
        self.as_ref().unwrap().as_nchar()
    }
    fn as_medium_blob(&self) -> &[u8] {
        self.as_ref().unwrap().as_medium_blob()
    }
    fn as_blob(&self) -> &[u8] {
        self.as_ref().unwrap().as_blob()
    }
}

pub trait IValue: Sized {
    const TY: Ty;

    type Inner: Sized;

    fn is_null(&self) -> bool {
        false
    }

    fn into_value(self) -> Value;

    fn into_inner(self) -> Self::Inner;
}

impl IValue for INull {
    const TY: Ty = Ty::Null;

    fn is_null(&self) -> bool {
        true
    }
    fn into_value(self) -> Value {
        Value::Null(Ty::Null)
    }

    type Inner = ();

    fn into_inner(self) -> Self::Inner {
        ()
    }
}

/// Primitive type to TDengine data type.
macro_rules! impl_prim {
    ($($ty:ident = $inner:ty)*) => {
        $(paste::paste! {
            impl IValue for [<I $ty>] {
                const TY: Ty = Ty::$ty;
                type Inner = $inner;

                #[inline]
                fn is_null(&self) -> bool {
                    false
                }

                #[inline]
                fn into_value(self) -> Value {
                    Value::$ty(self)
                }

                #[inline]
                fn into_inner(self) -> Self::Inner {
                    self
                }
            }
        })*
    };
}

impl_prim!(
    Bool = bool
    TinyInt = i8
    SmallInt =  i16
    Int = i32
    BigInt = i64
    UTinyInt = u8
    USmallInt = u16
    UInt = u32
    UBigInt = u64
    Float = f32
    Double = f64
    Decimal = Decimal
    Json = Json
);

pub trait IsPrimitive: Copy {
    const TY: Ty;
    fn is_primitive(&self) -> bool {
        std::mem::size_of::<Self>() == Self::TY.fixed_length()
    }

src/stmt/column.rs (line 60)

    fn from_primitive<T: IsValue>(v: &T) -> Self {
        let mut param = RawMultiBind::new(T::TY);
        param.buffer_length = T::TY.fixed_length();
        param.buffer = box_into_raw(v.clone()) as *const T as _;
        param.length = box_into_raw(param.buffer_length) as _;
        param.is_null = box_into_raw(0) as _;
        param
    }

src/common/raw/views/mod.rs (line 436)

pub fn views_to_raw_block(views: &[ColumnView]) -> Vec<u8> {
    let mut header = super::Header::default();

    header.nrows = views.first().map(|v| v.len()).unwrap_or(0) as _;
    header.ncols = views.len() as _;

    let ncols = views.len();

    let mut bytes = Vec::new();
    bytes.extend(header.as_bytes());

    let schemas = views
        .iter()
        .map(|view| {
            let ty = view.as_ty();
            ColSchema {
                ty,
                len: ty.fixed_length() as _,
            }
        })
        .collect_vec();
    let schema_bytes = unsafe {
        std::slice::from_raw_parts(
            schemas.as_ptr() as *const u8,
            ncols * std::mem::size_of::<ColSchema>(),
        )
    };
    bytes.write_all(schema_bytes).unwrap();

    let length_offset = bytes.len();
    bytes.resize(bytes.len() + ncols * std::mem::size_of::<u32>(), 0);

    let mut lengths = Vec::with_capacity(ncols);
    lengths.resize(ncols, 0);
    for (i, view) in views.iter().enumerate() {
        let cur = bytes.len();
        let n = view.write_raw_into(&mut bytes).unwrap();
        let len = bytes.len();
        debug_assert!(cur + n == len);
        if !view.as_ty().is_primitive() {
            lengths[i] = (n - header.nrows() * 4) as _;
        } else {
            lengths[i] = (header.nrows() * view.as_ty().fixed_length()) as _;
        }
    }
    unsafe {
        (*(bytes.as_mut_ptr() as *mut super::Header)).length = bytes.len() as _;
        std::ptr::copy(
            lengths.as_ptr(),
            bytes.as_mut_ptr().offset(length_offset as isize) as *mut u32,
            lengths.len(),
        );
    }
    bytes
}

pub const fn name(&self) -> &'static str

The sql name of type.

Examples found in repository

src/common/ty.rs (line 359)

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name())
    }

src/common/field.rs (line 123)

    pub fn sql_repr(&self) -> String {
        let ty = self.ty();
        if ty.is_var_type() {
            format!("`{}` {}({})", self.name(), ty.name(), self.bytes())
        } else {
            format!("`{}` {}", self.name(), ty.name())
        }
    }
}

impl Display for Field {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let ty = self.ty();
        if ty.is_var_type() {
            write!(f, "`{}` {}({})", self.name(), ty.name(), self.bytes())
        } else {
            write!(f, "`{}` {}", self.name(), ty.name())
        }
    }

pub const fn lowercase_name(&self) -> &'static str

Trait Implementations

impl Clone for Ty

fn clone(&self) -> Ty

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Ty

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Ty

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Ty

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where
    D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Ty

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<i16> for Ty

fn from(v: i16) -> Self

Converts to this type from the input type.

impl From<i32> for Ty

fn from(v: i32) -> Self

Converts to this type from the input type.

impl From<i64> for Ty

fn from(v: i64) -> Self

Converts to this type from the input type.

impl From<i8> for Ty

fn from(v: i8) -> Self

Converts to this type from the input type.

impl From<u16> for Ty

fn from(v: u16) -> Self

Converts to this type from the input type.

impl From<u32> for Ty

fn from(v: u32) -> Self

Converts to this type from the input type.

impl From<u64> for Ty

fn from(v: u64) -> Self

Converts to this type from the input type.

impl From<u8> for Ty

fn from(v: u8) -> Self

Converts to this type from the input type.

impl FromStr for Ty

type Err = &'static str

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Ty

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<Ty> for Ty

fn eq(&self, other: &Ty) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Ty

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where
    S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Ty

impl Eq for Ty

impl StructuralEq for Ty

impl StructuralPartialEq for Ty