risinglight 0.2.0

An OLAP database system for educational purpose
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

// Copyright 2022 RisingLight Project Authors. Licensed under Apache-2.0.

use async_recursion::async_recursion;
use enum_dispatch::enum_dispatch;

use super::{ConcatIterator, MergeIterator, RowSetIterator};
use crate::array::DataChunk;
use crate::storage::{StorageChunk, StorageResult, TxnIterator};

#[enum_dispatch]
pub enum SecondaryIterator {
    Concat(ConcatIterator),
    Merge(MergeIterator),
    RowSet(RowSetIterator),
    #[cfg(test)]
    Test(super::tests::TestIterator),
}

#[enum_dispatch(SecondaryIterator)]
pub trait SecondaryIteratorImpl {}

/// An iterator over all data in a transaction.
///
/// TODO: Lifetime of the iterator should be bound to the transaction.
/// When the transaction end, accessing items inside iterator is UB.
/// To achieve this, we must enable GAT.
pub struct SecondaryTableTxnIterator {
    iter: SecondaryIterator,
}

impl SecondaryTableTxnIterator {
    pub(super) fn new(iter: SecondaryIterator) -> Self {
        Self { iter }
    }
}

impl SecondaryIterator {
    #[async_recursion]
    pub async fn next_batch(
        &mut self,
        expected_size: Option<usize>,
    ) -> StorageResult<Option<StorageChunk>> {
        match self {
            SecondaryIterator::Concat(iter) => iter.next_batch(expected_size).await,
            SecondaryIterator::Merge(iter) => iter.next_batch(expected_size).await,
            SecondaryIterator::RowSet(iter) => iter.next_batch(expected_size).await,
            #[cfg(test)]
            SecondaryIterator::Test(iter) => iter.next_batch(expected_size).await,
        }
    }
}

impl TxnIterator for SecondaryTableTxnIterator {
    async fn next_batch(
        &mut self,
        expected_size: Option<usize>,
    ) -> StorageResult<Option<DataChunk>> {
        Ok(self
            .iter
            .next_batch(expected_size)
            .await?
            .map(|x| x.to_data_chunk()))
    }
}