From 6673fcfd1177ce19c86f3a0b056629fe11fce81b Mon Sep 17 00:00:00 2001 From: Greg Heartsfield Date: Sat, 1 Jan 2022 18:38:52 -0600 Subject: [PATCH] feat: implement multi-valued filter searching NIP-01 now uses arrays instead of scalars. Fixes https://todo.sr.ht/~gheartsfield/nostr-rs-relay/17 --- src/db.rs | 59 ++++++++++++++++++++++++++++---------------- src/subscription.rs | 60 +++++++++++++++++++++++++++++++-------------- 2 files changed, 80 insertions(+), 39 deletions(-) diff --git a/src/db.rs b/src/db.rs index d6a8adb..e4b3a0a 100644 --- a/src/db.rs +++ b/src/db.rs @@ -302,35 +302,52 @@ fn query_from_sub(sub: &Subscription) -> String { filter_components.push(authors_clause); } // Query for Kind - if f.kind.is_some() { + if let Some(ks) = &f.kinds { // kind is number, no escaping needed - let kind_clause = format!("kind = {}", f.kind.unwrap()); + let str_kinds: Vec = ks.iter().map(|x| x.to_string()).collect(); + let kind_clause = format!("kind IN ({})", str_kinds.join(", ")); filter_components.push(kind_clause); } // Query for event - if f.id.is_some() { - let id_str = f.id.as_ref().unwrap(); - if is_hex(id_str) { - let id_clause = format!("event_hash = x'{}'", id_str); - filter_components.push(id_clause); - } + if f.ids.is_some() { + let ids_escaped: Vec = f + .ids + .as_ref() + .unwrap() + .iter() + .filter(|&x| is_hex(x)) + .map(|x| format!("x'{}'", x)) + .collect(); + let id_clause = format!("event_hash IN ({})", ids_escaped.join(", ")); + filter_components.push(id_clause); } // Query for referenced event - if f.event.is_some() { - let ev_str = f.event.as_ref().unwrap(); - if is_hex(ev_str) { - let ev_clause = format!("referenced_event = x'{}'", ev_str); - filter_components.push(ev_clause); - } + if f.events.is_some() { + let events_escaped: Vec = f + .events + .as_ref() + .unwrap() + .iter() + .filter(|&x| is_hex(x)) + .map(|x| format!("x'{}'", x)) + .collect(); + let events_clause = format!("referenced_event IN ({})", events_escaped.join(", ")); + filter_components.push(events_clause); } - // Query for referenced pet name pubkey - if f.pubkey.is_some() { - let pet_str = f.pubkey.as_ref().unwrap(); - if is_hex(pet_str) { - let pet_clause = format!("referenced_pubkey = x'{}'", pet_str); - filter_components.push(pet_clause); - } + // Query for referenced pubkey + if f.pubkeys.is_some() { + let pubkeys_escaped: Vec = f + .pubkeys + .as_ref() + .unwrap() + .iter() + .filter(|&x| is_hex(x)) + .map(|x| format!("x'{}'", x)) + .collect(); + let pubkeys_clause = format!("referenced_pubkey IN ({})", pubkeys_escaped.join(", ")); + filter_components.push(pubkeys_clause); } + // Query for timestamp if f.since.is_some() { let created_clause = format!("created_at > {}", f.since.unwrap()); diff --git a/src/subscription.rs b/src/subscription.rs index 092dd50..1165d53 100644 --- a/src/subscription.rs +++ b/src/subscription.rs @@ -2,6 +2,7 @@ use crate::error::Result; use crate::event::Event; use serde::{Deserialize, Deserializer, Serialize}; +use std::collections::HashSet; /// Subscription identifier and set of request filters #[derive(Serialize, PartialEq, Debug, Clone)] @@ -17,16 +18,16 @@ pub struct Subscription { /// absent ([`None`]) if it should be ignored. #[derive(Serialize, Deserialize, PartialEq, Debug, Clone)] pub struct ReqFilter { - /// Event hash - pub id: Option, - /// Event kind - pub kind: Option, + /// Event hashes + pub ids: Option>, + /// Event kinds + pub kinds: Option>, /// Referenced event hash #[serde(rename = "#e")] - pub event: Option, + pub events: Option>, /// Referenced public key for a petname #[serde(rename = "#p")] - pub pubkey: Option, + pub pubkeys: Option>, /// Events published after this time pub since: Option, /// Events published before this time @@ -105,8 +106,13 @@ impl Subscription { impl ReqFilter { /// Check for a match within the authors list. - // TODO: Ambiguity; what if the array is empty? Should we - // consider that the same as null? + fn ids_match(&self, event: &Event) -> bool { + self.ids + .as_ref() + .map(|vs| vs.contains(&event.id.to_owned())) + .unwrap_or(true) + } + fn authors_match(&self, event: &Event) -> bool { self.authors .as_ref() @@ -115,29 +121,47 @@ impl ReqFilter { } /// Check if this filter either matches, or does not care about the event tags. fn event_match(&self, event: &Event) -> bool { - self.event - .as_ref() - .map(|t| event.event_tag_match(t)) - .unwrap_or(true) + // This needs to be analyzed for performance; building these + // hash sets for each active subscription isn't great. + if let Some(es) = &self.events { + let event_refs = + HashSet::<_>::from_iter(event.get_event_tags().iter().map(|x| x.to_owned())); + let filter_refs = HashSet::<_>::from_iter(es.iter().map(|x| &x[..])); + let cardinality = event_refs.intersection(&filter_refs).count(); + cardinality > 0 + } else { + true + } } /// Check if this filter either matches, or does not care about /// the pubkey/petname tags. fn pubkey_match(&self, event: &Event) -> bool { - self.pubkey - .as_ref() - .map(|t| event.pubkey_tag_match(t)) - .unwrap_or(true) + // This needs to be analyzed for performance; building these + // hash sets for each active subscription isn't great. + if let Some(ps) = &self.pubkeys { + let pubkey_refs = + HashSet::<_>::from_iter(event.get_pubkey_tags().iter().map(|x| x.to_owned())); + let filter_refs = HashSet::<_>::from_iter(ps.iter().map(|x| &x[..])); + let cardinality = pubkey_refs.intersection(&filter_refs).count(); + cardinality > 0 + } else { + true + } } /// Check if this filter either matches, or does not care about the kind. fn kind_match(&self, kind: u64) -> bool { - self.kind.map(|v| v == kind).unwrap_or(true) + self.kinds + .as_ref() + .map(|ks| ks.contains(&kind)) + .unwrap_or(true) } /// Determine if all populated fields in this filter match the provided event. pub fn interested_in_event(&self, event: &Event) -> bool { - self.id.as_ref().map(|v| v == &event.id).unwrap_or(true) + // self.id.as_ref().map(|v| v == &event.id).unwrap_or(true) + self.ids_match(event) && self.since.map(|t| event.created_at > t).unwrap_or(true) && self.kind_match(event.kind) && self.authors_match(event)