Fix clippy nits.

microrm-macros/src/entity.rs

@@ -32,11 +32,11 @@ pub fn derive(tokens: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let make_part_list = |plist: &Vec<_>| match plist.len() {
         0 => quote! { () },
         1 => {
-            let ty = make_combined_name(&plist.first().as_ref().unwrap());
+            let ty = make_combined_name(plist.first().as_ref().unwrap());
             quote! { #ty }
         }
         _ => {
-            let tys = plist.iter().map(|part| make_combined_name(&part));
+            let tys = plist.iter().map(make_combined_name);
             quote! { ( #(#tys),* ) }
         }
     };
@@ -59,11 +59,11 @@ pub fn derive(tokens: proc_macro::TokenStream) -> proc_macro::TokenStream {
         .collect::<Vec<_>>();
 
     let part_defs = parts.iter().map(|part| {
-        let part_combined_name = make_combined_name(&part);
+        let part_combined_name = make_combined_name(part);
         let part_base_name = &part.0.to_string();
         let part_type = &part.1;
 
-        let placeholder = format!("${}_{}", entity_ident.to_string(), part_base_name);
+        let placeholder = format!("${}_{}", entity_ident, part_base_name);
 
         let unique = unique_parts.iter().any(|p| p.0 == part.0);
 
@@ -87,14 +87,14 @@ pub fn derive(tokens: proc_macro::TokenStream) -> proc_macro::TokenStream {
     });
 
     let part_visit = parts.iter().map(|part| {
-        let part_combined_name = make_combined_name(&part);
+        let part_combined_name = make_combined_name(part);
         quote! {
             v.visit::<#part_combined_name>();
         }
     });
 
     let part_ref_visit = parts.iter().map(|part| {
-        let part_combined_name = make_combined_name(&part);
+        let part_combined_name = make_combined_name(part);
         let field = &part.0;
         quote! {
             v.visit_datum::<#part_combined_name>(&self.#field);
@@ -102,7 +102,7 @@ pub fn derive(tokens: proc_macro::TokenStream) -> proc_macro::TokenStream {
     });
 
     let part_names = parts.iter().map(|part| {
-        let part_combined_name = make_combined_name(&part);
+        let part_combined_name = make_combined_name(part);
         let part_camel_name = format_ident!("{}", part.0.to_string().to_case(Case::UpperCamel));
         quote! {
             pub const #part_camel_name : #part_combined_name = #part_combined_name;

microrm/src/db.rs

@@ -40,6 +40,19 @@ pub struct Connection {
     statement_cache: Mutex<HashMap<u64, CachedStatement>>,
 }
 
+/*
+#[cfg(test)]
+mod sendsync_check {
+    struct CheckSend<T: Send>(std::marker::PhantomData<T>);
+    struct CheckSync<T: Send>(std::marker::PhantomData<T>);
+
+    #[test]
+    fn check_send() {
+        let cs = CheckSend::<super::DBConnection>(Default::default());
+    }
+}
+*/
+
 impl Connection {
     pub fn open<U: AsRef<str>>(uri: U) -> Result<DBConnection, DBError> {
         match sqlite::Connection::open_thread_safe_with_flags(

microrm/src/query.rs

@@ -1,11 +1,11 @@
 use crate::db::DBConnection;
 use crate::schema::entity::helpers::check_assoc;
 use crate::schema::{AssocData, IDWrap, LocalSide};
+use crate::DBResult;
 use crate::{
-    schema::datum::{Datum, DatumList, DatumVisitor},
+    schema::datum::{Datum, DatumList},
     schema::entity::{Entity, EntityID, EntityPart, EntityPartList, EntityPartVisitor},
 };
-use crate::{DBError, DBResult};
 use std::collections::HashMap;
 use std::hash::{Hash, Hasher};
 
@@ -17,8 +17,6 @@ pub(crate) fn insert<E: Entity>(conn: &DBConnection, value: E) -> DBResult<E::ID
     conn.with_prepared(
         std::any::TypeId::of::<InsertQuery<E>>(),
         || {
-            let table_name = format!("{}", E::entity_name());
-
             let mut part_names = String::new();
             let mut placeholders = String::new();
             struct PartNameVisitor<'a>(&'a mut String, &'a mut String);
@@ -30,14 +28,14 @@ pub(crate) fn insert<E: Entity>(conn: &DBConnection, value: E) -> DBResult<E::ID
                         return;
                     }
 
-                    if self.0.len() != 0 {
+                    if !self.0.is_empty() {
                         self.0.push_str(", ");
                         self.1.push_str(", ");
                     }
-                    self.0.push_str("`");
+                    self.0.push('`');
                     self.0.push_str(EP::part_name());
-                    self.0.push_str("`");
-                    self.1.push_str("?");
+                    self.0.push('`');
+                    self.1.push('?');
                 }
             }
 
@@ -45,7 +43,9 @@ pub(crate) fn insert<E: Entity>(conn: &DBConnection, value: E) -> DBResult<E::ID
 
             format!(
                 "INSERT INTO `{}` ({}) VALUES ({}) RETURNING `id`",
-                table_name, part_names, placeholders
+                E::entity_name(),
+                part_names,
+                placeholders
             )
         },
         |prepared| {
@@ -115,14 +115,10 @@ impl Query {
 
         let columns_ = match self.parts.remove(&QueryPart::Columns) {
             None => String::new(),
-            Some(v) => {
-                format!(
-                    "{}",
-                    v.into_iter()
-                        .reduce(|a, b| format!("{}, {}", a, b))
-                        .unwrap()
-                )
-            }
+            Some(v) => v
+                .into_iter()
+                .reduce(|a, b| format!("{}, {}", a, b))
+                .unwrap(),
         };
 
         let from_ = match self.parts.remove(&QueryPart::From) {
@@ -172,12 +168,7 @@ impl Query {
 
         let trailing_ = match self.parts.remove(&QueryPart::Trailing) {
             None => String::new(),
-            Some(v) => {
-                format!(
-                    "{}",
-                    v.into_iter().reduce(|a, b| format!("{} {}", a, b)).unwrap()
-                )
-            }
+            Some(v) => v.into_iter().reduce(|a, b| format!("{} {}", a, b)).unwrap(),
         };
 
         /*println!(
@@ -259,7 +250,7 @@ pub trait AssocInterface: 'static {
         Self: Sized,
     {
         let adata = self.get_data()?;
-        let an = AssocNames::collect::<Self>(&self)?;
+        let an = AssocNames::collect::<Self>(self)?;
 
         // second, add to the assoc table
         adata.conn.with_prepared(
@@ -289,7 +280,7 @@ pub trait AssocInterface: 'static {
         Self: Sized,
     {
         let adata = self.get_data()?;
-        let an = AssocNames::collect::<Self>(&self)?;
+        let an = AssocNames::collect::<Self>(self)?;
 
         // second, add to the assoc table
         adata.conn.with_prepared(

microrm/src/query/components.rs

@@ -8,7 +8,6 @@ use crate::{
         entity::{Entity, EntityPart, EntityPartList, EntityPartVisitor},
         DatumDiscriminator, IDMap, IDWrap,
     },
-    DBResult,
 };
 
 use super::Query;
@@ -59,10 +58,6 @@ impl<'a, AI: AssocInterface> Queryable for AssocQueryable<'a, AI> {
     type StaticVersion = AssocQueryable<'static, AI>;
 
     fn build(&self) -> Query {
-        let adata = self
-            .assoc
-            .get_data()
-            .expect("building query for assoc with no data");
         let anames = super::AssocNames::collect(self.assoc).unwrap();
         let assoc_name = anames.assoc_name();
         Query::new()
@@ -105,7 +100,7 @@ pub(crate) struct WithComponent<'a, WEP: EntityPart, Parent: Queryable> {
 }
 
 impl<'a, WEP: EntityPart, Parent: Queryable> WithComponent<'a, WEP, Parent> {
-    pub fn new(parent: Parent, part: WEP, datum: &'a WEP::Datum) -> Self {
+    pub fn new(parent: Parent, _part: WEP, datum: &'a WEP::Datum) -> Self {
         Self {
             datum,
             parent,

microrm/src/schema.rs

@@ -44,10 +44,6 @@ impl<T: Entity> IDWrap<T> {
         self.id
     }
 
-    pub fn as_ref(&self) -> &T {
-        &self.wrap
-    }
-
     pub fn wrapped(self) -> T {
         self.wrap
     }
@@ -190,13 +186,13 @@ impl<T: Entity> Datum for AssocMap<T> {
         d.visit_assoc_map::<T>();
     }
 
-    fn bind_to<'a>(&self, _stmt: &mut sqlite::Statement<'a>, _index: usize) {
+    fn bind_to(&self, _stmt: &mut sqlite::Statement, _index: usize) {
         unreachable!()
     }
 
-    fn build_from<'a>(
+    fn build_from(
         adata: AssocData,
-        _stmt: &mut sqlite::Statement<'a>,
+        _stmt: &mut sqlite::Statement,
         index: usize,
     ) -> DBResult<(Self, usize)>
     where
@@ -273,13 +269,13 @@ impl<R: Relation> Datum for AssocDomain<R> {
         d.visit_assoc_domain::<R>();
     }
 
-    fn bind_to<'a>(&self, _stmt: &mut sqlite::Statement<'a>, _index: usize) {
+    fn bind_to(&self, _stmt: &mut sqlite::Statement, _index: usize) {
         unreachable!()
     }
 
-    fn build_from<'a>(
+    fn build_from(
         adata: AssocData,
-        _stmt: &mut sqlite::Statement<'a>,
+        _stmt: &mut sqlite::Statement,
         index: usize,
     ) -> DBResult<(Self, usize)>
     where
@@ -356,13 +352,13 @@ impl<R: Relation> Datum for AssocRange<R> {
         d.visit_assoc_range::<R>();
     }
 
-    fn bind_to<'a>(&self, _stmt: &mut sqlite::Statement<'a>, _index: usize) {
+    fn bind_to(&self, _stmt: &mut sqlite::Statement, _index: usize) {
         unreachable!()
     }
 
-    fn build_from<'a>(
+    fn build_from(
         adata: AssocData,
-        _stmt: &mut sqlite::Statement<'a>,
+        _stmt: &mut sqlite::Statement,
         index: usize,
     ) -> DBResult<(Self, usize)>
     where
@@ -416,7 +412,7 @@ impl<T: 'static + serde::Serialize + serde::de::DeserializeOwned> Datum for Seri
         "text"
     }
 
-    fn bind_to<'a>(&self, stmt: &mut sqlite::Statement<'a>, index: usize) {
+    fn bind_to(&self, stmt: &mut sqlite::Statement, index: usize) {
         <String as Datum>::bind_to(
             &serde_json::to_string(&self.wrapped).expect("couldn't serialize object into JSON"),
             stmt,
@@ -424,9 +420,9 @@ impl<T: 'static + serde::Serialize + serde::de::DeserializeOwned> Datum for Seri
         )
     }
 
-    fn build_from<'a>(
+    fn build_from(
         adata: AssocData,
-        stmt: &mut sqlite::Statement<'a>,
+        stmt: &mut sqlite::Statement,
         index: usize,
     ) -> DBResult<(Self, usize)>
     where
@@ -434,7 +430,7 @@ impl<T: 'static + serde::Serialize + serde::de::DeserializeOwned> Datum for Seri
     {
         let (s, idx) = <String as Datum>::build_from(adata, stmt, index)?;
 
-        let d = serde_json::from_str::<T>(s.as_str()).map_err(|e| DBError::JSON(e))?;
+        let d = serde_json::from_str::<T>(s.as_str()).map_err(DBError::JSON)?;
 
         Ok((Self { wrapped: d }, idx))
     }

microrm/src/schema/build.rs

@@ -147,14 +147,14 @@ pub(crate) fn collect_from_database<DB: Database>() -> DatabaseSchema {
                     assoc_table.dependencies.push(range_name.to_string());
 
                     assoc_table.columns.push(ColumnInfo {
-                        name: "domain".into(),
+                        name: "domain",
                         ty: "int".into(),
                         fkey: Some(format!("`{}`(`id`)", table_name)),
                         unique: false,
                     });
 
                     assoc_table.columns.push(ColumnInfo {
-                        name: "range".into(),
+                        name: "range",
                         ty: "int".into(),
                         fkey: Some(format!("`{}`(`id`)", range_name)),
                         unique: false,
@@ -171,14 +171,14 @@ pub(crate) fn collect_from_database<DB: Database>() -> DatabaseSchema {
                     assoc_table.dependencies.push(domain_name.to_string());
 
                     assoc_table.columns.push(ColumnInfo {
-                        name: "domain".into(),
+                        name: "domain",
                         ty: "int".into(),
                         fkey: Some(format!("`{}`(`id`)", domain_name)),
                         unique: false,
                     });
 
                     assoc_table.columns.push(ColumnInfo {
-                        name: "range".into(),
+                        name: "range",
                         ty: "int".into(),
                         fkey: Some(format!("`{}`(`id`)", table_name)),
                         unique: false,
@@ -212,7 +212,7 @@ pub(crate) fn collect_from_database<DB: Database>() -> DatabaseSchema {
 
     loop {
         let mut table_list = tsort.pop_all();
-        if table_list.len() == 0 {
+        if table_list.is_empty() {
             break;
         }
         // bring into stable ordering
@@ -228,7 +228,7 @@ pub(crate) fn collect_from_database<DB: Database>() -> DatabaseSchema {
         }
     }
 
-    if tsort.len() > 0 {
+    if !tsort.is_empty() {
         panic!("Cycle detected in dependency keys!")
     }
 

microrm/src/schema/datum.rs

@@ -16,10 +16,10 @@ mod datum_list;
 pub trait Datum {
     fn sql_type() -> &'static str;
 
-    fn bind_to<'a>(&self, _stmt: &mut sqlite::Statement<'a>, index: usize);
-    fn build_from<'a>(
+    fn bind_to(&self, _stmt: &mut sqlite::Statement, index: usize);
+    fn build_from(
         adata: AssocData,
-        stmt: &mut sqlite::Statement<'a>,
+        stmt: &mut sqlite::Statement,
         index: usize,
     ) -> DBResult<(Self, usize)>
     where

microrm/src/schema/datum/datum_common.rs

@@ -8,14 +8,14 @@ impl Datum for time::OffsetDateTime {
         "text"
     }
 
-    fn bind_to<'a>(&self, stmt: &mut sqlite::Statement<'a>, index: usize) {
+    fn bind_to(&self, stmt: &mut sqlite::Statement, index: usize) {
         let ts = self.unix_timestamp();
         ts.bind_to(stmt, index)
     }
 
-    fn build_from<'a>(
+    fn build_from(
         adata: AssocData,
-        stmt: &mut sqlite::Statement<'a>,
+        stmt: &mut sqlite::Statement,
         index: usize,
     ) -> DBResult<(Self, usize)>
     where
@@ -34,14 +34,14 @@ impl Datum for String {
         "text"
     }
 
-    fn bind_to<'a>(&self, stmt: &mut sqlite::Statement<'a>, index: usize) {
+    fn bind_to(&self, stmt: &mut sqlite::Statement, index: usize) {
         stmt.bind((index, self.as_str()))
             .expect("couldn't bind string");
     }
 
-    fn build_from<'a>(
+    fn build_from(
         _: AssocData,
-        stmt: &mut sqlite::Statement<'a>,
+        stmt: &mut sqlite::Statement,
         index: usize,
     ) -> DBResult<(Self, usize)>
     where
@@ -56,14 +56,14 @@ impl Datum for usize {
         "int"
     }
 
-    fn bind_to<'a>(&self, stmt: &mut sqlite::Statement<'a>, index: usize) {
+    fn bind_to(&self, stmt: &mut sqlite::Statement, index: usize) {
         stmt.bind((index, *self as i64))
             .expect("couldn't bind usize as i64");
     }
 
-    fn build_from<'a>(
+    fn build_from(
         _: AssocData,
-        stmt: &mut sqlite::Statement<'a>,
+        stmt: &mut sqlite::Statement,
         index: usize,
     ) -> DBResult<(Self, usize)>
     where
@@ -78,13 +78,13 @@ impl Datum for isize {
         "int"
     }
 
-    fn bind_to<'a>(&self, _stmt: &mut sqlite::Statement<'a>, _index: usize) {
+    fn bind_to(&self, _stmt: &mut sqlite::Statement, _index: usize) {
         todo!()
     }
 
-    fn build_from<'a>(
+    fn build_from(
         _: AssocData,
-        stmt: &mut sqlite::Statement<'a>,
+        stmt: &mut sqlite::Statement,
         index: usize,
     ) -> DBResult<(Self, usize)>
     where
@@ -99,13 +99,13 @@ impl Datum for u64 {
         "int"
     }
 
-    fn bind_to<'a>(&self, _stmt: &mut sqlite::Statement<'a>, _index: usize) {
+    fn bind_to(&self, _stmt: &mut sqlite::Statement, _index: usize) {
         todo!()
     }
 
-    fn build_from<'a>(
+    fn build_from(
         _: AssocData,
-        stmt: &mut sqlite::Statement<'a>,
+        stmt: &mut sqlite::Statement,
         index: usize,
     ) -> DBResult<(Self, usize)>
     where
@@ -120,13 +120,13 @@ impl Datum for i64 {
         "int"
     }
 
-    fn bind_to<'a>(&self, stmt: &mut sqlite::Statement<'a>, index: usize) {
+    fn bind_to(&self, stmt: &mut sqlite::Statement, index: usize) {
         stmt.bind((index, *self)).expect("couldn't bind i64")
     }
 
-    fn build_from<'a>(
+    fn build_from(
         _: AssocData,
-        stmt: &mut sqlite::Statement<'a>,
+        stmt: &mut sqlite::Statement,
         index: usize,
     ) -> DBResult<(Self, usize)>
     where
@@ -141,13 +141,13 @@ impl<T: Datum> Datum for Option<T> {
         T::sql_type()
     }
 
-    fn bind_to<'a>(&self, _stmt: &mut sqlite::Statement<'a>, _index: usize) {
+    fn bind_to(&self, _stmt: &mut sqlite::Statement, _index: usize) {
         todo!()
     }
 
-    fn build_from<'a>(
+    fn build_from(
         _: AssocData,
-        _stmt: &mut sqlite::Statement<'a>,
+        _stmt: &mut sqlite::Statement,
         _index: usize,
     ) -> DBResult<(Self, usize)>
     where
@@ -163,14 +163,14 @@ impl Datum for bool {
         "int"
     }
 
-    fn bind_to<'a>(&self, stmt: &mut sqlite::Statement<'a>, index: usize) {
+    fn bind_to(&self, stmt: &mut sqlite::Statement, index: usize) {
         stmt.bind((index, if *self { 1 } else { 0 }))
             .expect("couldn't bind bool");
     }
 
-    fn build_from<'a>(
+    fn build_from(
         _: AssocData,
-        stmt: &mut sqlite::Statement<'a>,
+        stmt: &mut sqlite::Statement,
         index: usize,
     ) -> DBResult<(Self, usize)>
     where
@@ -185,14 +185,14 @@ impl Datum for Vec<u8> {
         "blob"
     }
 
-    fn bind_to<'a>(&self, stmt: &mut sqlite::Statement<'a>, index: usize) {
+    fn bind_to(&self, stmt: &mut sqlite::Statement, index: usize) {
         stmt.bind((index, self.as_slice()))
             .expect("couldn't bind Vec<u8>");
     }
 
-    fn build_from<'a>(
+    fn build_from(
         _: AssocData,
-        stmt: &mut sqlite::Statement<'a>,
+        stmt: &mut sqlite::Statement,
         index: usize,
     ) -> DBResult<(Self, usize)>
     where
@@ -207,14 +207,14 @@ impl<'l, T: Datum> Datum for &'l T {
         T::sql_type()
     }
 
-    fn bind_to<'a>(&self, stmt: &mut sqlite::Statement<'a>, index: usize) {
+    fn bind_to(&self, stmt: &mut sqlite::Statement, index: usize) {
         T::bind_to(self, stmt, index)
     }
 
-    fn build_from<'a>(
-        adata: AssocData,
-        stmt: &mut sqlite::Statement<'a>,
-        index: usize,
+    fn build_from(
+        _adata: AssocData,
+        _stmt: &mut sqlite::Statement,
+        _index: usize,
     ) -> DBResult<(Self, usize)>
     where
         Self: Sized,