use crate::{tests::providers::Provider, Engine};
const ORACLE_ALLOWANCE: usize = 256 << 20;
#[rstest::rstest]
#[case::memory(Provider::Memory)]
#[case::sqlite(Provider::SQLiteNative)]
#[case::sqlite_key_value(Provider::SQLiteKeyValue)]
#[case::redb(Provider::Redb)]
fn regular_expression_engine_matches_postgresql_and_reopen(#[case] provider: Provider) {
let directory = tempfile::tempdir().unwrap();
let path = directory.path().join("regular-expression-engine.db");
let engine = provider.open_with_retention(&path, ORACLE_ALLOWANCE);
let mut reference: serde_json::Value = serde_json::from_str(include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/../../tests/parity/pg18/regular_expression_engine_oracle.expected.json"
)))
.unwrap();
crate::tests::pg18_oracle::verify(&engine, &reference.to_string());
if matches!(provider, Provider::Memory) {
return;
}
drop(engine);
let engine = provider.open_with_retention(&path, ORACLE_ALLOWANCE);
reference["cases"].as_array_mut().unwrap().retain(|case| {
matches!(
case["id"].as_str().unwrap(),
"stored_view_rows"
| "stored_check_rejects_c_class"
| "stored_check_rejects_case"
| "stored_check_rows"
| "stored_default_values"
)
});
assert_eq!(reference["cases"].as_array().unwrap().len(), 5);
crate::tests::pg18_oracle::verify(&engine, &reference.to_string());
}
#[rstest::rstest]
#[case::memory(Provider::Memory)]
#[case::sqlite(Provider::SQLiteNative)]
#[case::sqlite_key_value(Provider::SQLiteKeyValue)]
#[case::redb(Provider::Redb)]
fn regex_compilation_preserves_native_admission_and_recovers(#[case] provider: Provider) {
let directory = tempfile::tempdir().unwrap();
let engine = provider.open_with_retention(&directory.path().join("regex-limit.db"), 64 << 20);
let retained = engine.query_retention_control().unwrap();
assert_eq!(retained.memory().used(), 0);
let error = engine
.sql(
"SELECT regexp_match('ab', '((((a{1,100}){1,100}){1,100}){1,100})')",
&[],
)
.unwrap_err();
assert_eq!(error.sqlstate(), Some("53200"), "{provider:?}: {error}");
let cached = engine.session.state.read().sql_statement_cache.clone();
let cached_bytes = retained.memory().used();
assert!(cached_bytes > 0);
assert_eq!(engine.transaction_depth(), 0);
assert_eq!(engine.sql("SELECT 1 AS value", &[]).unwrap().rows.len(), 1);
engine.close().unwrap();
drop(engine);
assert_eq!(retained.memory().used(), cached_bytes);
drop(cached);
assert_eq!(retained.memory().used(), 0);
}
#[test]
fn a_long_match_stops_at_the_statement_timeout() {
let engine = Engine::new();
engine.sql("SET statement_timeout = 50", &[]).unwrap();
for query in [
"SELECT regexp_match('a', repeat('(', 3000) || 'a' || repeat(')', 3000)) AS captures",
"SELECT * FROM regexp_matches('a', repeat('(', 3000) || 'a' || repeat(')', 3000)) AS m(captures)",
] {
let started = std::time::Instant::now();
let error = engine.sql(query, &[]).unwrap_err();
assert_eq!(error.sqlstate(), Some("57014"), "{query}: {error}");
assert_eq!(
error.to_string(),
"canceling statement due to statement timeout"
);
assert!(
started.elapsed() < std::time::Duration::from_secs(2),
"{query} ran to completion instead of stopping at the timeout"
);
}
assert_eq!(engine.sql("SELECT 1 AS value", &[]).unwrap().rows.len(), 1);
}