use super::*;
use rusqlite::hooks::{AuthAction, AuthContext, Authorization};
use std::sync::{
atomic::{AtomicUsize, Ordering},
Arc,
};
#[test]
fn physical_row_operations_reuse_preparation_with_fresh_bindings() {
let connection = Connection::open_in_memory().unwrap();
connection
.execute_batch("CREATE TABLE _metadata (key TEXT PRIMARY KEY, value TEXT NOT NULL)")
.unwrap();
let compiled = Arc::new(AtomicUsize::new(0));
let counter = Arc::clone(&compiled);
connection
.authorizer(Some(move |context: AuthContext<'_>| {
if matches!(
context.action,
AuthAction::Select | AuthAction::Insert { .. } | AuthAction::Delete { .. }
) {
counter.fetch_add(1, Ordering::Relaxed);
}
Authorization::Allow
}))
.unwrap();
let control = StorageReadControl::with_limit(65536);
let layout = super::super::NativeRecordFamily::Metadata.layout();
let transaction = connection.unchecked_transaction().unwrap();
for number in 0..128 {
let key = format!("key:{number:04}\0%_");
let text = format!("value:{number}");
let values = [
ValueRef::Text(key.as_bytes()),
ValueRef::Text(text.as_bytes()),
];
upsert(&transaction, layout, &values, &control).unwrap();
let encoded_key = physical_key(layout, &values, &control).unwrap();
let found = get(&transaction, layout, &encoded_key, &control)
.unwrap()
.unwrap();
assert_eq!(&*decode_row(&found, 2, &control).unwrap(), &values);
remove(&transaction, layout, &encoded_key, &control).unwrap();
assert!(get(&transaction, layout, &encoded_key, &control)
.unwrap()
.is_none());
upsert(&transaction, layout, &values, &control).unwrap();
}
assert!(
compiled.load(Ordering::Relaxed) <= 8,
"fixed row operations must not compile statements per row"
);
transaction.rollback().unwrap();
assert_eq!(
connection
.query_row("SELECT count(*) FROM _metadata", [], |row| row
.get::<_, i64>(0))
.unwrap(),
0
);
assert_eq!(control.memory().used(), 0);
connection
.authorizer(None::<fn(AuthContext<'_>) -> Authorization>)
.unwrap();
}
#[test]
fn a_row_is_read_with_its_size_until_it_exceeds_the_inline_limit() {
let connection = Connection::open_in_memory().unwrap();
connection
.execute_batch("CREATE TABLE _metadata (key TEXT PRIMARY KEY, value TEXT NOT NULL)")
.unwrap();
let layout = super::super::NativeRecordFamily::Metadata.layout();
let control = StorageReadControl::with_limit(4 << 20);
let rows = [
("a", String::new()),
("b", "v".repeat(INLINE_ROW_BYTES - 1)),
("c", "v".repeat(INLINE_ROW_BYTES)),
("d", "v".repeat(300_000)),
];
let mut keys = Vec::new();
for (key, value) in &rows {
let values = [
ValueRef::Text(key.as_bytes()),
ValueRef::Text(value.as_bytes()),
];
upsert(&connection, layout, &values, &control).unwrap();
keys.push(physical_key(layout, &values, &control).unwrap());
}
for ((key, value), encoded) in rows.iter().zip(&keys) {
let found = get(&connection, layout, encoded, &control)
.unwrap()
.unwrap();
assert_eq!(
&*decode_row(&found, 2, &control).unwrap(),
&[
ValueRef::Text(key.as_bytes()),
ValueRef::Text(value.as_bytes())
]
);
}
let mut visited = Vec::new();
visit(&connection, layout, &control, |values| {
visited.push(values[1].as_str().unwrap().len());
Ok(())
})
.unwrap();
assert_eq!(
visited,
[0, INLINE_ROW_BYTES - 1, INLINE_ROW_BYTES, 300_000]
);
drop(keys);
assert_eq!(control.memory().used(), 0);
let narrow = StorageReadControl::with_limit(64 * 1024);
let encoded = |key: &str| {
physical_key(
layout,
&[ValueRef::Text(key.as_bytes()), ValueRef::Text(b"")],
&narrow,
)
.unwrap()
};
assert!(get(&connection, layout, &encoded("c"), &narrow)
.unwrap()
.is_some());
assert!(matches!(
get(&connection, layout, &encoded("d"), &narrow),
Err(crate::mvcc::Error::Version(VersionError::Memory(_)))
));
assert!(get(&connection, layout, &encoded("missing"), &narrow)
.unwrap()
.is_none());
assert_eq!(narrow.memory().used(), 0);
}