native_db_32bit/watch/query/
get.rs

1use crate::db_type::{DatabaseSecondaryKeyOptions, InnerKeyValue, Input, KeyDefinition, Result};
2use crate::watch;
3use crate::watch::query::internal;
4use crate::watch::MpscReceiver;
5
6/// Watch only one value.
7pub struct WatchGet<'db, 'w> {
8    pub(crate) internal: &'w internal::InternalWatch<'db>,
9}
10
11impl WatchGet<'_, '_> {
12    /// Watch the primary key.
13    ///
14    /// Returns a channel receiver and the watcher id.
15    /// The watcher id can be used to unwatch the channel.
16    ///
17    /// # Example
18    /// ```rust
19    /// use native_db::*;
20    /// use native_model::{native_model, Model};
21    /// use serde::{Deserialize, Serialize};
22    ///
23    /// #[derive(Serialize, Deserialize)]
24    /// #[native_model(id=1, version=1)]
25    /// #[native_db]
26    /// struct Data {
27    ///     #[primary_key]
28    ///     id: u64,
29    /// }
30    ///
31    /// fn main() -> Result<(), db_type::Error> {
32    ///     let mut builder = DatabaseBuilder::new();
33    ///     builder.define::<Data>()?;
34    ///     let db = builder.create_in_memory()?;
35    ///     
36    ///     // Watch the primary key
37    ///     let (_recv, _id) = db.watch().get().primary::<Data>(1u64)?;
38    ///     Ok(())
39    /// }
40    /// ```
41    pub fn primary<T: Input>(
42        &self,
43        key: impl InnerKeyValue,
44    ) -> Result<(MpscReceiver<watch::Event>, u64)> {
45        self.internal.watch_primary::<T>(key)
46    }
47
48    /// Watch the secondary key.
49    ///
50    /// Returns a channel receiver and the watcher id.
51    /// The watcher id can be used to unwatch the channel.
52    ///
53    /// # Example
54    /// ```rust
55    /// use native_db::*;
56    /// use native_model::{native_model, Model};
57    /// use serde::{Deserialize, Serialize};
58    ///
59    /// #[derive(Serialize, Deserialize)]
60    /// #[native_model(id=1, version=1)]
61    /// #[native_db]
62    /// struct Data {
63    ///     #[primary_key]
64    ///     id: u64,
65    ///     #[secondary_key]
66    ///    name: String,
67    /// }
68    ///
69    /// fn main() -> Result<(), db_type::Error> {
70    ///     let mut builder = DatabaseBuilder::new();
71    ///     builder.define::<Data>()?;
72    ///     let db = builder.create_in_memory()?;
73    ///     
74    ///     // Watch the secondary key name
75    ///     let (_recv, _id) = db.watch().get().secondary::<Data>(DataKey::name, "test")?;
76    ///     Ok(())
77    /// }
78    /// ```
79    pub fn secondary<T: Input>(
80        &self,
81        key_def: impl KeyDefinition<DatabaseSecondaryKeyOptions>,
82        key: impl InnerKeyValue,
83    ) -> Result<(MpscReceiver<watch::Event>, u64)> {
84        self.internal.watch_secondary::<T>(&key_def, key)
85    }
86}