turbo_ecto v1.0.2

Turbo.Ecto.Services.BuildSearchQuery (turbo_ecto v1.0.2)

Turbo.Ecto.Services.BuildSearchQuery is a service module which serves the search hook.

@search_types is a collection of all the 8 valid search_types that come shipped with Turbo.Ecto's default search hook. The types are:

  • [x] eq: equal. (SQL: col = 'value')
  • [x] not_eq: not equal. (SQL: col != 'value')
  • [x] lt: less than. (SQL: col < 1024)
  • [x] lteq: less than or equal. (SQL: col <= 1024)
  • [x] gt: greater than. (SQL: col > 1024)
  • [x] gteq: greater than or equal. (SQL: col >= 1024)
  • [x] is_present: not null and not empty. (SQL: col is not null AND col != '')
  • [x] is_blank: is null or empty. (SQL: col is null OR col = '')
  • [x] is_null: is null or not null (SQL: col is null)
  • [x] is_true is true. (SQL: col is true)
  • [x] is_not_true is not true. (SQL: col is false)
  • [x] is_false is false. (SQL: col is false)
  • [x] is_not_false is true. (SQL: col is true)
  • [x] like: contains trem value. (SQL: col like "%value%")
  • [x] not_like: not contains value. (SQL: col not like '%value%')
  • [x] ilike: contains value in a case insensitive fashion. (SQL: )
  • [x] not_ilike: not contains value in a case insensitive fashion. (SQL:
  • [x] in contains. (SQL: col in ['1024', '1025'])
  • [x] not_in not contains. (SQL: col not in ['1024', '1025'])
  • [x] start_with start with. (SQL: col like 'value%')
  • [x] not_start_with not start with. (SQL: col not like 'value%')
  • [x] end_with end with. (SQL: col like '%value')
  • [x] not_end_with (SQL: col not like '%value')
  • [x] between: between begin and end. (SQL: begin <= col and col <= end)

Link to this section Summary

Functions

handle_expr(atom, attribute, values)

Examples

When search_type is :eq

search_types()

Link to this section Functions

Link to this function

handle_expr(atom, attribute, values)

Specs

handle_expr(
  atom(),
  %Turbo.Ecto.Hooks.Search.Attribute{name: term(), parent: term()},
  list()
) :: tuple()

Examples

When search_type is :eq:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:eq, %Attribute{name: :price, parent: :query}, ["10"])
{:==, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :price]}, {:^, [], ["10"]}]}

When search_type is :not_eq:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:not_eq, %Attribute{name: :price, parent: :query}, ["10"])
{:!=, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :price]}, {:^, [], ["10"]}]}

When search_type is :lt:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:lt, %Attribute{name: :price, parent: :query}, ["10"])
{:<, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :price]}, {:^, [], ["10"]}]}

When search_type is :lteq:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:lteq, %Attribute{name: :price, parent: :query}, ["10"])
{:<=, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :price]}, {:^, [], ["10"]}]}

When search_type is :gt:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:gt, %Attribute{name: :price, parent: :query}, ["10"])
{:>, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :price]}, {:^, [], ["10"]}]}

When search_type is :gteq:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:gteq, %Attribute{name: :price, parent: :query}, ["10"])
{:>=, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :price]}, {:^, [], ["10"]}]}

When search_type is :like:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:like, %Attribute{name: :title, parent: :query}, ["elixir"])
{:like, [], [{:field, [], [{:query, [], Elixir}, :title]}, "%elixir%"]}

When search_type is :not_like:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:not_like, %Attribute{name: :title, parent: :query}, ["elixir"])
{:not, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:like, [], [{:field, [], [{:query, [], Elixir}, :title]}, "%elixir%"]}]}

When search_type is :ilike:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:ilike, %Attribute{name: :title, parent: :query}, ["elixir"])
{:ilike, [], [{:field, [], [{:query, [], Elixir}, :title]}, "%elixir%"]}

When search_type is :not_ilike:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:not_ilike, %Attribute{name: :title, parent: :query}, ["elixir"])
{:not, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:ilike, [], [{:field, [], [{:query, [], Elixir}, :title]}, "%elixir%"]}]}

When search_type is :in:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:in, %Attribute{name: :price, parent: :query}, ["10", "20"])
{:in, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :price]}, {:^, [], [["10", "20"]]}]}

When search_type is :not_in:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:not_in, %Attribute{name: :price, parent: :query}, ["10", "20"])
{
  :not,
  [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel],
  [{:in, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :price]}, {:^, [], [["10", "20"]]}]}]
}

When search_type is :start_with:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:start_with, %Attribute{name: :title, parent: :query}, ["elixir"])
{:ilike, [], [{:field, [], [{:query, [], Elixir}, :title]}, "elixir%"]}

When search_type is :not_start_with:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:not_start_with, %Attribute{name: :title, parent: :query}, ["elixir"])
{:not, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:ilike, [], [{:field, [], [{:query, [], Elixir}, :title]}, "elixir%"]}]}

When search_type is :end_with:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:end_with, %Attribute{name: :title, parent: :query}, ["elixir"])
{:ilike, [], [{:field, [], [{:query, [], Elixir}, :title]}, "%elixir%"]}

When search_type is :not_end_with:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:not_end_with, %Attribute{name: :title, parent: :query}, ["elixir"])
{:not, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:ilike, [], [{:field, [], [{:query, [], Elixir}, :title]}, "%elixir%"]}]}

When search_type is :is_true:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:is_true, %Attribute{name: :available, parent: :query}, [true])
{:==, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :available]}, {:^, [], [true]}]}
iex> BuildSearchQuery.handle_expr(:is_true, %Attribute{name: :available, parent: :query}, [false])
{:!=, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :available]}, {:^, [], [true]}]}

When search_type is :is_not_true:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:is_not_true, %Attribute{name: :available, parent: :query}, [true])
{:==, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :available]}, {:^, [], [false]}]}
iex> BuildSearchQuery.handle_expr(:is_not_true, %Attribute{name: :available, parent: :query}, [false])
{:!=, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :available]}, {:^, [], [false]}]}

When search_type is :is_false:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:is_false, %Attribute{name: :price, parent: :query}, [true])
{:==, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :price]}, {:^, [], [false]}]}
iex> BuildSearchQuery.handle_expr(:is_false, %Attribute{name: :price, parent: :query}, [false])
{:!=, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :price]}, {:^, [], [false]}]}

When search_type is :is_not_false:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:is_not_false, %Attribute{name: :price, parent: :query}, [true])
{:!=, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :price]}, {:^, [], [false]}]}
iex> BuildSearchQuery.handle_expr(:is_not_false, %Attribute{name: :price, parent: :query}, [false])
{:==, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :price]}, {:^, [], [false]}]}

When search_type is :is_null:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:is_null, %Attribute{name: :available, parent: :query}, [true])
{:is_nil, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :available]}]}
iex> BuildSearchQuery.handle_expr(:is_null, %Attribute{name: :available, parent: :query}, [false])
{:not, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:is_nil, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :available]}]}]}

When search_type is :is_not_null:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:is_not_null, %Attribute{name: :available, parent: :query}, [true])
{:not, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:is_nil, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :available]}]}]}
iex> BuildSearchQuery.handle_expr(:is_not_null, %Attribute{name: :available, parent: :query}, [false])
{:not, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:is_nil, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :available]}]}]}

When search_type is :is_present:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:is_present, %Attribute{name: :available, parent: :query}, [true])
{
        :not,
        [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel],
        [{:or, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:is_nil, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :available]}]}, {:==, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :available]}, {:^, [], [""]}]}]}]
      }
iex> BuildSearchQuery.handle_expr(:is_present, %Attribute{name: :available, parent: :query}, [false])
{
        :or,
        [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel],
        [{:not, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:is_nil, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :available]}]}]}, {:!=, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :available]}, {:^, [], [""]}]}]
      }

When search_type is :is_blank:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:is_blank, %Attribute{name: :available, parent: :query}, [true])
{:or, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:is_nil, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :available]}]}, {:==, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:field, [], [{:query, [], Elixir}, :available]}, {:^, [], [""]}]}]}
iex> BuildSearchQuery.handle_expr(:is_blank, %Attribute{name: :available, parent: :query}, [false])
{:or,
       [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel],
       [
         {:not,
          [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel],
          [
            {:is_nil,
             [
               context: Turbo.Ecto.Services.BuildSearchQuery,
               import: Kernel
             ], [{:field, [], [{:query, [], Elixir}, :available]}]}
          ]},
         {:!=,
          [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel],
          [
            {:field, [], [{:query, [], Elixir}, :available]},
            {:^, [], [""]}
          ]}
       ]}

When search_type is :between:

iex> alias Turbo.Ecto.Services.BuildSearchQuery
iex> alias Turbo.Ecto.Hooks.Search.Attribute
iex> BuildSearchQuery.handle_expr(:between, %Attribute{name: :price, parent: :query}, ["10", "20"])
{
  :and,
  [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel],
  [
    {:<, [context: Turbo.Ecto.Services.BuildSearchQuery, import: Kernel], [{:^, [], ["10"]}, {:field, [], [{:query, [], Elixir}, :price]}]},
    {:<, [{:context, Turbo.Ecto.Services.BuildSearchQuery}, {:import, Kernel}], [{:field, [], [{:query, [], Elixir}, :price]}, {:^, [], ["20"]}]}
  ]
}
Link to this function

search_types()