git.squeep.com Git - akkoma/blob - lib/pleroma/user/search.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.User.Search do
   6   alias Pleroma.Repo
   7   alias Pleroma.User
   8   import Ecto.Query
   9
  10   def search(query, opts \\ []) do
  11     resolve = Keyword.get(opts, :resolve, false)
  12     for_user = Keyword.get(opts, :for_user)
  13
  14     # Strip the beginning @ off if there is a query
  15     query = String.trim_leading(query, "@")
  16
  17     maybe_resolve(resolve, for_user, query)
  18
  19     {:ok, results} =
  20       Repo.transaction(fn ->
  21         Ecto.Adapters.SQL.query(Repo, "select set_limit(0.25)", [])
  22
  23         query
  24         |> search_query(for_user)
  25         |> Repo.all()
  26       end)
  27
  28     results
  29   end
  30
  31   defp search_query(query, for_user) do
  32     query
  33     |> union_query()
  34     |> distinct_query()
  35     |> boost_search_rank_query(for_user)
  36     |> subquery()
  37     |> order_by(desc: :search_rank)
  38     |> limit(20)
  39     |> maybe_restrict_local(for_user)
  40   end
  41
  42   defp union_query(query) do
  43     fts_subquery = fts_search_subquery(query)
  44     trigram_subquery = trigram_search_subquery(query)
  45
  46     from(s in trigram_subquery, union_all: ^fts_subquery)
  47   end
  48
  49   defp distinct_query(q) do
  50     from(s in subquery(q), order_by: s.search_type, distinct: s.id)
  51   end
  52
  53   defp maybe_resolve(true, user, query) do
  54     case {limit(), user} do
  55       {:all, _} -> :noop
  56       {:unauthenticated, %User{}} -> User.get_or_fetch(query)
  57       {:unauthenticated, _} -> :noop
  58       {false, _} -> User.get_or_fetch(query)
  59     end
  60   end
  61
  62   defp maybe_resolve(_, _, _), do: :noop
  63
  64   defp maybe_restrict_local(q, user) do
  65     case {limit(), user} do
  66       {:all, _} -> restrict_local(q)
  67       {:unauthenticated, %User{}} -> q
  68       {:unauthenticated, _} -> restrict_local(q)
  69       {false, _} -> q
  70     end
  71   end
  72
  73   defp limit, do: Pleroma.Config.get([:instance, :limit_to_local_content], :unauthenticated)
  74
  75   defp restrict_local(q), do: where(q, [u], u.local == true)
  76
  77   defp boost_search_rank_query(query, nil), do: query
  78
  79   defp boost_search_rank_query(query, for_user) do
  80     friends_ids = User.get_friends_ids(for_user)
  81     followers_ids = User.get_followers_ids(for_user)
  82
  83     from(u in subquery(query),
  84       select_merge: %{
  85         search_rank:
  86           fragment(
  87             """
  88              CASE WHEN (?) THEN 0.5 + (?) * 1.3
  89              WHEN (?) THEN 0.5 + (?) * 1.2
  90              WHEN (?) THEN (?) * 1.1
  91              ELSE (?) END
  92             """,
  93             u.id in ^friends_ids and u.id in ^followers_ids,
  94             u.search_rank,
  95             u.id in ^friends_ids,
  96             u.search_rank,
  97             u.id in ^followers_ids,
  98             u.search_rank,
  99             u.search_rank
 100           )
 101       }
 102     )
 103   end
 104
 105   defp fts_search_subquery(term, query \\ User) do
 106     processed_query =
 107       term
 108       |> String.replace(~r/\W+/, " ")
 109       |> String.trim()
 110       |> String.split()
 111       |> Enum.map(&(&1 <> ":*"))
 112       |> Enum.join(" | ")
 113
 114     from(
 115       u in query,
 116       select_merge: %{
 117         search_type: ^0,
 118         search_rank:
 119           fragment(
 120             """
 121             ts_rank_cd(
 122               setweight(to_tsvector('simple', regexp_replace(?, '\\W', ' ', 'g')), 'A') ||
 123               setweight(to_tsvector('simple', regexp_replace(coalesce(?, ''), '\\W', ' ', 'g')), 'B'),
 124               to_tsquery('simple', ?),
 125               32
 126             )
 127             """,
 128             u.nickname,
 129             u.name,
 130             ^processed_query
 131           )
 132       },
 133       where:
 134         fragment(
 135           """
 136             (setweight(to_tsvector('simple', regexp_replace(?, '\\W', ' ', 'g')), 'A') ||
 137             setweight(to_tsvector('simple', regexp_replace(coalesce(?, ''), '\\W', ' ', 'g')), 'B')) @@ to_tsquery('simple', ?)
 138           """,
 139           u.nickname,
 140           u.name,
 141           ^processed_query
 142         )
 143     )
 144     |> User.restrict_deactivated()
 145   end
 146
 147   defp trigram_search_subquery(term) do
 148     from(
 149       u in User,
 150       select_merge: %{
 151         # ^1 gives 'Postgrex expected a binary, got 1' for some weird reason
 152         search_type: fragment("?", 1),
 153         search_rank:
 154           fragment(
 155             "similarity(?, trim(? || ' ' || coalesce(?, '')))",
 156             ^term,
 157             u.nickname,
 158             u.name
 159           )
 160       },
 161       where: fragment("trim(? || ' ' || coalesce(?, '')) % ?", u.nickname, u.name, ^term)
 162     )
 163     |> User.restrict_deactivated()
 164   end
 165 end