impl encode & decode for HashSet<E> where you can encode [E]

[Twister915]

Desired behavior:

fn do_something(
    pool: PgPool,
    except: HashSet<String>,
) -> impl TryStream<Ok = sqlx::postgres::PgRow, Error = sqlx::Error> {
    sqlx::query(
        "SELECT c0.target_id AS id FROM connections c0 \
        WHERE NOT c0.target_id = ANY($1)",
    )
    .bind(except)
    .fetch(&pool)
}

Problem:

The Decode, Encode, and Type trait is not implemented for the HashSet collection, even though [E] in this case (String) could be encoded or decoded.

It should be possible to implement these interfaces for all iterable types, so perhaps that should be done instead (wherever impl IntoIter)?

[abonander]

We could add something like

fn bind_array<T, I>(&mut self, array: I) -> &mut Self where I: IntoIterator<Item = T>, T: Encode<Postgres>

to Query/QueryAs specifically for Postgres but I'm not sure how I would translate this to the macros (we can address that down the road though).

If we tried to just implement Decode/Encode/Type for anything that implements IntoIterator we would most likely run into overlapping impl errors. It would require specialization to implement it how you expect.

Adding specific impls for BTreeSet<T> or HashSet<T> aren't out of the question though.

[abonander]

Alternatively, we could provide an adaptor type that should slot into the macros a lot easier, e.g.:

/// Encode/decode any iterable type as an array.
pub struct PgArray<I>(pub I);

impl<I> Type<Postgres> for PgArray<I> where I: IntoIterator, I::Item: Type<Postgres> {
    // ..
}

impl<I> Encode<Postgres> for PgArray<I> where I: IntoIterator, I::Item: Type<Postgres> {
    // ..
}

impl<I, T> Decode<Postgres> for PgArray<I> where I: Default + Extend<T>, T: Type<Postgres> {
    // ...
}

Then for the macros you could select any column as "my_array: PgArray<HashSet<String>>" and pass PgArray(&hash_set): _ as a bind parameter.

[folex]

Hello!

What would be the most elegant way to use query_as! macro to decode into a structure with a field of HashSet type?

Is there anything simpler than creating a newtype around HashSet and implementing sqlx::Decode for it?

My use case is the following:

pub struct ApiKey {
    pub user_id: Uuid,
    pub hash: String,
    pub scopes: HashSet<PermissionScope>,
}

select user_id, api_key_hash as hash, scopes as "scopes: HashSet<PermissionScope>" 
from api_keys where api_key_hash = $1

---

P.S. Here's my humble implementation of the newtype approach in case anyone needs it

Rust implementation

PermissionSet

use std::collections::HashSet;

use sqlx::encode::IsNull;
use sqlx::error::BoxDynError;
use sqlx::postgres::PgArgumentBuffer;
use sqlx::{Database, Decode, Encode, Postgres, Type};

#[derive(Debug, Clone, Copy, Serialize, Deserialize, sqlx::Type, Eq, PartialEq, Hash)]
#[sqlx(type_name = "PermissionScope")]
pub enum PermissionScope {
    #[serde(rename = "api_key:create")]
    #[sqlx(rename = "api_key:create")]
    ApiKeyCreate,
    #[serde(rename = "api_key:remove")]
    #[sqlx(rename = "api_key:remove")]
    ApiKeyRemove,
}

#[derive(Debug, PartialEq, Eq)]
pub struct PermissionSet(HashSet<PermissionScope>);

impl PermissionSet {
    pub fn new<I: IntoIterator<Item = PermissionScope>>(scopes: I) -> Self {
        Self(HashSet::from_iter(scopes))
    }

    /// Return true if the PermissionSet has all the required permissions
    pub fn has_permissions(&self, permissions: &HashSet<PermissionScope>) -> bool {
        let mut diff = permissions.difference(&self.0);
        let is_empty = diff.next().is_none();

        return is_empty;
    }
}

/// Decode as Vec
impl<'r, DB: Database> Decode<'r, DB> for PermissionSet
where
    Vec<PermissionScope>: Decode<'r, DB>,
{
    fn decode(value: <DB as Database>::ValueRef<'r>) -> Result<Self, BoxDynError> {
        let vec = <Vec<PermissionScope> as Decode<DB>>::decode(value)?;
        let hash_set = HashSet::from_iter(vec);
        Ok(PermissionSet(hash_set))
    }
}

/// Encode as Vec
impl<'r> Encode<'r, Postgres> for PermissionSet
where
    Vec<PermissionScope>: Encode<'r, Postgres>,
{
    fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, BoxDynError> {
        let vec = self.0.iter().collect::<Vec<_>>();
        vec.encode_by_ref(buf)
    }
}

impl<DB: Database> Type<DB> for PermissionSet
where
    Vec<PermissionScope>: Type<DB>,
{
    fn type_info() -> DB::TypeInfo {
        <Vec<PermissionScope> as Type<DB>>::type_info()
    }
}

Usage

use sqlx::types::Uuid;
use sqlx::PgPool;

use crate::permissions::PermissionSet;
use crate::storage::{StorageError, User};

pub struct ApiKey {
    pub user_id: Uuid,
    pub hash: String,
    pub scopes: PermissionSet,
}

pub async fn store_api_key(db: &PgPool, key: ApiKey) -> Result<(), StorageError> {
    sqlx::query!(
        // language=PostgreSQL
        r#"
            insert into "api_keys" (user_id, api_key_hash, scopes)
            values ($1, $2, $3)
        "#,
        key.user_id,
        key.hash,
        key.scopes as PermissionSet
    )
    .execute(db)
    .await
    .map_err(StorageError::SqlxWriteError)?;

    Ok(())
}

pub async fn get_api_key(db: &PgPool, api_key_hash: &str) -> Result<Option<ApiKey>, StorageError> {
    sqlx::query_as!(
        ApiKey,
        // language=PostgreSQL
        r#"
            select user_id, api_key_hash as hash, scopes as "scopes: PermissionSet" from api_keys where api_key_hash = $1
        "#,
        api_key_hash
    )
    .fetch_optional(db)
    .await
    .map_err(StorageError::SqlxReadError)
}

[ivan770]

Since Encode::encode_by_ref limits the scope of acceptable iterators to those, which can be instantiated from the reference to a different value, sqlx could include a type similar to the previously described PgArray<I>, but that accepts a reference to the value in the form of pub struct PgArray<'a, I>(pub &'a I);

The impl block, in turn, would look like this:

impl<'a, 'q, I, T> Encode<'q, Postgres> for PgArray<'a, I>
where
    &'a I: IntoIterator<Item = T>,
    T: Encode<'q, Postgres> + Type<Postgres>
{
    // ...
}

While that would not accept just any I: IntoIterator<Item = T> (for such implementation, encode_by_ref would need to be entirely replaced with encode), it would still accept slices, maps, sets from std.