fix

Author: b41sh

src/functions/path.rs

@@ -1105,8 +1105,8 @@ impl RawJsonb<'_> {
     /// ```
     pub fn extract_scalar_key_values(&self) -> Result<Vec<(KeyPaths<'_>, Value<'_>)>> {
         let item = JsonbItem::from_raw_jsonb(*self)?;
-        let mut result = Vec::new();
-        let mut current_paths = Vec::new();
+        let mut result = Vec::with_capacity(16);
+        let mut current_paths = Vec::with_capacity(3);
         Self::extract_scalar_key_values_recursive(item, &mut current_paths, &mut result)?;
         Ok(result)
     }

src/keypath.rs

@@ -13,11 +13,8 @@
 // limitations under the License.
 
 use std::borrow::Cow;
-use std::cmp::Ordering;
 use std::fmt::Display;
 use std::fmt::Formatter;
-use std::hash::Hash;
-use std::hash::Hasher;
 
 use nom::branch::alt;
 use nom::character::complete::char;
@@ -53,90 +50,6 @@ pub enum KeyPath<'a> {
     Name(Cow<'a, str>),
 }
 
-impl Eq for KeyPaths<'_> {}
-
-impl PartialEq for KeyPaths<'_> {
-    fn eq(&self, other: &Self) -> bool {
-        let result = self.cmp(other);
-        result == Ordering::Equal
-    }
-}
-
-impl PartialOrd for KeyPaths<'_> {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for KeyPaths<'_> {
-    fn cmp(&self, other: &Self) -> Ordering {
-        for (self_path, other_path) in self.paths.iter().zip(other.paths.iter()) {
-            let ord = self_path.cmp(other_path);
-            if ord != Ordering::Equal {
-                return ord;
-            }
-        }
-        self.paths.len().cmp(&other.paths.len())
-    }
-}
-
-impl Eq for KeyPath<'_> {}
-
-impl PartialEq for KeyPath<'_> {
-    fn eq(&self, other: &Self) -> bool {
-        let ord = self.cmp(other);
-        ord == Ordering::Equal
-    }
-}
-
-impl PartialOrd for KeyPath<'_> {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for KeyPath<'_> {
-    fn cmp(&self, other: &Self) -> Ordering {
-        match (self, other) {
-            (KeyPath::Index(v1), KeyPath::Index(v2)) => v1.cmp(v2),
-            (
-                KeyPath::QuotedName(v1) | KeyPath::Name(v1),
-                KeyPath::QuotedName(v2) | KeyPath::Name(v2),
-            ) => v1.cmp(v2),
-            (KeyPath::QuotedName(_) | KeyPath::Name(_), KeyPath::Index(_)) => Ordering::Greater,
-            (KeyPath::Index(_), KeyPath::QuotedName(_) | KeyPath::Name(_)) => Ordering::Less,
-        }
-    }
-}
-
-impl Hash for KeyPath<'_> {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        match self {
-            KeyPath::Index(idx) => {
-                // Hash a discriminant to distinguish from other variants
-                0_u8.hash(state);
-                idx.hash(state);
-            }
-            KeyPath::QuotedName(name) => {
-                // Hash a discriminant to distinguish from other variants
-                1_u8.hash(state);
-                name.hash(state);
-            }
-            KeyPath::Name(name) => {
-                // Hash a discriminant to distinguish from other variants
-                2_u8.hash(state);
-                name.hash(state);
-            }
-        }
-    }
-}
-
-impl Hash for KeyPaths<'_> {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.paths.hash(state);
-    }
-}
-
 impl Display for KeyPaths<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(f, "{{")?;