fix: remove funcs

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

Author: cutecutecat

src/datatype/text_svecf32.rs

@@ -1,3 +1,6 @@
+use num_traits::Zero;
+use pgrx::error;
+
 use super::memory_svecf32::SVecf32Output;
 use crate::datatype::memory_svecf32::SVecf32Input;
 use crate::error::*;
@@ -9,22 +12,66 @@ use std::fmt::Write;
 
 #[pgrx::pg_extern(immutable, strict, parallel_safe)]
 fn _vectors_svecf32_in(input: &CStr, _oid: Oid, _typmod: i32) -> SVecf32Output {
-    use crate::utils::parse::{parse_pgvector_svector, svector_filter_nonzero, svector_sorted};
+    use crate::utils::parse::parse_pgvector_svector;
     let v = parse_pgvector_svector(input.to_bytes(), |s| s.parse::<F32>().ok());
     match v {
         Err(e) => {
             bad_literal(&e.to_string());
         }
-        Ok((indexes, values, dims)) => {
-            let (mut sorted_indexes, mut sorted_values) = svector_sorted(&indexes, &values);
+        Ok((mut indexes, mut values, dims)) => {
             check_value_dims_1048575(dims);
-            check_index_in_bound(&sorted_indexes, dims);
-            svector_filter_nonzero(&mut sorted_indexes, &mut sorted_values);
-            SVecf32Output::new(SVecf32Borrowed::new(
-                dims as u32,
-                &sorted_indexes,
-                &sorted_values,
-            ))
+            // is_sorted
+            if !indexes.windows(2).all(|i| i[0] <= i[1]) {
+                assert_eq!(indexes.len(), values.len());
+                let n = indexes.len();
+                let mut permutation = (0..n).collect::<Vec<_>>();
+                permutation.sort_unstable_by_key(|&i| &indexes[i]);
+                for i in 0..n {
+                    if i == permutation[i] || usize::MAX == permutation[i] {
+                        continue;
+                    }
+                    let index = indexes[i];
+                    let value = values[i];
+                    let mut j = i;
+                    while i != permutation[j] {
+                        let next = permutation[j];
+                        indexes[j] = indexes[permutation[j]];
+                        values[j] = values[permutation[j]];
+                        permutation[j] = usize::MAX;
+                        j = next;
+                    }
+                    indexes[j] = index;
+                    values[j] = value;
+                    permutation[j] = usize::MAX;
+                }
+            }
+            let mut last: Option<u32> = None;
+            for index in indexes.clone() {
+                if last == Some(index) {
+                    error!(
+                        "Indexes need to be unique, but there are more than one same index {index}"
+                    )
+                }
+                if last >= Some(dims as u32) {
+                    error!("Index out of bounds: the dim is {dims} but the index is {index}");
+                }
+                last = Some(index);
+                {
+                    let mut i = 0;
+                    let mut j = 0;
+                    while j < values.len() {
+                        if !values[j].is_zero() {
+                            indexes[i] = indexes[j];
+                            values[i] = values[j];
+                            i += 1;
+                        }
+                        j += 1;
+                    }
+                    indexes.truncate(i);
+                    values.truncate(i);
+                }
+            }
+            SVecf32Output::new(SVecf32Borrowed::new(dims as u32, &indexes, &values))
         }
     }
 }

src/error.rs

@@ -69,20 +69,6 @@ ADVICE: Check if dimensions of the vector are among 1 and 1_048_575."
     NonZeroU32::new(dims as u32).unwrap()
 }
 
-pub fn check_index_in_bound(indexes: &[u32], dims: usize) -> NonZeroU32 {
-    let mut last: Option<u32> = None;
-    for index in indexes {
-        if last == Some(*index) {
-            error!("Indexes need to be unique, but there are more than one same index {index}")
-        }
-        if *index >= dims as u32 {
-            error!("Index out of bounds: the dim is {dims} but the index is {index}");
-        }
-        last = Some(*index);
-    }
-    NonZeroU32::new(dims as u32).unwrap()
-}
-
 pub fn bad_literal(hint: &str) -> ! {
     error!(
         "\

src/utils/parse.rs

@@ -98,43 +98,6 @@ enum ParseState {
     Dims,
 }
 
-#[inline(always)]
-pub fn svector_sorted<T: Zero + Clone + PartialEq>(
-    indexes: &[u32],
-    values: &[T],
-) -> (Vec<u32>, Vec<T>) {
-    let mut indices = (0..indexes.len()).collect::<Vec<_>>();
-    indices.sort_by_key(|&i| &indexes[i]);
-
-    let mut sorted_indexes: Vec<u32> = Vec::with_capacity(indexes.len());
-    let mut sorted_values: Vec<T> = Vec::with_capacity(indexes.len());
-    for i in indices {
-        sorted_indexes.push(*indexes.get(i).unwrap());
-        sorted_values.push(values.get(i).unwrap().clone());
-    }
-    (sorted_indexes, sorted_values)
-}
-
-#[inline(always)]
-pub fn svector_filter_nonzero<T: Zero + Clone + PartialEq>(
-    indexes: &mut Vec<u32>,
-    values: &mut Vec<T>,
-) {
-    // Index must be sorted!
-    let mut i = 0;
-    let mut j = 0;
-    while j < values.len() {
-        if !values[j].is_zero() {
-            indexes[i] = indexes[j];
-            values[i] = values[j].clone();
-            i += 1;
-        }
-        j += 1;
-    }
-    indexes.truncate(i);
-    values.truncate(i);
-}
-
 #[inline(always)]
 pub fn parse_pgvector_svector<T: Zero + Clone, F>(
     input: &[u8],
@@ -312,56 +275,4 @@ mod tests {
             assert_eq!(ret.unwrap_err(), err, "parsed at expr {:?}", e);
         }
     }
-
-    #[test]
-    fn test_svector_parse_filter() {
-        let exprs: Vec<(&str, (Vec<u32>, Vec<F32>, usize), (Vec<u32>, Vec<F32>))> = vec![
-            ("{}/0", (vec![], vec![], 0), (vec![], vec![])),
-            ("{}/1919810", (vec![], vec![], 1919810), (vec![], vec![])),
-            (
-                "{0:1, 0:2}/1",
-                (vec![0, 0], vec![F32(1.0), F32(2.0)], 1),
-                (vec![0, 0], vec![F32(1.0), F32(2.0)]),
-            ),
-            (
-                "{0:1, 1:1.5}/1",
-                (vec![0, 1], vec![F32(1.0), F32(1.5)], 1),
-                (vec![0, 1], vec![F32(1.0), F32(1.5)]),
-            ),
-            (
-                "{0:0, 1:0, 2:0}/2",
-                (vec![0, 1, 2], vec![F32(0.0), F32(0.0), F32(0.0)], 2),
-                (vec![], vec![]),
-            ),
-            (
-                "{2:0, 1:0}/2",
-                (vec![2, 1], vec![F32(0.0), F32(0.0)], 2),
-                (vec![], vec![]),
-            ),
-            (
-                "{2:0, 1:0, }/2",
-                (vec![2, 1], vec![F32(0.0), F32(0.0)], 2),
-                (vec![], vec![]),
-            ),
-            (
-                "{3:2, 2:1, 1:0, 0:-1}/4",
-                (
-                    vec![3, 2, 1, 0],
-                    vec![F32(2.0), F32(1.0), F32(0.0), F32(-1.0)],
-                    4,
-                ),
-                (vec![0, 2, 3], vec![F32(-1.0), F32(1.0), F32(2.0)]),
-            ),
-        ];
-        for (e, parsed, filtered) in exprs {
-            let ret = parse_pgvector_svector(e.as_bytes(), |s| s.parse::<F32>().ok());
-            assert!(ret.is_ok(), "at expr {:?}: {:?}", e, ret);
-            assert_eq!(ret.unwrap(), parsed, "parsed at expr {:?}", e);
-
-            let (indexes, values, _) = parsed;
-            let (mut indexes, mut values) = svector_sorted(&indexes, &values);
-            svector_filter_nonzero(&mut indexes, &mut values);
-            assert_eq!((indexes, values), filtered, "filtered at expr {:?}", e);
-        }
-    }
 }