use std::fs;
use std::path::PathBuf;
use std::sync::atomic::{AtomicU64, Ordering};
static COUNTER: AtomicU64 = AtomicU64::new(0);
fn temp_dir() -> PathBuf {
let d = std::env::temp_dir().join("timslite_integration");
fs::create_dir_all(&d).unwrap();
let id = COUNTER.fetch_add(1, Ordering::Relaxed);
d.join(format!(
"test_{:?}_{id}",
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
))
}
#[test]
fn t33_1_iterator_cross_segment() {
use timslite::{Store, StoreConfig};
let dir = temp_dir();
let mut store = Store::open(&dir, StoreConfig::default()).unwrap();
store
.create_dataset(
"cross_seg",
"data",
256 * 1024, 4 * 1024 * 1024,
6,
0,
0,
)
.unwrap();
let ds = store.open_dataset("cross_seg", "data").unwrap();
let arc = ds.clone();
{
let lock = arc.clone();
for i in 0..200i64 {
let data = vec![0xABu8; 4096]; lock.write(i * 10 + 1, &data).unwrap();
}
}
{
let lock = arc.clone();
let entries = lock.query(1, 2001).unwrap();
assert_eq!(entries.len(), 200, "should return all 200 records");
for (i, (ts, data)) in entries.iter().enumerate() {
assert_eq!(*ts, i as i64 * 10 + 1);
assert_eq!(data.len(), 4096);
assert!(data.iter().all(|&b| b == 0xAB));
}
}
{
let lock = arc.clone();
let entries = lock.query(501, 1501).unwrap();
assert_eq!(
entries.len(),
101,
"should return 101 records (inclusive range)"
);
for (ts, _) in &entries {
assert!(*ts >= 501 && *ts <= 1501);
}
}
store.close().unwrap();
}
#[test]
fn t33_2_iterator_cross_block() {
use timslite::{Store, StoreConfig};
let dir = temp_dir();
let mut store = Store::open(&dir, StoreConfig::default()).unwrap();
store
.create_dataset(
"cross_block",
"data",
64 * 1024 * 1024,
4 * 1024 * 1024,
6,
0,
0,
)
.unwrap();
let ds = store.open_dataset("cross_block", "data").unwrap();
let arc = ds.clone();
{
let lock = arc.clone();
for i in 0..50i64 {
let data = vec![0xCDu8; 4096]; lock.write(i * 10 + 1, &data).unwrap();
}
}
{
let lock = arc.clone();
let entries = lock.query(1, 501).unwrap();
assert_eq!(entries.len(), 50, "should return all 50 records");
for (i, (ts, data)) in entries.iter().enumerate() {
assert_eq!(*ts, i as i64 * 10 + 1);
assert_eq!(data.len(), 4096);
assert!(data.iter().all(|&b| b == 0xCD));
}
}
{
let lock = arc.clone();
let entries = lock.query(101, 301).unwrap();
assert_eq!(
entries.len(),
21,
"should return 21 records (inclusive range)"
);
for (ts, _) in &entries {
assert!(*ts >= 101 && *ts <= 301);
}
}
store.close().unwrap();
}
#[test]
fn t33_3_iterator_empty_range() {
use timslite::{Store, StoreConfig};
let dir = temp_dir();
let mut store = Store::open(&dir, StoreConfig::default()).unwrap();
store
.create_dataset(
"empty_range",
"data",
64 * 1024 * 1024,
4 * 1024 * 1024,
6,
0,
0,
)
.unwrap();
let ds = store.open_dataset("empty_range", "data").unwrap();
let arc = ds.clone();
{
let lock = arc.clone();
lock.write(100, b"data_100").unwrap();
lock.write(200, b"data_200").unwrap();
lock.write(300, b"data_300").unwrap();
}
{
let lock = arc.clone();
let entries = lock.query(300, 100).unwrap();
assert_eq!(entries.len(), 0, "start > end should return empty");
}
{
let lock = arc.clone();
let entries = lock.query(500, 600).unwrap();
assert_eq!(entries.len(), 0, "range with no data should return empty");
}
store.close().unwrap();
}
#[test]
fn t33_4_iterator_single_record() {
use timslite::{Store, StoreConfig};
let dir = temp_dir();
let mut store = Store::open(&dir, StoreConfig::default()).unwrap();
store
.create_dataset(
"single_rec",
"data",
64 * 1024 * 1024,
4 * 1024 * 1024,
6,
0,
0,
)
.unwrap();
let ds = store.open_dataset("single_rec", "data").unwrap();
let arc = ds.clone();
{
let lock = arc.clone();
lock.write(100, b"only_record").unwrap();
}
{
let lock = arc.clone();
let entries = lock.query(100, 100).unwrap();
assert_eq!(entries.len(), 1);
assert_eq!(entries[0].0, 100);
assert_eq!(entries[0].1, b"only_record");
}
{
let lock = arc.clone();
let entries = lock.query(50, 150).unwrap();
assert_eq!(entries.len(), 1);
assert_eq!(entries[0].0, 100);
}
store.close().unwrap();
}
#[test]
fn query_iter_collect_take_stops_when_iterator_is_exhausted() {
use timslite::{Store, StoreConfig};
let dir = temp_dir();
let mut store = Store::open(&dir, StoreConfig::default()).unwrap();
store
.create_dataset(
"collect_take_short",
"data",
64 * 1024 * 1024,
4 * 1024 * 1024,
6,
0,
0,
)
.unwrap();
let ds = store.open_dataset("collect_take_short", "data").unwrap();
ds.write(1, b"one").unwrap();
ds.write(2, b"two").unwrap();
let records = ds.query_iter(1, 2).unwrap().collect_take(5).unwrap();
assert_eq!(records, vec![(1, b"one".to_vec()), (2, b"two".to_vec())]);
store.close().unwrap();
}
#[test]
fn t33_5_iterator_skip_deleted() {
use timslite::{Store, StoreConfig};
let dir = temp_dir();
let mut store = Store::open(&dir, StoreConfig::default()).unwrap();
store
.create_dataset(
"skip_deleted",
"data",
64 * 1024 * 1024,
4 * 1024 * 1024,
6,
0,
0,
)
.unwrap();
let ds = store.open_dataset("skip_deleted", "data").unwrap();
let arc = ds.clone();
{
let lock = arc.clone();
lock.write(100, b"keep_100").unwrap();
lock.write(200, b"delete_200").unwrap();
lock.write(300, b"keep_300").unwrap();
lock.write(400, b"delete_400").unwrap();
lock.write(500, b"keep_500").unwrap();
}
{
let lock = arc.clone();
lock.delete(200).unwrap();
lock.delete(400).unwrap();
}
{
let lock = arc.clone();
let entries = lock.query(100, 500).unwrap();
assert_eq!(entries.len(), 3, "should return 3 non-deleted records");
let timestamps: Vec<i64> = entries.iter().map(|(ts, _)| *ts).collect();
assert_eq!(timestamps, vec![100, 300, 500]);
}
store.close().unwrap();
}
#[test]
fn t33_6_iterator_correction_writes() {
use timslite::{Store, StoreConfig};
let dir = temp_dir();
let mut store = Store::open(&dir, StoreConfig::default()).unwrap();
store
.create_dataset(
"correction",
"data",
64 * 1024 * 1024,
4 * 1024 * 1024,
6,
0,
0,
)
.unwrap();
let ds = store.open_dataset("correction", "data").unwrap();
let arc = ds.clone();
{
let lock = arc.clone();
lock.write(100, b"original_100").unwrap();
lock.write(200, b"original_200").unwrap();
lock.write(300, b"original_300").unwrap();
}
{
let lock = arc.clone();
lock.write(200, b"corrected_200").unwrap();
}
{
let lock = arc.clone();
let entries = lock.query(100, 300).unwrap();
assert_eq!(entries.len(), 3);
assert_eq!(entries[0].0, 100);
assert_eq!(entries[0].1, b"original_100");
assert_eq!(entries[1].0, 200);
assert_eq!(entries[1].1, b"corrected_200");
assert_eq!(entries[2].0, 300);
assert_eq!(entries[2].1, b"original_300");
}
store.close().unwrap();
}
#[test]
fn t33_7_closed_segment_transparent_reopen() {
use std::time::Duration;
use timslite::{Store, StoreConfig};
let dir = temp_dir();
let config = StoreConfig::builder()
.enable_background_thread(false)
.idle_timeout(Duration::from_millis(50))
.build();
let mut store = Store::open(&dir, config).unwrap();
store
.create_dataset(
"closed_seg",
"data",
64 * 1024 * 1024,
4 * 1024 * 1024,
6,
0,
0,
)
.unwrap();
let ds = store.open_dataset("closed_seg", "data").unwrap();
let arc = ds.clone();
{
let lock = arc.clone();
for i in 0..20i64 {
lock.write(i * 10 + 1, &[0xAA; 256]).unwrap();
}
}
drop(arc);
std::thread::sleep(Duration::from_millis(100));
let _ = store.tick_background_tasks().unwrap();
let arc = ds.clone();
{
let lock = arc.clone();
for i in 20..40i64 {
lock.write(i * 10 + 1, &[0xBB; 256]).unwrap();
}
}
{
let lock = arc.clone();
let entries = lock.query(1, 391).unwrap();
assert_eq!(
entries.len(),
40,
"should return all 40 records after idle-close reopen"
);
for (i, (ts, data)) in entries.iter().enumerate().take(20) {
assert_eq!(*ts, i as i64 * 10 + 1);
assert!(data.iter().all(|&b| b == 0xAA));
}
for (i, (ts, data)) in entries.iter().enumerate().take(40).skip(20) {
assert_eq!(*ts, i as i64 * 10 + 1);
assert!(data.iter().all(|&b| b == 0xBB));
}
}
store.close().unwrap();
}
#[test]
fn t33_8_in_memory_pending_block_query() {
use timslite::{Store, StoreConfig};
let dir = temp_dir();
let mut store = Store::open(&dir, StoreConfig::default()).unwrap();
store
.create_dataset(
"pending_q",
"data",
64 * 1024 * 1024,
4 * 1024 * 1024,
6,
0,
0,
)
.unwrap();
let ds = store.open_dataset("pending_q", "data").unwrap();
let arc = ds.clone();
{
let lock = arc.clone();
for i in 0..10i64 {
lock.write(i * 10 + 1, &[0xCC; 128]).unwrap();
}
lock.flush().unwrap();
}
{
let lock = arc.clone();
for i in 10..20i64 {
lock.write(i * 10 + 1, &[0xDD; 128]).unwrap();
}
}
{
let lock = arc.clone();
let entries = lock.query(1, 191).unwrap();
assert_eq!(
entries.len(),
20,
"query should include both flushed and pending data"
);
for (i, (ts, data)) in entries.iter().enumerate().take(10) {
assert_eq!(*ts, i as i64 * 10 + 1);
assert!(data.iter().all(|&b| b == 0xCC));
}
for (i, (ts, data)) in entries.iter().enumerate().take(20).skip(10) {
assert_eq!(*ts, i as i64 * 10 + 1);
assert!(data.iter().all(|&b| b == 0xDD));
}
}
{
let lock = arc.clone();
let entries = lock.query(101, 191).unwrap();
assert_eq!(
entries.len(),
10,
"query on pending-only range should return 10 records"
);
for (ts, data) in &entries {
assert!(*ts >= 101 && *ts <= 191);
assert!(data.iter().all(|&b| b == 0xDD));
}
}
store.close().unwrap();
}
#[test]
fn t33_9_query_after_data_modification() {
use timslite::{Store, StoreConfig};
let dir = temp_dir();
let mut store = Store::open(&dir, StoreConfig::default()).unwrap();
store
.create_dataset(
"mod_iter",
"data",
64 * 1024 * 1024,
4 * 1024 * 1024,
6,
0,
0,
)
.unwrap();
let ds = store.open_dataset("mod_iter", "data").unwrap();
let arc = ds.clone();
{
let lock = arc.clone();
for i in 0..10i64 {
lock.write(i * 10 + 1, &[0x11; 64]).unwrap();
}
}
{
let lock = arc.clone();
let entries = lock.query(1, 91).unwrap();
assert_eq!(entries.len(), 10, "initial query should return 10 records");
for (i, (ts, data)) in entries.iter().enumerate() {
assert_eq!(*ts, i as i64 * 10 + 1);
assert!(data.iter().all(|&b| b == 0x11));
}
}
{
let lock = arc.clone();
for i in 10..20i64 {
lock.write(i * 10 + 1, &[0x22; 64]).unwrap();
}
}
{
let lock = arc.clone();
let entries = lock.query(1, 191).unwrap();
assert_eq!(
entries.len(),
20,
"second query should return all 20 records"
);
for (i, (ts, data)) in entries.iter().enumerate().take(10) {
assert_eq!(*ts, i as i64 * 10 + 1);
assert!(data.iter().all(|&b| b == 0x11));
}
for (i, (ts, data)) in entries.iter().enumerate().take(20).skip(10) {
assert_eq!(*ts, i as i64 * 10 + 1);
assert!(data.iter().all(|&b| b == 0x22));
}
}
{
let lock = arc.clone();
let entries = lock.query(101, 191).unwrap();
assert_eq!(
entries.len(),
10,
"query on new range should return 10 records"
);
for (ts, data) in &entries {
assert!(*ts >= 101 && *ts <= 191);
assert!(data.iter().all(|&b| b == 0x22));
}
}
store.close().unwrap();
}
#[test]
fn public_query_iter_reads_current_index_entry_after_correction() {
use timslite::{Store, StoreConfig};
let dir = temp_dir();
let config = StoreConfig::builder().enable_journal(false).build();
let mut store = Store::open(&dir, config).unwrap();
store
.create_dataset("ds", "type", 64 * 1024 * 1024, 4 * 1024 * 1024, 6, 0, 0)
.unwrap();
let ds = store.open_dataset("ds", "type").unwrap();
ds.write(1, b"one").unwrap();
ds.write(2, b"old").unwrap();
ds.write(3, b"three").unwrap();
let mut iter = ds.query_iter(1, 3).unwrap();
assert_eq!(iter.next().unwrap().unwrap(), (1, b"one".to_vec()));
ds.write(2, b"corrected").unwrap();
assert_eq!(iter.next().unwrap().unwrap(), (2, b"corrected".to_vec()));
assert_eq!(iter.next().unwrap().unwrap(), (3, b"three".to_vec()));
assert!(iter.next().is_none());
store.close().unwrap();
}
#[test]
fn public_query_iter_skips_entry_deleted_after_iterator_creation() {
use timslite::{Store, StoreConfig};
let dir = temp_dir();
let config = StoreConfig::builder().enable_journal(false).build();
let mut store = Store::open(&dir, config).unwrap();
store
.create_dataset("ds", "type", 64 * 1024 * 1024, 4 * 1024 * 1024, 6, 0, 0)
.unwrap();
let ds = store.open_dataset("ds", "type").unwrap();
ds.write(1, b"one").unwrap();
ds.write(2, b"two").unwrap();
ds.write(3, b"three").unwrap();
let mut iter = ds.query_iter(1, 3).unwrap();
assert_eq!(iter.next().unwrap().unwrap(), (1, b"one".to_vec()));
ds.delete(2).unwrap();
assert_eq!(iter.next().unwrap().unwrap(), (3, b"three".to_vec()));
assert!(iter.next().is_none());
store.close().unwrap();
}
#[test]
fn public_query_iter_reverse_skip_and_collect_take_chain() {
use timslite::{Store, StoreConfig};
let dir = temp_dir();
let config = StoreConfig::builder().enable_journal(false).build();
let mut store = Store::open(&dir, config).unwrap();
store
.create_dataset("ds", "type", 64 * 1024 * 1024, 4 * 1024 * 1024, 6, 1, 0)
.unwrap();
let ds = store.open_dataset("ds", "type").unwrap();
ds.write(10, b"ten").unwrap();
ds.write(20, b"twenty").unwrap();
ds.write(30, b"thirty").unwrap();
ds.write(40, b"forty").unwrap();
ds.write(50, b"fifty").unwrap();
ds.delete(40).unwrap();
let rows = ds
.query_iter(10, 50)
.unwrap()
.reverse()
.skip(1)
.collect_take(2)
.unwrap();
assert_eq!(
rows,
vec![(30, b"thirty".to_vec()), (20, b"twenty".to_vec()),]
);
store.close().unwrap();
}
#[test]
fn public_query_iter_skip_then_reverse_keeps_skip_on_low_side() {
use timslite::{Store, StoreConfig};
let dir = temp_dir();
let config = StoreConfig::builder().enable_journal(false).build();
let mut store = Store::open(&dir, config).unwrap();
store
.create_dataset("ds", "type", 64 * 1024 * 1024, 4 * 1024 * 1024, 6, 1, 0)
.unwrap();
let ds = store.open_dataset("ds", "type").unwrap();
ds.write(10, b"ten").unwrap();
ds.write(20, b"twenty").unwrap();
ds.write(30, b"thirty").unwrap();
ds.write(40, b"forty").unwrap();
let rows = ds
.query_iter(10, 40)
.unwrap()
.skip(1)
.reverse()
.collect_all()
.unwrap();
assert_eq!(
rows,
vec![
(40, b"forty".to_vec()),
(30, b"thirty".to_vec()),
(20, b"twenty".to_vec()),
]
);
store.close().unwrap();
}
#[test]
fn public_query_iter_standard_skip_after_adapter_still_works() {
use timslite::{Store, StoreConfig};
let dir = temp_dir();
let config = StoreConfig::builder().enable_journal(false).build();
let mut store = Store::open(&dir, config).unwrap();
store
.create_dataset("ds", "type", 64 * 1024 * 1024, 4 * 1024 * 1024, 6, 0, 0)
.unwrap();
let ds = store.open_dataset("ds", "type").unwrap();
ds.write(10, b"ten").unwrap();
ds.write(20, b"twenty").unwrap();
ds.write(30, b"thirty").unwrap();
let timestamps = ds
.query_iter(10, 30)
.unwrap()
.map(|row| row.map(|(timestamp, _)| timestamp))
.skip(1)
.collect::<Result<Vec<_>, _>>()
.unwrap();
assert_eq!(timestamps, vec![20, 30]);
store.close().unwrap();
}