feat: 10% faster by using uuid

benfdking · benfdking · commit 7a998dea9e61 · 2024-05-13T19:01:25.000Z
- went from 2.66s on before to 2.44s after
diff --git a/crates/lib/src/core/parser/context.rs b/crates/lib/src/core/parser/context.rs
@@ -16,7 +16,7 @@ pub struct ParseContext<'a> {
     match_depth: usize,
     track_progress: bool,
     pub(crate) terminators: Vec<Rc<dyn Matchable>>,
-    parse_cache: AHashMap<((String, (usize, usize), &'static str, usize), String), MatchResult>,
+    parse_cache: AHashMap<((String, (usize, usize), &'static str, usize), uuid::Uuid), MatchResult>,
     pub(crate) indentation_config: AHashMap<String, bool>,
 }
 
@@ -139,15 +139,15 @@ impl<'a> ParseContext<'a> {
     pub(crate) fn check_parse_cache(
         &self,
         loc_key: (String, (usize, usize), &'static str, usize),
-        matcher_key: String,
+        matcher_key: uuid::Uuid,
     ) -> Option<MatchResult> {
         self.parse_cache.get(&(loc_key, matcher_key)).cloned()
     }
 
     pub(crate) fn put_parse_cache(
         &mut self,
         loc_key: (String, (usize, usize), &'static str, usize),
-        matcher_key: String,
+        matcher_key: uuid::Uuid,
         match_result: MatchResult,
     ) {
         self.parse_cache.insert((loc_key, matcher_key), match_result);
diff --git a/crates/lib/src/core/parser/grammar/anyof.rs b/crates/lib/src/core/parser/grammar/anyof.rs
@@ -85,7 +85,7 @@ pub struct AnyNumberOf {
     pub allow_gaps: bool,
     pub optional: bool,
     pub parse_mode: ParseMode,
-    cache_key: String,
+    cache_key: Uuid,
 }
 
 impl PartialEq for AnyNumberOf {
@@ -104,7 +104,7 @@ impl AnyNumberOf {
             optional: false,
             parse_mode: ParseMode::Strict,
             terminators: Vec::new(),
-            cache_key: Uuid::new_v4().hyphenated().to_string(),
+            cache_key: Uuid::new_v4(),
         }
     }
 
@@ -292,8 +292,8 @@ impl Matchable for AnyNumberOf {
         Rc::new(new_grammar)
     }
 
-    fn cache_key(&self) -> String {
-        self.cache_key.clone()
+    fn cache_key(&self) -> Option<Uuid> {
+        Some(self.cache_key)
     }
 }
 
diff --git a/crates/lib/src/core/parser/grammar/base.rs b/crates/lib/src/core/parser/grammar/base.rs
@@ -28,15 +28,15 @@ pub struct BaseGrammar {
     terminators: Vec<Rc<dyn Matchable>>,
     reset_terminators: bool,
     parse_mode: ParseMode,
-    cache_key: String,
+    cache_key: Uuid,
 }
 
 impl PartialEq for BaseGrammar {
     fn eq(&self, other: &Self) -> bool {
         // self.elements == other.elements &&
         self.allow_gaps == other.allow_gaps
             && self.optional == other.optional
-        //   && self.terminators == other.terminators
+            //   && self.terminators == other.terminators
             && self.reset_terminators == other.reset_terminators
             && self.parse_mode == other.parse_mode
             && self.cache_key == other.cache_key
@@ -52,7 +52,7 @@ impl BaseGrammar {
         reset_terminators: bool,
         parse_mode: ParseMode,
     ) -> Self {
-        let cache_key = Uuid::new_v4().to_string();
+        let cache_key = Uuid::new_v4();
 
         Self {
             elements,
@@ -98,8 +98,8 @@ impl Matchable for BaseGrammar {
         Ok(MatchResult::new(Vec::new(), Vec::new()))
     }
 
-    fn cache_key(&self) -> String {
-        self.cache_key.clone()
+    fn cache_key(&self) -> Option<Uuid> {
+        Some(self.cache_key)
     }
 }
 
@@ -112,7 +112,7 @@ pub struct Ref {
     reset_terminators: bool,
     allow_gaps: bool,
     optional: bool,
-    cache_key: String,
+    cache_key: Uuid,
     simple_cache: OnceCell<Option<(AHashSet<String>, AHashSet<String>)>>,
 }
 
@@ -132,7 +132,7 @@ impl Ref {
             reset_terminators: false,
             allow_gaps: true,
             optional: false,
-            cache_key: Uuid::new_v4().hyphenated().to_string(),
+            cache_key: Uuid::new_v4(),
             simple_cache: OnceCell::new(),
         }
     }
@@ -245,8 +245,8 @@ impl Matchable for Ref {
         })
     }
 
-    fn cache_key(&self) -> String {
-        self.cache_key.clone()
+    fn cache_key(&self) -> Option<Uuid> {
+        Some(self.cache_key)
     }
 }
 
@@ -363,15 +363,25 @@ pub fn longest_trimmed_match(
     for (_idx, matcher) in enumerate(available_options) {
         let matcher_key = matcher.cache_key();
 
-        let match_result = match parse_context
-            .check_parse_cache(loc_key.clone(), matcher_key.clone())
-        {
-            Some(match_result) => match_result,
-            None => {
-                let match_result = matcher.match_segments(segments, parse_context)?;
+        let match_result = if let Some(matcher_key) = matcher_key {
+            match parse_context.check_parse_cache(loc_key.clone(), matcher_key) {
+                Some(match_result) => match_result,
+                None => {
+                    let match_result = matcher.match_segments(segments, parse_context)?;
+                    parse_context.put_parse_cache(
+                        loc_key.clone(),
+                        matcher_key,
+                        match_result.clone(),
+                    );
+                    match_result
+                }
+            }
+        } else {
+            let match_result = matcher.match_segments(segments, parse_context)?;
+            if let Some(matcher_key) = matcher_key {
                 parse_context.put_parse_cache(loc_key.clone(), matcher_key, match_result.clone());
-                match_result
             }
+            match_result
         };
 
         // No match. Skip this one.
diff --git a/crates/lib/src/core/parser/grammar/delimited.rs b/crates/lib/src/core/parser/grammar/delimited.rs
@@ -2,6 +2,7 @@ use std::ops::{Deref, DerefMut};
 use std::rc::Rc;
 
 use ahash::AHashSet;
+use uuid::Uuid;
 
 use super::anyof::{one_of, AnyNumberOf};
 use super::base::{longest_trimmed_match, Ref};
@@ -26,7 +27,7 @@ pub struct Delimited {
     delimiter: Rc<dyn Matchable>,
     pub(crate) min_delimiters: Option<usize>,
     optional: bool,
-    cache_key: String,
+    cache_key: Uuid,
 }
 
 impl Delimited {
@@ -37,7 +38,7 @@ impl Delimited {
             delimiter: Ref::new("CommaSegment").to_matchable(),
             min_delimiters: None,
             optional: false,
-            cache_key: uuid::Uuid::new_v4().hyphenated().to_string(),
+            cache_key: Uuid::new_v4(),
         }
     }
 
@@ -249,8 +250,8 @@ impl Matchable for Delimited {
         Ok(MatchResult { matched_segments, unmatched_segments })
     }
 
-    fn cache_key(&self) -> String {
-        self.cache_key.clone()
+    fn cache_key(&self) -> Option<Uuid> {
+        Some(self.cache_key)
     }
 }
 
diff --git a/crates/lib/src/core/parser/grammar/noncode.rs b/crates/lib/src/core/parser/grammar/noncode.rs
@@ -1,4 +1,5 @@
 use ahash::AHashSet;
+use uuid::Uuid;
 
 use crate::core::errors::SQLParseError;
 use crate::core::parser::context::ParseContext;
@@ -40,8 +41,8 @@ impl Matchable for NonCodeMatcher {
         Ok(MatchResult::new(segments[0..idx].to_vec(), segments[idx..].to_vec()))
     }
 
-    fn cache_key(&self) -> String {
-        "non-code-matcher".to_string()
+    fn cache_key(&self) -> Option<Uuid> {
+        None
     }
 }
 
diff --git a/crates/lib/src/core/parser/grammar/sequence.rs b/crates/lib/src/core/parser/grammar/sequence.rs
@@ -113,7 +113,7 @@ pub struct Sequence {
     pub(crate) allow_gaps: bool,
     is_optional: bool,
     pub(crate) terminators: Vec<Rc<dyn Matchable>>,
-    cache_key: String,
+    cache_key: Uuid,
 }
 
 impl Sequence {
@@ -124,7 +124,7 @@ impl Sequence {
             is_optional: false,
             parse_mode: ParseMode::Strict,
             terminators: Vec::new(),
-            cache_key: Uuid::new_v4().hyphenated().to_string(),
+            cache_key: Uuid::new_v4(),
         }
     }
 
@@ -407,8 +407,8 @@ impl Matchable for Sequence {
         })
     }
 
-    fn cache_key(&self) -> String {
-        self.cache_key.clone()
+    fn cache_key(&self) -> Option<Uuid> {
+        Some(self.cache_key)
     }
 
     fn copy(
@@ -698,7 +698,7 @@ impl Matchable for Bracketed {
         })
     }
 
-    fn cache_key(&self) -> String {
+    fn cache_key(&self) -> Option<Uuid> {
         self.this.cache_key()
     }
 }
diff --git a/crates/lib/src/core/parser/matchable.rs b/crates/lib/src/core/parser/matchable.rs
@@ -84,7 +84,9 @@ pub trait Matchable: Any + Segment + DynClone + Debug + DynEq {
     }
 
     // A method to generate a unique cache key for the matchable object.
-    fn cache_key(&self) -> String {
+    //
+    // Returns none for no caching key
+    fn cache_key(&self) -> Option<uuid::Uuid> {
         unimplemented!("{}", std::any::type_name::<Self>())
     }
 
diff --git a/crates/lib/src/core/parser/parsers.rs b/crates/lib/src/core/parser/parsers.rs
@@ -85,8 +85,8 @@ impl TypedParser {
 impl Segment for TypedParser {}
 
 impl Matchable for TypedParser {
-    fn cache_key(&self) -> String {
-        Uuid::new_v4().hyphenated().to_string()
+    fn cache_key(&self) -> Option<Uuid> {
+        Some(Uuid::new_v4())
     }
 
     fn simple(
@@ -124,7 +124,7 @@ pub struct StringParser {
                             * Rust */
     optional: bool,
     trim_chars: Option<Vec<char>>,
-    cache_key: String,
+    cache_key: Uuid,
 }
 
 impl StringParser {
@@ -145,7 +145,7 @@ impl StringParser {
             type_,
             optional,
             trim_chars,
-            cache_key: Uuid::new_v4().hyphenated().to_string(),
+            cache_key: Uuid::new_v4(),
         }
     }
 
@@ -212,8 +212,8 @@ impl Matchable for StringParser {
         Ok(MatchResult::from_unmatched(segments.to_vec()))
     }
 
-    fn cache_key(&self) -> String {
-        self.cache_key.clone()
+    fn cache_key(&self) -> Option<Uuid> {
+        Some(self.cache_key)
     }
 }
 
@@ -225,7 +225,7 @@ pub struct RegexParser {
     _template: HashableFancyRegex,
     _anti_template: HashableFancyRegex,
     factory: fn(&dyn Segment) -> ErasedSegment,
-    cache_key: String, // Add other fields as needed
+    cache_key: Uuid, // Add other fields as needed
 }
 
 impl PartialEq for RegexParser {
@@ -257,7 +257,7 @@ impl RegexParser {
             _template: HashableFancyRegex(template_pattern),
             _anti_template: HashableFancyRegex(anti_template_pattern),
             factory, // Initialize other fields here
-            cache_key: Uuid::new_v4().hyphenated().to_string(),
+            cache_key: Uuid::new_v4(),
         }
     }
 
@@ -332,8 +332,8 @@ impl Matchable for RegexParser {
         Ok(MatchResult::from_unmatched(segments.to_vec()))
     }
 
-    fn cache_key(&self) -> String {
-        self.cache_key.clone()
+    fn cache_key(&self) -> Option<Uuid> {
+        Some(self.cache_key)
     }
 }
 
@@ -432,7 +432,7 @@ impl Matchable for MultiStringParser {
         Ok(MatchResult::from_unmatched(segments.to_vec()))
     }
 
-    fn cache_key(&self) -> String {
+    fn cache_key(&self) -> Option<Uuid> {
         todo!()
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -85,7 +85,7 @@ pub struct AnyNumberOf {`
`85`	`85`	`pub allow_gaps: bool,`
`86`	`86`	`pub optional: bool,`
`87`	`87`	`pub parse_mode: ParseMode,`
`88`		`- cache_key: String,`
	`88`	`+ cache_key: Uuid,`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`impl PartialEq for AnyNumberOf {`
`@@ -104,7 +104,7 @@ impl AnyNumberOf {`
`104`	`104`	`optional: false,`
`105`	`105`	`parse_mode: ParseMode::Strict,`
`106`	`106`	`terminators: Vec::new(),`
`107`		`- cache_key: Uuid::new_v4().hyphenated().to_string(),`
	`107`	`+ cache_key: Uuid::new_v4(),`
`108`	`108`	`}`
`109`	`109`	`}`
`110`	`110`
`@@ -292,8 +292,8 @@ impl Matchable for AnyNumberOf {`
`292`	`292`	`Rc::new(new_grammar)`
`293`	`293`	`}`
`294`	`294`
`295`		`- fn cache_key(&self) -> String {`
`296`		`- self.cache_key.clone()`
	`295`	`+ fn cache_key(&self) -> Option<Uuid> {`
	`296`	`+ Some(self.cache_key)`
`297`	`297`	`}`
`298`	`298`	`}`
`299`	`299`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@ use std::ops::{Deref, DerefMut};`
`2`	`2`	`use std::rc::Rc;`
`3`	`3`
`4`	`4`	`use ahash::AHashSet;`
	`5`	`+use uuid::Uuid;`
`5`	`6`
`6`	`7`	`use super::anyof::{one_of, AnyNumberOf};`
`7`	`8`	`use super::base::{longest_trimmed_match, Ref};`
`@@ -26,7 +27,7 @@ pub struct Delimited {`
`26`	`27`	`delimiter: Rc<dyn Matchable>,`
`27`	`28`	`pub(crate) min_delimiters: Option<usize>,`
`28`	`29`	`optional: bool,`
`29`		`- cache_key: String,`
	`30`	`+ cache_key: Uuid,`
`30`	`31`	`}`
`31`	`32`
`32`	`33`	`impl Delimited {`
`@@ -37,7 +38,7 @@ impl Delimited {`
`37`	`38`	`delimiter: Ref::new("CommaSegment").to_matchable(),`
`38`	`39`	`min_delimiters: None,`
`39`	`40`	`optional: false,`
`40`		`- cache_key: uuid::Uuid::new_v4().hyphenated().to_string(),`
	`41`	`+ cache_key: Uuid::new_v4(),`
`41`	`42`	`}`
`42`	`43`	`}`
`43`	`44`
`@@ -249,8 +250,8 @@ impl Matchable for Delimited {`
`249`	`250`	`Ok(MatchResult { matched_segments, unmatched_segments })`
`250`	`251`	`}`
`251`	`252`
`252`		`- fn cache_key(&self) -> String {`
`253`		`- self.cache_key.clone()`
	`253`	`+ fn cache_key(&self) -> Option<Uuid> {`
	`254`	`+ Some(self.cache_key)`
`254`	`255`	`}`
`255`	`256`	`}`
`256`	`257`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`use ahash::AHashSet;`
	`2`	`+use uuid::Uuid;`
`2`	`3`
`3`	`4`	`use crate::core::errors::SQLParseError;`
`4`	`5`	`use crate::core::parser::context::ParseContext;`
`@@ -40,8 +41,8 @@ impl Matchable for NonCodeMatcher {`
`40`	`41`	`Ok(MatchResult::new(segments[0..idx].to_vec(), segments[idx..].to_vec()))`
`41`	`42`	`}`
`42`	`43`
`43`		`- fn cache_key(&self) -> String {`
`44`		`- "non-code-matcher".to_string()`
	`44`	`+ fn cache_key(&self) -> Option<Uuid> {`
	`45`	`+ None`
`45`	`46`	`}`
`46`	`47`	`}`
`47`	`48`
Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,7 @@ pub struct Sequence {`
`113`	`113`	`pub(crate) allow_gaps: bool,`
`114`	`114`	`is_optional: bool,`
`115`	`115`	`pub(crate) terminators: Vec<Rc<dyn Matchable>>,`
`116`		`- cache_key: String,`
	`116`	`+ cache_key: Uuid,`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`impl Sequence {`
`@@ -124,7 +124,7 @@ impl Sequence {`
`124`	`124`	`is_optional: false,`
`125`	`125`	`parse_mode: ParseMode::Strict,`
`126`	`126`	`terminators: Vec::new(),`
`127`		`- cache_key: Uuid::new_v4().hyphenated().to_string(),`
	`127`	`+ cache_key: Uuid::new_v4(),`
`128`	`128`	`}`
`129`	`129`	`}`
`130`	`130`
`@@ -407,8 +407,8 @@ impl Matchable for Sequence {`
`407`	`407`	`})`
`408`	`408`	`}`
`409`	`409`
`410`		`- fn cache_key(&self) -> String {`
`411`		`- self.cache_key.clone()`
	`410`	`+ fn cache_key(&self) -> Option<Uuid> {`
	`411`	`+ Some(self.cache_key)`
`412`	`412`	`}`
`413`	`413`
`414`	`414`	`fn copy(`
`@@ -698,7 +698,7 @@ impl Matchable for Bracketed {`
`698`	`698`	`})`
`699`	`699`	`}`
`700`	`700`
`701`		`- fn cache_key(&self) -> String {`
	`701`	`+ fn cache_key(&self) -> Option<Uuid> {`
`702`	`702`	`self.this.cache_key()`
`703`	`703`	`}`
`704`	`704`	`}`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,9 @@ pub trait Matchable: Any + Segment + DynClone + Debug + DynEq {`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`// A method to generate a unique cache key for the matchable object.`
`87`		`- fn cache_key(&self) -> String {`
	`87`	`+ //`
	`88`	`+ // Returns none for no caching key`
	`89`	`+ fn cache_key(&self) -> Option<uuid::Uuid> {`
`88`	`90`	`unimplemented!("{}", std::any::type_name::<Self>())`
`89`	`91`	`}`
`90`	`92`
Original file line number	Diff line number	Diff line change
`@@ -85,8 +85,8 @@ impl TypedParser {`
`85`	`85`	`impl Segment for TypedParser {}`
`86`	`86`
`87`	`87`	`impl Matchable for TypedParser {`
`88`		`- fn cache_key(&self) -> String {`
`89`		`- Uuid::new_v4().hyphenated().to_string()`
	`88`	`+ fn cache_key(&self) -> Option<Uuid> {`
	`89`	`+ Some(Uuid::new_v4())`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`fn simple(`
`@@ -124,7 +124,7 @@ pub struct StringParser {`
`124`	`124`	`* Rust */`
`125`	`125`	`optional: bool,`
`126`	`126`	`trim_chars: Option<Vec<char>>,`
`127`		`- cache_key: String,`
	`127`	`+ cache_key: Uuid,`
`128`	`128`	`}`
`129`	`129`
`130`	`130`	`impl StringParser {`
`@@ -145,7 +145,7 @@ impl StringParser {`
`145`	`145`	`type_,`
`146`	`146`	`optional,`
`147`	`147`	`trim_chars,`
`148`		`- cache_key: Uuid::new_v4().hyphenated().to_string(),`
	`148`	`+ cache_key: Uuid::new_v4(),`
`149`	`149`	`}`
`150`	`150`	`}`
`151`	`151`
`@@ -212,8 +212,8 @@ impl Matchable for StringParser {`
`212`	`212`	`Ok(MatchResult::from_unmatched(segments.to_vec()))`
`213`	`213`	`}`
`214`	`214`
`215`		`- fn cache_key(&self) -> String {`
`216`		`- self.cache_key.clone()`
	`215`	`+ fn cache_key(&self) -> Option<Uuid> {`
	`216`	`+ Some(self.cache_key)`
`217`	`217`	`}`
`218`	`218`	`}`
`219`	`219`
`@@ -225,7 +225,7 @@ pub struct RegexParser {`
`225`	`225`	`_template: HashableFancyRegex,`
`226`	`226`	`_anti_template: HashableFancyRegex,`
`227`	`227`	`factory: fn(&dyn Segment) -> ErasedSegment,`
`228`		`- cache_key: String, // Add other fields as needed`
	`228`	`+ cache_key: Uuid, // Add other fields as needed`
`229`	`229`	`}`
`230`	`230`
`231`	`231`	`impl PartialEq for RegexParser {`
`@@ -257,7 +257,7 @@ impl RegexParser {`
`257`	`257`	`_template: HashableFancyRegex(template_pattern),`
`258`	`258`	`_anti_template: HashableFancyRegex(anti_template_pattern),`
`259`	`259`	`factory, // Initialize other fields here`
`260`		`- cache_key: Uuid::new_v4().hyphenated().to_string(),`
	`260`	`+ cache_key: Uuid::new_v4(),`
`261`	`261`	`}`
`262`	`262`	`}`
`263`	`263`
`@@ -332,8 +332,8 @@ impl Matchable for RegexParser {`
`332`	`332`	`Ok(MatchResult::from_unmatched(segments.to_vec()))`
`333`	`333`	`}`
`334`	`334`
`335`		`- fn cache_key(&self) -> String {`
`336`		`- self.cache_key.clone()`
	`335`	`+ fn cache_key(&self) -> Option<Uuid> {`
	`336`	`+ Some(self.cache_key)`
`337`	`337`	`}`
`338`	`338`	`}`
`339`	`339`
`@@ -432,7 +432,7 @@ impl Matchable for MultiStringParser {`
`432`	`432`	`Ok(MatchResult::from_unmatched(segments.to_vec()))`
`433`	`433`	`}`
`434`	`434`
`435`		`- fn cache_key(&self) -> String {`
	`435`	`+ fn cache_key(&self) -> Option<Uuid> {`
`436`	`436`	`todo!()`
`437`	`437`	`}`
`438`	`438`	`}`