loosen search

Author: Robert Masen

src/controllers/krate/search.rs

@@ -37,6 +37,12 @@ pub fn search(req: &mut dyn Request) -> CargoResult<Response> {
     let conn = req.db_conn()?;
     let (offset, limit) = req.pagination(10, 100)?;
     let params = req.query();
+    //extract the search param for loose searching
+    let search_q = if let Some(q) = params.get("q") {
+        format!("%{}%", q)
+    } else {
+        String::new()
+    };
     let sort = params
         .get("sort")
         .map(|s| &**s)
@@ -56,7 +62,7 @@ pub fn search(req: &mut dyn Request) -> CargoResult<Response> {
             let q = plainto_tsquery(q_string);
             query = query.filter(
                 q.matches(crates::textsearchable_index_col)
-                    .or(Crate::with_name(q_string)),
+                    .or(Crate::like_name(&search_q)),
             );
 
             query = query.select((
@@ -206,3 +212,182 @@ pub fn search(req: &mut dyn Request) -> CargoResult<Response> {
         meta: Meta { total },
     }))
 }
+pub fn loose_search(req: &mut dyn Request) -> CargoResult<Response> {
+    use diesel::sql_types::Bool;
+
+    let conn = req.db_conn()?;
+    let (offset, limit) = req.pagination(10, 100)?;
+    let params = req.query();
+    let sort = params
+        .get("sort")
+        .map(|s| &**s)
+        .unwrap_or("recent-downloads");
+
+    let loose_q = if let Some(q_string) = params.get("q") {
+        format!("%{}%", q_string)
+    } else {
+        String::new()
+    };
+    let mut query = crates::table
+        .left_join(recent_crate_downloads::table)
+        .select((
+            ALL_COLUMNS,
+            false.into_sql::<Bool>(),
+            recent_crate_downloads::downloads.nullable(),
+        )).into_boxed();
+    if let Some(q_string) = params.get("q") {
+        if !q_string.is_empty() {
+            let sort = params.get("sort").map(|s| &**s).unwrap_or("relevance");
+            let q = plainto_tsquery(q_string);
+            query = query.filter(
+                q.matches(crates::textsearchable_index_col)
+                    .or(Crate::like_name(&loose_q)),
+            );
+
+            query = query.select((
+                ALL_COLUMNS,
+                Crate::with_name(q_string),
+                recent_crate_downloads::downloads.nullable(),
+            ));
+            query = query.order(Crate::with_name(q_string).desc());
+
+            if sort == "relevance" {
+                let rank = ts_rank_cd(crates::textsearchable_index_col, q);
+                query = query.then_order_by(rank.desc())
+            }
+        }
+    }
+
+    if let Some(cat) = params.get("category") {
+        query = query.filter(
+            crates::id.eq_any(
+                crates_categories::table
+                    .select(crates_categories::crate_id)
+                    .inner_join(categories::table)
+                    .filter(
+                        categories::slug
+                            .eq(cat)
+                            .or(categories::slug.like(format!("{}::%", cat))),
+                    ),
+            ),
+        );
+    }
+
+    if let Some(kw) = params.get("keyword") {
+        query = query.filter(
+            crates::id.eq_any(
+                crates_keywords::table
+                    .select(crates_keywords::crate_id)
+                    .inner_join(keywords::table)
+                    .filter(::lower(keywords::keyword).eq(::lower(kw))),
+            ),
+        );
+    } else if let Some(letter) = params.get("letter") {
+        let pattern = format!(
+            "{}%",
+            letter
+                .chars()
+                .next()
+                .unwrap()
+                .to_lowercase()
+                .collect::<String>()
+        );
+        query = query.filter(canon_crate_name(crates::name).like(pattern));
+    } else if let Some(user_id) = params.get("user_id").and_then(|s| s.parse::<i32>().ok()) {
+        query = query.filter(
+            crates::id.eq_any(
+                crate_owners::table
+                    .select(crate_owners::crate_id)
+                    .filter(crate_owners::owner_id.eq(user_id))
+                    .filter(crate_owners::deleted.eq(false))
+                    .filter(crate_owners::owner_kind.eq(OwnerKind::User as i32)),
+            ),
+        );
+    } else if let Some(team_id) = params.get("team_id").and_then(|s| s.parse::<i32>().ok()) {
+        query = query.filter(
+            crates::id.eq_any(
+                crate_owners::table
+                    .select(crate_owners::crate_id)
+                    .filter(crate_owners::owner_id.eq(team_id))
+                    .filter(crate_owners::deleted.eq(false))
+                    .filter(crate_owners::owner_kind.eq(OwnerKind::Team as i32)),
+            ),
+        );
+    } else if params.get("following").is_some() {
+        query = query.filter(
+            crates::id.eq_any(
+                follows::table
+                    .select(follows::crate_id)
+                    .filter(follows::user_id.eq(req.user()?.id)),
+            ),
+        );
+    }
+
+    if sort == "downloads" {
+        query = query.then_order_by(crates::downloads.desc())
+    } else if sort == "recent-downloads" {
+        query = query.then_order_by(recent_crate_downloads::downloads.desc().nulls_last())
+    } else if sort == "recent-updates" {
+        query = query.order(crates::updated_at.desc());
+    } else {
+        query = query.then_order_by(crates::name.asc())
+    }
+    println!("{:?}", diesel::debug_query(&query));
+    // The database query returns a tuple within a tuple, with the root
+    // tuple containing 3 items.
+    let data = query
+        .paginate(limit, offset)
+        .load::<((Crate, bool, Option<i64>), i64)>(&*conn)?;
+    let total = data.first().map(|&(_, t)| t).unwrap_or(0);
+    let perfect_matches = data.iter().map(|&((_, b, _), _)| b).collect::<Vec<_>>();
+    let recent_downloads = data
+        .iter()
+        .map(|&((_, _, s), _)| s.unwrap_or(0))
+        .collect::<Vec<_>>();
+    let crates = data.into_iter().map(|((c, _, _), _)| c).collect::<Vec<_>>();
+
+    let versions = crates
+        .versions()
+        .load::<Version>(&*conn)?
+        .grouped_by(&crates)
+        .into_iter()
+        .map(|versions| Version::max(versions.into_iter().map(|v| v.num)));
+
+    let badges = CrateBadge::belonging_to(&crates)
+        .select((badges::crate_id, badges::all_columns))
+        .load::<CrateBadge>(&conn)?
+        .grouped_by(&crates)
+        .into_iter()
+        .map(|badges| badges.into_iter().map(|cb| cb.badge).collect());
+
+    let crates = versions
+        .zip(crates)
+        .zip(perfect_matches)
+        .zip(recent_downloads)
+        .zip(badges)
+        .map(
+            |((((max_version, krate), perfect_match), recent_downloads), badges)| {
+                krate.minimal_encodable(
+                    &max_version,
+                    Some(badges),
+                    perfect_match,
+                    Some(recent_downloads),
+                )
+            },
+        ).collect();
+
+    #[derive(Serialize)]
+    struct R {
+        crates: Vec<EncodableCrate>,
+        meta: Meta,
+    }
+    #[derive(Serialize)]
+    struct Meta {
+        total: i64,
+    }
+
+    Ok(req.json(&R {
+        crates,
+        meta: Meta { total },
+    }))
+}

src/models/krate.rs

@@ -90,6 +90,8 @@ pub const MAX_NAME_LENGTH: usize = 64;
 type CanonCrateName<T> = self::canon_crate_name::HelperType<T>;
 type All = diesel::dsl::Select<crates::table, AllColumns>;
 type WithName<'a> = diesel::dsl::Eq<CanonCrateName<crates::name>, CanonCrateName<&'a str>>;
+/// The result of a loose search
+type LikeName<'a> = diesel::dsl::Like<CanonCrateName<crates::name>, CanonCrateName<&'a str>>;
 type ByName<'a> = diesel::dsl::Filter<All, WithName<'a>>;
 type ByExactName<'a> = diesel::dsl::Filter<All, diesel::dsl::Eq<crates::name, &'a str>>;
 
@@ -237,6 +239,21 @@ impl<'a> NewCrate<'a> {
 }
 
 impl Crate {
+    /// SQL filter with the `like` binary operator
+    /// ```sql
+    /// SELECT *
+    /// FROM crates
+    /// WHERE name like $1
+    /// ```
+    pub fn like_name(name: &str) -> LikeName<'_> {
+        canon_crate_name(crates::name).like(canon_crate_name(name))
+    }
+    /// SQL filter with the = binary operator
+    /// ```sql
+    /// SELECT *
+    /// FROM crates
+    /// WHERE name = $1
+    /// ```
     pub fn with_name(name: &str) -> WithName<'_> {
         canon_crate_name(crates::name).eq(canon_crate_name(name))
     }