refactor: use sparse struct to parse

Signed-off-by: cutecutecat <junyuchen@tensorchord.ai>

Author: cutecutecat

src/datatype/text_svecf32.rs

@@ -1,39 +1,22 @@
 use super::memory_svecf32::SVecf32Output;
 use crate::datatype::memory_svecf32::SVecf32Input;
-use crate::datatype::typmod::Typmod;
 use crate::error::*;
 use base::scalar::*;
 use base::vector::*;
-use num_traits::Zero;
 use pgrx::pg_sys::Oid;
 use std::ffi::{CStr, CString};
 
 #[pgrx::pg_extern(immutable, strict, parallel_safe)]
-fn _vectors_svecf32_in(input: &CStr, _oid: Oid, typmod: i32) -> SVecf32Output {
+fn _vectors_svecf32_in(input: &CStr, _oid: Oid, _typmod: i32) -> SVecf32Output {
     use crate::utils::parse::parse_pgvector_svector;
-    let reserve = Typmod::parse_from_i32(typmod)
-        .unwrap()
-        .dims()
-        .map(|x| x.get())
-        .unwrap_or(0);
-    let v = parse_pgvector_svector(input.to_bytes(), reserve as usize, |s| {
-        s.parse::<F32>().ok()
-    });
+    let v = parse_pgvector_svector(input.to_bytes(), |s| s.parse::<F32>().ok());
     match v {
         Err(e) => {
             bad_literal(&e.to_string());
         }
-        Ok(vector) => {
-            check_value_dims_1048575(vector.len());
-            let mut indexes = Vec::<u32>::new();
-            let mut values = Vec::<F32>::new();
-            for (i, &x) in vector.iter().enumerate() {
-                if !x.is_zero() {
-                    indexes.push(i as u32);
-                    values.push(x);
-                }
-            }
-            SVecf32Output::new(SVecf32Borrowed::new(vector.len() as u32, &indexes, &values))
+        Ok((indexes, values, dims)) => {
+            check_value_dims_1048575(dims);
+            SVecf32Output::new(SVecf32Borrowed::new(dims as u32, &indexes, &values))
         }
     }
 }

src/utils/parse.rs

@@ -88,16 +88,16 @@ where
 #[inline(always)]
 pub fn parse_pgvector_svector<T: Zero + Clone, F>(
     input: &[u8],
-    reserve: usize,
     f: F,
-) -> Result<Vec<T>, ParseVectorError>
+) -> Result<(Vec<u32>, Vec<T>, usize), ParseVectorError>
 where
     F: Fn(&str) -> Option<T>,
 {
     use arrayvec::ArrayVec;
     if input.is_empty() {
         return Err(ParseVectorError::EmptyString {});
     }
+    let mut dims: usize = 0;
     let left = 'a: {
         for position in 0..input.len() - 1 {
             match input[position] {
@@ -109,7 +109,6 @@ where
         return Err(ParseVectorError::BadParentheses { character: '{' });
     };
     let mut token: ArrayVec<u8, 48> = ArrayVec::new();
-    let mut capacity = reserve;
     let right = 'a: {
         for position in (1..input.len()).rev() {
             match input[position] {
@@ -121,7 +120,7 @@ where
                 b'/' => {
                     token.reverse();
                     let s = unsafe { std::str::from_utf8_unchecked(&token[..]) };
-                    capacity = s
+                    dims = s
                         .parse::<usize>()
                         .map_err(|_| ParseVectorError::BadParsing { position })?;
                 }
@@ -135,8 +134,9 @@ where
         }
         return Err(ParseVectorError::BadParentheses { character: '}' });
     };
-    let mut vector = vec![T::zero(); capacity];
-    let mut index: usize = 0;
+    let mut indexes = Vec::<u32>::new();
+    let mut values = Vec::<T>::new();
+    let mut index: u32 = 0;
     for position in left + 1..right {
         let c = input[position];
         match c {
@@ -153,7 +153,8 @@ where
                     // Safety: all bytes in `token` are ascii characters
                     let s = unsafe { std::str::from_utf8_unchecked(&token[1..]) };
                     let num = f(s).ok_or(ParseVectorError::BadParsing { position })?;
-                    vector[index] = num;
+                    indexes.push(index);
+                    values.push(num);
                     token.clear();
                 } else {
                     return Err(ParseVectorError::TooShortNumber { position });
@@ -164,7 +165,7 @@ where
                     // Safety: all bytes in `token` are ascii characters
                     let s = unsafe { std::str::from_utf8_unchecked(&token[1..]) };
                     index = s
-                        .parse::<usize>()
+                        .parse::<u32>()
                         .map_err(|_| ParseVectorError::BadParsing { position })?;
                     token.clear();
                 } else {
@@ -180,8 +181,9 @@ where
         // Safety: all bytes in `token` are ascii characters
         let s = unsafe { std::str::from_utf8_unchecked(&token[1..]) };
         let num = f(s).ok_or(ParseVectorError::BadParsing { position })?;
-        vector[index] = num;
+        indexes.push(index);
+        values.push(num);
         token.clear();
     }
-    Ok(vector)
+    Ok((indexes, values, dims))
 }