Add methods to get type information

src/query.rs

@@ -8,6 +8,7 @@ use http::{
 use reqwest::Client;
 use tokio::time::sleep;
 
+use crate::row::SnowflakeColumnType;
 use crate::{chunk::download_chunk, Error, Result, SnowflakeRow};
 
 pub(super) const SESSION_EXPIRED: &str = "390112";
@@ -102,17 +103,28 @@ pub(super) async fn query<Q: Into<QueryRequest>>(
         row_set.extend(rows);
     }
 
-    let column_names = row_types
+    let column_types = row_types
         .into_iter()
         .enumerate()
-        .map(|(i, name)| (name.name.to_ascii_uppercase(), i))
+        .map(|(i, row_type)| {
+            (
+                row_type.name.to_ascii_uppercase(),
+                (
+                    i,
+                    SnowflakeColumnType {
+                        snowflake_type: row_type.data_type,
+                        nullable: row_type.nullable,
+                    },
+                ),
+            )
+        })
         .collect::<HashMap<_, _>>();
-    let column_names = Arc::new(column_names);
+    let column_types = Arc::new(column_types);
     Ok(row_set
         .into_iter()
         .map(|row| SnowflakeRow {
             row,
-            column_names: Arc::clone(&column_names),
+            column_types: Arc::clone(&column_types),
         })
         .collect())
 }

src/row.rs

@@ -1,25 +1,74 @@
-use std::{collections::HashMap, sync::Arc};
+use std::{collections::HashMap, ops::Deref, sync::Arc};
 
 use chrono::{DateTime, Days, NaiveDate, NaiveDateTime};
 
 use crate::{Error, Result};
 
+#[derive(Debug)]
+pub struct SnowflakeColumn {
+    pub(super) name: String,
+    pub(super) index: usize,
+    pub(super) column_type: SnowflakeColumnType,
+}
+
+impl SnowflakeColumn {
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+    pub fn column_type(&self) -> &SnowflakeColumnType {
+        &self.column_type
+    }
+
+    pub fn index(&self) -> usize {
+        self.index
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct SnowflakeColumnType {
+    pub(super) snowflake_type: String,
+    pub(super) nullable: bool,
+}
+
+impl SnowflakeColumnType {
+    pub fn snowflake_type(&self) -> &str {
+        &self.snowflake_type
+    }
+    pub fn nullable(&self) -> bool {
+        self.nullable
+    }
+}
+
 #[derive(Debug)]
 pub struct SnowflakeRow {
     pub(crate) row: Vec<Option<String>>,
-    pub(crate) column_names: Arc<HashMap<String, usize>>,
+    pub(crate) column_types: Arc<HashMap<String, (usize, SnowflakeColumnType)>>,
 }
 
 impl SnowflakeRow {
     pub fn get<T: SnowflakeDecode>(&self, column_name: &str) -> Result<T> {
-        let index = self
-            .column_names
+        let (idx, _) = self
+            .column_types
             .get(&column_name.to_ascii_uppercase())
             .ok_or_else(|| Error::Decode(format!("column not found: {}", column_name)))?;
-        self.row[*index].try_get()
+        self.row[*idx].try_get()
     }
     pub fn column_names(&self) -> Vec<&str> {
-        self.column_names.iter().map(|(k, _)| k.as_str()).collect()
+        self.column_types.iter().map(|(k, _)| k.as_str()).collect()
+    }
+    pub fn column_types(&self) -> Vec<SnowflakeColumn> {
+        let column_types = self.column_types.deref();
+        let mut v: Vec<_> = column_types
+            .iter()
+            .map(|(name, (idx, ty))| SnowflakeColumn {
+                name: name.clone(),
+                index: *idx,
+                column_type: ty.clone(),
+            })
+            .collect();
+        // sort by column index
+        v.sort_by_key(|c| c.index);
+        v
     }
 }
 

tests/test-chunk.rs

@@ -38,5 +38,25 @@ async fn test_download_chunked_results() -> Result<()> {
     assert!(rows[0].column_names().contains(&"SEQ"));
     assert!(rows[0].column_names().contains(&"RAND"));
 
+    let columns = rows[0].column_types();
+    assert_eq!(
+        columns[0]
+            .column_type()
+            .snowflake_type()
+            .to_ascii_uppercase(),
+        "FIXED"
+    );
+    assert_eq!(columns[0].column_type().nullable(), false);
+    assert_eq!(columns[0].index(), 0);
+    assert_eq!(
+        columns[1]
+            .column_type()
+            .snowflake_type()
+            .to_ascii_uppercase(),
+        "TEXT"
+    );
+    assert_eq!(columns[1].column_type().nullable(), false);
+    assert_eq!(columns[1].index(), 1);
+
     Ok(())
 }