ok

Author: juleswritescode

Cargo.lock

@@ -23,6 +23,7 @@ biome_js_syntax = "0.5.7"
 biome_rowan = "0.5.7"
 biome_string_case = "0.5.8"
 bpaf = { version = "0.9.15", features = ["derive"] }
+criterion = "0.5"
 crossbeam = "0.8.4"
 enumflags2 = "0.7.11"
 ignore = "0.4.23"

Cargo.toml

@@ -31,7 +31,7 @@ sqlx.workspace = true
 tokio = { version = "1.41.1", features = ["full"] }
 
 [dev-dependencies]
-criterion = "0.5.1"
+criterion.workspace = true
 pgt_test_utils.workspace = true
 
 [lib]

crates/pgt_completions/Cargo.toml

@@ -19,7 +19,7 @@ pgt_text_size.workspace = true
 regex.workspace = true
 
 [dev-dependencies]
-criterion = "0.3"
+criterion.workspace = true 
 ntest = "0.9.3"
 
 [[bench]]

crates/pgt_statement_splitter/Cargo.toml

@@ -29,8 +29,13 @@ tree-sitter.workspace = true
 uuid = { version = "1.18.1", features = ["v4"] }
 
 [dev-dependencies]
+criterion.workspace = true
 insta.workspace = true
 pgt_test_utils.workspace = true
 
+[[bench]]
+harness = false
+name = "error_rewriting"
+
 [lib]
 doctest = false

crates/pgt_typecheck/Cargo.toml

@@ -0,0 +1,55 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use pgt_typecheck::diagnostics::rewrite_error_message;
+use pgt_typecheck::IdentifierReplacement;
+
+fn benchmark_error_rewriting(c: &mut Criterion) {
+ let replacement = IdentifierReplacement {
+ original_name: "user_id".to_string(),
+ original_range: 0..7,
+ default_value: "'00000000-0000-0000-0000-000000000000'".to_string(),
+ type_name: "uuid".to_string(),
+ };
+
+ // test case 1: matching the first pattern (most common case)
+ c.bench_function("rewrite_invalid_input_syntax", |b| {
+ b.iter(|| {
+ rewrite_error_message(
+ black_box(r#"invalid input syntax for type integer: "00000000-0000-0000-0000-000000000000""#),
+ black_box(&replacement),
+ )
+ })
+ });
+
+ // test case 2: matching the operator pattern
+ c.bench_function("rewrite_operator_does_not_exist", |b| {
+ b.iter(|| {
+ rewrite_error_message(
+ black_box("operator does not exist: integer + text"),
+ black_box(&replacement),
+ )
+ })
+ });
+
+ // test case 3: no pattern matches (fallback)
+ c.bench_function("rewrite_fallback", |b| {
+ b.iter(|| {
+ rewrite_error_message(
+ black_box("some other error message that doesn't match any pattern"),
+ black_box(&replacement),
+ )
+ })
+ });
+
+ // test case 4: longer error message with first pattern
+ c.bench_function("rewrite_long_message", |b| {
+ b.iter(|| {
+ rewrite_error_message(
+ black_box(r#"invalid input syntax for type timestamp: "00000000-0000-0000-0000-000000000000" at character 45"#),
+ black_box(&replacement),
+ )
+ })
+ });
+}
+
+criterion_group!(benches, benchmark_error_rewriting);
+criterion_main!(benches);

crates/pgt_typecheck/benches/error_rewriting.rs

@@ -116,20 +116,6 @@ static ERROR_RULES: Lazy<Vec<ErrorRewriteRule>> = Lazy::new(|| {
  )
  },
  },
- ErrorRewriteRule {
- pattern: Regex::new(
- r#"column "([^"]*)" is of type (\w+) but expression is of type (\w+)"#,
- )
- .unwrap(),
- rewrite: |caps, replacement| {
- let column = &caps[1];
- let expected_type = &caps[2];
- format!(
- "column `{}` expects {}, but `{}` is of type {}",
- column, expected_type, replacement.original_name, replacement.type_name
- )
- },
- },
  ErrorRewriteRule {
  pattern: Regex::new(r#"operator does not exist: (.+)"#).unwrap(),
  rewrite: |caps, replacement| {
@@ -144,7 +130,7 @@ static ERROR_RULES: Lazy<Vec<ErrorRewriteRule>> = Lazy::new(|| {
 });
 
 /// Rewrites Postgres error messages to be more user-friendly
-fn rewrite_error_message(pg_error_message: &str, replacement: &IdentifierReplacement) -> String {
+pub fn rewrite_error_message(pg_error_message: &str, replacement: &IdentifierReplacement) -> String {
  // try each rule
  for rule in ERROR_RULES.iter() {
  if let Some(caps) = rule.pattern.captures(pg_error_message) {

crates/pgt_typecheck/src/diagnostics.rs

@@ -1,5 +1,5 @@
-mod diagnostics;
-mod typed_identifier;
+pub mod diagnostics;
+pub mod typed_identifier;
 
 pub use diagnostics::TypecheckDiagnostic;
 use diagnostics::create_type_error;
@@ -10,7 +10,7 @@ use sqlx::postgres::PgDatabaseError;
 pub use sqlx::postgres::PgSeverity;
 use sqlx::{Executor, PgPool};
 use typed_identifier::apply_identifiers;
-pub use typed_identifier::{IdentifierType, TypedIdentifier};
+pub use typed_identifier::{IdentifierReplacement, IdentifierType, TypedIdentifier};
 
 #[derive(Debug)]
 pub struct TypecheckParams<'a> {