get any getter for postgres backend

Author: bram209

ormx-macros/src/attrs.rs

@@ -29,6 +29,9 @@ pub enum TableFieldAttr {
     GetOptional(Getter),
     // get_many [= <ident>]? [(<type>)]?
     GetMany(Getter),
+    // get_many [= <ident>]? [(<type>)]?
+    #[cfg(feature = "postgres")]
+    GetAny(Getter),
     // set [= <ident>]?
     Set(Option<Ident>),
 }
@@ -95,14 +98,16 @@ pub fn parse_attrs<A: Parse>(attrs: &[Attribute]) -> Result<Vec<A>> {
 macro_rules! impl_parse {
     // entry point
     ($i:ident {
-        $( $s:literal => $v:ident( $($t:tt)* ) ),*
+        $( $(#[cfg($cfg_attr: meta)])? $s:literal => $v:ident( $($t:tt)* ) ),*
     }) => {
         impl syn::parse::Parse for $i {
             #[allow(clippy::redundant_closure_call)]
             fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
                 let ident = input.parse::<syn::Ident>()?;
                 match &*ident.to_string() {
-                    $( $s => (impl_parse!($($t)*))(input).map(Self::$v), )*
+                    $(
+                        $(#[cfg($cfg_attr)])?
+                        $s => (impl_parse!($($t)*))(input).map(Self::$v), )*
                     _ => Err(input.error("unknown attribute"))
                 }
             }
@@ -141,6 +146,8 @@ impl_parse!(TableFieldAttr {
     "get_one" => GetOne(Getter),
     "get_optional" => GetOptional(Getter),
     "get_many" => GetMany(Getter),
+    #[cfg(feature = "postgres")]
+    "get_any" => GetAny(Getter),
     "set" => Set((= Ident)?),
     "custom_type" => CustomType(),
     "default" => Default()

ormx-macros/src/backend/postgres/get_any.rs

@@ -0,0 +1,41 @@
+use crate::{
+    backend::{common, postgres::PgBindings},
+    table::Table,
+};
+
+use super::PgBackend;
+use proc_macro2::TokenStream;
+use quote::quote;
+
+pub(crate) fn impl_get_any_getter(table: &Table<PgBackend>) -> TokenStream {
+    let column_list = table.select_column_list();
+    let vis = &table.vis;
+    let mut getters = TokenStream::new();
+
+    for field in table.fields.iter() {
+        if let Some(getter) = &field.get_any {
+            let sql = format!(
+                "SELECT {} FROM {} WHERE {} = ANY({})",
+                column_list,
+                table.table,
+                field.column(),
+                PgBindings::default().next().unwrap()
+            );
+
+            let func = getter.ident_or_fallback(&field);
+            let arg = getter.arg_ty.clone().unwrap_or_else(|| {
+                let ty = &field.ty;
+                syn::parse2(quote!(&[#ty])).unwrap()
+            });
+
+            getters.extend(common::get_many(vis, &func, &arg, &sql));
+        }
+    }
+
+    let table_ident = &table.ident;
+    quote! {
+        impl #table_ident {
+            #getters
+        }
+    }
+}

ormx-macros/src/backend/postgres/mod.rs

@@ -5,6 +5,11 @@ use proc_macro2::TokenStream;
 use crate::backend::Backend;
 use crate::table::Table;
 
+use self::get_any::impl_get_any_getter;
+
+use super::common;
+
+mod get_any;
 mod insert;
 
 #[derive(Clone)]
@@ -32,6 +37,12 @@ impl Backend for PgBackend {
     fn impl_insert(table: &Table<Self>) -> TokenStream {
         insert::impl_insert(table)
     }
+
+    fn impl_getters(table: &Table<Self>) -> TokenStream {
+        let mut getters = common::getters::<Self>(table);
+        getters.extend(impl_get_any_getter(table));
+        getters
+    }
 }
 
 #[derive(Default)]

ormx-macros/src/table/mod.rs

@@ -32,6 +32,8 @@ pub struct TableField<B: Backend> {
     pub get_one: Option<Getter>,
     pub get_optional: Option<Getter>,
     pub get_many: Option<Getter>,
+    #[cfg(feature = "postgres")]
+    pub get_any: Option<Getter>,
     pub set: Option<Ident>,
     pub _phantom: PhantomData<*const B>,
 }
@@ -86,16 +88,19 @@ impl<B: Backend> TableField<B> {
 
 impl Getter {
     pub fn or_fallback<B: Backend>(&self, field: &TableField<B>) -> (Ident, Type) {
-        let ident = self
-            .func
-            .clone()
-            .unwrap_or_else(|| Ident::new(&format!("by_{}", field.field), Span::call_site()));
+        let ident = self.ident_or_fallback(field);
         let arg = self.arg_ty.clone().unwrap_or_else(|| {
             let ty = &field.ty;
             syn::parse2(quote!(&#ty)).unwrap()
         });
         (ident, arg)
     }
+
+    pub fn ident_or_fallback<B: Backend>(&self, field: &TableField<B>) -> Ident {
+        self.func
+            .clone()
+            .unwrap_or_else(|| Ident::new(&format!("by_{}", field.field), Span::call_site()))
+    }
 }
 
 pub fn derive(input: DeriveInput) -> Result<TokenStream> {

ormx-macros/src/table/parse.rs

@@ -38,13 +38,18 @@ impl<B: Backend> TryFrom<&syn::Field> for TableField<B> {
             default
         );
 
+        #[cfg(feature = "postgres")]
+        none!(get_any);
+
         for attr in parse_attrs::<TableFieldAttr>(&value.attrs)? {
             match attr {
                 TableFieldAttr::Column(c) => set_once(&mut column, c)?,
                 TableFieldAttr::CustomType(..) => set_once(&mut custom_type, true)?,
                 TableFieldAttr::GetOne(g) => set_once(&mut get_one, g)?,
                 TableFieldAttr::GetOptional(g) => set_once(&mut get_optional, g)?,
                 TableFieldAttr::GetMany(g) => set_once(&mut get_many, g)?,
+                #[cfg(feature = "postgres")]
+                TableFieldAttr::GetAny(g) => set_once(&mut get_any, g)?,
                 TableFieldAttr::Set(s) => {
                     let default = || Ident::new(&format!("set_{}", ident), Span::call_site());
                     set_once(&mut set, s.unwrap_or_else(default))?
@@ -62,6 +67,8 @@ impl<B: Backend> TryFrom<&syn::Field> for TableField<B> {
             get_one,
             get_optional,
             get_many,
+            #[cfg(feature = "postgres")]
+            get_any,
             set,
             _phantom: PhantomData,
         })