Rumamge.Ecto v1.2.0 Rummage.Ecto.Services.BuildSearchQuery

Rummage.Ecto.Services.BuildSearchQuery is a service module which serves the default search hook, Rummage.Ecto.Hooks.Search that comes shipped with Rummage.Ecto.

Has a Module Attribute called search_types:

@search_types ~w(like ilike eq gt lt gteq lteq)

@search_types is a collection of all the 7 valid search_types that come shipped with Rummage.Ecto’s default search hook. The types are:

  • like: Searches for a term in a given field of a queryable.
  • ilike: Searches for a term in a given field of a queryable, in a case insensitive fashion.
  • eq: Searches for a term to be equal to a given field of a queryable.
  • gt: Searches for a term to be greater than to a given field of a queryable.
  • lt: Searches for a term to be less than to a given field of a queryable.
  • gteq: Searches for a term to be greater than or equal to to a given field of a queryable.
  • lteq: Searches for a term to be less than or equal to a given field of a queryable.

Feel free to use this module on a custom search hook that you write.

Summary

Functions

Builds a searched queryable on top of the given queryable using field and search_type when the search_term is eq

Builds a searched queryable on top of the given queryable using field and search_type when the search_term is gt

Builds a searched queryable on top of the given queryable using field and search_type when the search_term is gteq

Builds a searched queryable on top of the given queryable using field and search_type when the search_term is ilike

Builds a searched queryable on top of the given queryable using field and search_type when the search_term is like

Builds a searched queryable on top of the given queryable using field and search_type when the search_term is lt

Builds a searched queryable on top of the given queryable using field and search_type when the search_term is lteq

Builds a searched queryable on top of the given queryable using field, search_type and search_term

Functions

handle_eq(queryable, field, search_term)
handle_eq(Ecto.Query.t, atom, term) :: {Ecto.Query.t}

Builds a searched queryable on top of the given queryable using field and search_type when the search_term is eq.

Examples

iex> alias Rummage.Ecto.Services.BuildSearchQuery
iex> import Ecto.Query
iex> queryable = from u in "parents"
#Ecto.Query<from p in "parents">
iex> BuildSearchQuery.handle_eq(queryable, :field_1, "field_!")
#Ecto.Query<from p in "parents", where: p.field_1 == ^"field_!">
handle_gt(queryable, field, search_term)
handle_gt(Ecto.Query.t, atom, term) :: {Ecto.Query.t}

Builds a searched queryable on top of the given queryable using field and search_type when the search_term is gt.

Examples

iex> alias Rummage.Ecto.Services.BuildSearchQuery
iex> import Ecto.Query
iex> queryable = from u in "parents"
#Ecto.Query<from p in "parents">
iex> BuildSearchQuery.handle_gt(queryable, :field_1, "field_!")
#Ecto.Query<from p in "parents", where: p.field_1 > ^"field_!">
handle_gteq(queryable, field, search_term)
handle_gteq(Ecto.Query.t, atom, term) :: {Ecto.Query.t}

Builds a searched queryable on top of the given queryable using field and search_type when the search_term is gteq.

Examples

iex> alias Rummage.Ecto.Services.BuildSearchQuery
iex> import Ecto.Query
iex> queryable = from u in "parents"
#Ecto.Query<from p in "parents">
iex> BuildSearchQuery.handle_gteq(queryable, :field_1, "field_!")
#Ecto.Query<from p in "parents", where: p.field_1 >= ^"field_!">
handle_ilike(queryable, field, search_term)
handle_ilike(Ecto.Query.t, atom, term) :: {Ecto.Query.t}

Builds a searched queryable on top of the given queryable using field and search_type when the search_term is ilike.

Examples

iex> alias Rummage.Ecto.Services.BuildSearchQuery
iex> import Ecto.Query
iex> queryable = from u in "parents"
#Ecto.Query<from p in "parents">
iex> BuildSearchQuery.handle_ilike(queryable, :field_1, "field_!")
#Ecto.Query<from p in "parents", where: ilike(p.field_1, ^"%field_!%")>
handle_like(queryable, field, search_term)
handle_like(Ecto.Query.t, atom, term) :: {Ecto.Query.t}

Builds a searched queryable on top of the given queryable using field and search_type when the search_term is like.

Examples

iex> alias Rummage.Ecto.Services.BuildSearchQuery
iex> import Ecto.Query
iex> queryable = from u in "parents"
#Ecto.Query<from p in "parents">
iex> BuildSearchQuery.handle_like(queryable, :field_1, "field_!")
#Ecto.Query<from p in "parents", where: like(p.field_1, ^"%field_!%")>
handle_lt(queryable, field, search_term)
handle_lt(Ecto.Query.t, atom, term) :: {Ecto.Query.t}

Builds a searched queryable on top of the given queryable using field and search_type when the search_term is lt.

Examples

iex> alias Rummage.Ecto.Services.BuildSearchQuery
iex> import Ecto.Query
iex> queryable = from u in "parents"
#Ecto.Query<from p in "parents">
iex> BuildSearchQuery.handle_lt(queryable, :field_1, "field_!")
#Ecto.Query<from p in "parents", where: p.field_1 < ^"field_!">
handle_lteq(queryable, field, search_term)
handle_lteq(Ecto.Query.t, atom, term) :: {Ecto.Query.t}

Builds a searched queryable on top of the given queryable using field and search_type when the search_term is lteq.

Examples

iex> alias Rummage.Ecto.Services.BuildSearchQuery
iex> import Ecto.Query
iex> queryable = from u in "parents"
#Ecto.Query<from p in "parents">
iex> BuildSearchQuery.handle_lteq(queryable, :field_1, "field_!")
#Ecto.Query<from p in "parents", where: p.field_1 <= ^"field_!">
run(queryable, field, search_type, search_term)
run(Ecto.Query.t, atom, String.t, term) :: {Ecto.Query.t}

Builds a searched queryable on top of the given queryable using field, search_type and search_term.

Examples

When field, search_type and queryable are passed with search_type of like:

iex> alias Rummage.Ecto.Services.BuildSearchQuery
iex> import Ecto.Query
iex> queryable = from u in "parents"
#Ecto.Query<from p in "parents">
iex> BuildSearchQuery.run(queryable, :field_1, "like", "field_!")
#Ecto.Query<from p in "parents", where: like(p.field_1, ^"%field_!%")>

When field, search_type and queryable are passed with search_type of ilike:

iex> alias Rummage.Ecto.Services.BuildSearchQuery
  iex> import Ecto.Query
  iex> queryable = from u in "parents"
  #Ecto.Query<from p in "parents">
  iex> BuildSearchQuery.run(queryable, :field_1, "ilike", "field_!")
  #Ecto.Query<from p in "parents", where: ilike(p.field_1, ^"%field_!%")>

When field, search_type and queryable are passed with search_type of eq:

iex> alias Rummage.Ecto.Services.BuildSearchQuery
iex> import Ecto.Query
iex> queryable = from u in "parents"
#Ecto.Query<from p in "parents">
iex> BuildSearchQuery.run(queryable, :field_1, "eq", "field_!")
#Ecto.Query<from p in "parents", where: p.field_1 == ^"field_!">

When field, search_type and queryable are passed with search_type of gt:

iex> alias Rummage.Ecto.Services.BuildSearchQuery
iex> import Ecto.Query
iex> queryable = from u in "parents"
#Ecto.Query<from p in "parents">
iex> BuildSearchQuery.run(queryable, :field_1, "gt", "field_!")
#Ecto.Query<from p in "parents", where: p.field_1 > ^"field_!">

When field, search_type and queryable are passed with search_type of lt:

iex> alias Rummage.Ecto.Services.BuildSearchQuery
iex> import Ecto.Query
iex> queryable = from u in "parents"
#Ecto.Query<from p in "parents">
iex> BuildSearchQuery.run(queryable, :field_1, "lt", "field_!")
#Ecto.Query<from p in "parents", where: p.field_1 < ^"field_!">

When field, search_type and queryable are passed with search_type of gteq:

iex> alias Rummage.Ecto.Services.BuildSearchQuery
iex> import Ecto.Query
iex> queryable = from u in "parents"
#Ecto.Query<from p in "parents">
iex> BuildSearchQuery.run(queryable, :field_1, "gteq", "field_!")
#Ecto.Query<from p in "parents", where: p.field_1 >= ^"field_!">

When field, search_type and queryable are passed with search_type of lteq:

iex> alias Rummage.Ecto.Services.BuildSearchQuery
iex> import Ecto.Query
iex> queryable = from u in "parents"
#Ecto.Query<from p in "parents">
iex> BuildSearchQuery.run(queryable, :field_1, "lteq", "field_!")
#Ecto.Query<from p in "parents", where: p.field_1 <= ^"field_!">

When field, search_type and queryable are passed with an invalid search_type:

iex> alias Rummage.Ecto.Services.BuildSearchQuery
iex> import Ecto.Query
iex> queryable = from u in "parents"
#Ecto.Query<from p in "parents">
iex> BuildSearchQuery.run(queryable, :field_1, "pizza", "field_!")
#Ecto.Query<from p in "parents">