{inclusive,exclusive}_null.rs

fn cursor_inclusive_null() -> Result<(), Failed> {
    let rt = Builder::new_current_thread().build()?;

    let fdb_database_ref = unsafe { FDB_DATABASE.as_ref().unwrap() };

    rt.block_on({
        let fdb_database = fdb_database_ref.clone();
        async move {
            fdb_database
                .read(|tr| async move {
                    let kv_cursor = {
                        let mut kv_cursor_builder = KeyValueCursorBuilder::new();

                        kv_cursor_builder
                            .subspace(Subspace::new(Bytes::new()).subspace(&{
                                let tup: (&str, &str) = ("sub", "space");

                                let mut t = Tuple::new();
                                t.push_back::<String>(tup.0.to_string());
                                t.push_back::<String>(tup.1.to_string());
                                t
                            }))
                            .key_range({
                                // (4,)..=(Null,)
                                TupleRange::new(
                                    TupleLowEndpoint::RangeInclusive({
                                        let tup: (i8,) = (4,);

                                        let mut t = Tuple::new();
                                        t.push_back::<i8>(tup.0);
                                        t
                                    }),
                                    TupleHighEndpoint::RangeInclusive({
                                        let tup: (Null,) = (Null,);

                                        let mut t = Tuple::new();
                                        t.push_back::<Null>(tup.0);
                                        t
                                    }),
                                )
                                .into_key_range(&None)
                            })
                            .scan_properties(ScanPropertiesBuilder::default().build());

                        kv_cursor_builder.build(&tr)
                    }?;

                    let (kvs_tup, err) = kv_cursor
                        .map(|kv| async {
                            let (key, value) = kv.into_parts();

                            // We expect a proper `Tuple`.
                            let key_tup = Tuple::try_from(key).unwrap();
                            let value_tup = Tuple::try_from(value).unwrap();

                            (key_tup, value_tup)
                        })
                        .await
                        .collect()
                        .await;

                    let iter = (0..5).zip(kvs_tup);

                    for (j, (key_tup, value_tup)) in iter {
                        let tuple = {
                            let tup: (i8, i8) = (4, j);

                            let mut t = Tuple::new();
                            t.push_back::<i8>(tup.0);
                            t.push_back::<i8>(tup.1);
                            t
                        };

                        assert_eq!(tuple, key_tup);
                        assert_eq!(tuple, value_tup);
                    }

                    assert!(matches!(
                        err,
                        CursorError::NoNextReason(NoNextReason::SourceExhausted(_))
                    ));

                    if let CursorError::NoNextReason(NoNextReason::SourceExhausted(continuation)) =
                        err
                    {
                        assert!(continuation.is_end_marker());
                    }

                    Ok(())
                })
                .await?;

            Result::<(), Box<dyn Error>>::Ok(())
        }
    })?;

    Ok(())
}

fn cursor_exclusive_null() -> Result<(), Failed> {
    let rt = Builder::new_current_thread().build()?;

    let fdb_database_ref = unsafe { FDB_DATABASE.as_ref().unwrap() };

    rt.block_on({
        let fdb_database = fdb_database_ref.clone();
        async move {
            fdb_database
                .read(|tr| async move {
                    let kv_cursor = {
                        let mut kv_cursor_builder = KeyValueCursorBuilder::new();

                        kv_cursor_builder
                            .subspace(Subspace::new(Bytes::new()).subspace(&{
                                let tup: (&str, &str) = ("sub", "space");

                                let mut t = Tuple::new();
                                t.push_back::<String>(tup.0.to_string());
                                t.push_back::<String>(tup.1.to_string());
                                t
                            }))
                            .key_range({
                                // (4, 0){exclusive}..(Null,)
                                TupleRange::new(
                                    TupleLowEndpoint::RangeExclusive({
                                        let tup: (i8, i8) = (4, 0);

                                        let mut t = Tuple::new();
                                        t.push_back::<i8>(tup.0);
                                        t.push_back::<i8>(tup.1);
                                        t
                                    }),
                                    TupleHighEndpoint::RangeInclusive({
                                        let tup: (Null,) = (Null,);

                                        let mut t = Tuple::new();
                                        t.push_back::<Null>(tup.0);
                                        t
                                    }),
                                )
                                .into_key_range(&None)
                            })
                            .scan_properties(ScanPropertiesBuilder::default().build());

                        kv_cursor_builder.build(&tr)
                    }?;

                    let (kvs, err) = kv_cursor.collect().await;

                    assert_eq!(0, kvs.len());

                    assert!(matches!(
                        err,
                        CursorError::NoNextReason(NoNextReason::SourceExhausted(_))
                    ));

                    if let CursorError::NoNextReason(NoNextReason::SourceExhausted(continuation)) =
                        err
                    {
                        assert!(continuation.is_end_marker());
                    }

                    Ok(())
                })
                .await?;

            Result::<(), Box<dyn Error>>::Ok(())
        }
    })?;

    Ok(())
}