Struct holochain_zome_types::query::ChainQueryFilter

source ·

pub struct ChainQueryFilter {
    pub sequence_range: ChainQueryFilterRange,
    pub entry_type: Option<EntryType>,
    pub entry_hashes: Option<HashSet<EntryHash>>,
    pub action_type: Option<ActionType>,
    pub include_entries: bool,
    pub order_descending: bool,
}

Expand description

Specifies arguments to a query of the source chain, including ordering and filtering.

This struct is used to construct an actual SQL query on the database, and also has methods to allow filtering in-memory.

Fields§

§sequence_range: ChainQueryFilterRange

Limit the results to a range of records according to their actions.

§entry_type: Option<EntryType>

Filter by EntryType

§entry_hashes: Option<HashSet<EntryHash>>

Filter by a list of EntryHash.

§action_type: Option<ActionType>

Filter by ActionType

§include_entries: bool

Include the entries in the records

§order_descending: bool

The query should be ordered in descending order (default is ascending), when run as a database query. There is no provisioning for in-memory ordering.

Implementations§

source §

impl ChainQueryFilter

source

pub fn new() -> Self

Create a no-op ChainQueryFilter which returns everything.

source

pub fn sequence_range(self, sequence_range: ChainQueryFilterRange) -> Self

Filter on sequence range.

source

pub fn entry_type(self, entry_type: EntryType) -> Self

Filter on entry type.

source

pub fn entry_hashes(self, entry_hashes: HashSet<EntryHash>) -> Self

Filter on entry hashes.

source

pub fn action_type(self, action_type: ActionType) -> Self

Filter on action type.

source

pub fn include_entries(self, include_entries: bool) -> Self

Include the entries in the RecordsVec that is returned.

source

pub fn ascending(self) -> Self

Set the order to ascending.

source

pub fn descending(self) -> Self

Set the order to ascending.

source

pub fn disambiguate_forks(&self, actions: Vec<ActionHashed>) -> Vec<ActionHashed> ⓘ

If the sequence range supports fork disambiguation, apply it to remove actions that are not in the correct branch. Numerical range bounds do NOT support fork disambiguation, and neither does unbounded, but everything hash bounded does.

Examples found in repository ?

src/query.rs (line 287)

    pub fn filter_actions(&self, actions: Vec<ActionHashed>) -> Vec<ActionHashed> {
        self.disambiguate_forks(actions)
            .into_iter()
            .filter(|action| {
                self.action_type
                    .as_ref()
                    .map(|action_type| action.action_type() == *action_type)
                    .unwrap_or(true)
                    && self
                        .entry_type
                        .as_ref()
                        .map(|entry_type| action.entry_type() == Some(entry_type))
                        .unwrap_or(true)
                    && self
                        .entry_hashes
                        .as_ref()
                        .map(|entry_hashes| match action.entry_hash() {
                            Some(entry_hash) => entry_hashes.contains(entry_hash),
                            None => false,
                        })
                        .unwrap_or(true)
            })
            .collect()
    }

source

pub fn filter_actions(&self, actions: Vec<ActionHashed>) -> Vec<ActionHashed> ⓘ

Filter a vector of hashed actions according to the query.

Examples found in repository ?

src/query.rs (lines 313-318)

    pub fn filter_records(&self, records: Vec<Record>) -> Vec<Record> {
        let actions = self.filter_actions(
            records
                .iter()
                .map(|record| record.action_hashed().clone())
                .collect(),
        );
        let action_hashset = actions
            .iter()
            .map(|action| action.as_hash().clone())
            .collect::<HashSet<ActionHash>>();
        records
            .into_iter()
            .filter(|record| action_hashset.contains(record.action_address()))
            .collect()
    }

source