search_query (zotonic_mod_search v1.0.0-rc.17)

Handler for m.search[{query, Args..}]

Summary

Functions

build_query(Terms, Context)

-spec build_query(list(), z:context()) ->
                     #search_sql_terms{terms ::
                                           [#search_sql_term{label :: term(),
                                                             select :: term(),
                                                             tables :: term(),
                                                             join_inner :: term(),
                                                             join_left :: term(),
                                                             where :: term(),
                                                             sort :: term(),
                                                             asort :: term(),
                                                             zsort :: term(),
                                                             cats :: term(),
                                                             cats_exclude :: term(),
                                                             cats_exact :: term(),
                                                             extra :: term(),
                                                             args :: term()} |
                                            #search_sql_nested{terms ::
                                                                   [#search_sql_term{label :: term(),
                                                                                     select :: term(),
                                                                                     tables :: term(),
                                                                                     join_inner ::
                                                                                         term(),
                                                                                     join_left :: term(),
                                                                                     where :: term(),
                                                                                     sort :: term(),
                                                                                     asort :: term(),
                                                                                     zsort :: term(),
                                                                                     cats :: term(),
                                                                                     cats_exclude ::
                                                                                         term(),
                                                                                     cats_exact ::
                                                                                         term(),
                                                                                     extra :: term(),
                                                                                     args :: term()} |
                                                                    #search_sql_nested{}],
                                                               operator :: binary()}],
                                       post_func ::
                                           fun((#search_result{search_name :: binary() | atom(),
                                                               search_args ::
                                                                   map() | proplists:proplist(),
                                                               result :: list(),
                                                               page :: pos_integer(),
                                                               pagelen :: pos_integer() | undefined,
                                                               options :: z_search:search_options(),
                                                               total :: non_neg_integer() | undefined,
                                                               pages :: non_neg_integer() | undefined,
                                                               is_total_estimated :: boolean(),
                                                               next :: pos_integer() | false,
                                                               prev :: pos_integer(),
                                                               facets ::
                                                                   #{binary() => map()} | undefined},
                                                #search_sql{select :: iodata(),
                                                            from :: iodata(),
                                                            where :: iodata(),
                                                            order :: iodata(),
                                                            group_by :: iodata(),
                                                            limit :: term(),
                                                            tables :: list(),
                                                            args :: list(),
                                                            cats :: list(),
                                                            cats_exclude :: list(),
                                                            cats_exact :: list(),
                                                            run_func :: function() | undefined,
                                                            post_func ::
                                                                fun((#search_result{search_name ::
                                                                                        binary() |
                                                                                        atom(),
                                                                                    search_args ::
                                                                                        map() |
                                                                                        proplists:proplist(),
                                                                                    result :: list(),
                                                                                    page ::
                                                                                        pos_integer(),
                                                                                    pagelen ::
                                                                                        pos_integer() |
                                                                                        undefined,
                                                                                    options ::
                                                                                        z_search:search_options(),
                                                                                    total ::
                                                                                        non_neg_integer() |
                                                                                        undefined,
                                                                                    pages ::
                                                                                        non_neg_integer() |
                                                                                        undefined,
                                                                                    is_total_estimated ::
                                                                                        boolean(),
                                                                                    next ::
                                                                                        pos_integer() |
                                                                                        false,
                                                                                    prev ::
                                                                                        pos_integer(),
                                                                                    facets ::
                                                                                        #{binary() =>
                                                                                              map()} |
                                                                                        undefined},
                                                                     #search_sql{},
                                                                     z:context()) ->
                                                                        #search_result{search_name ::
                                                                                           binary() |
                                                                                           atom(),
                                                                                       search_args ::
                                                                                           map() |
                                                                                           proplists:proplist(),
                                                                                       result :: list(),
                                                                                       page ::
                                                                                           pos_integer(),
                                                                                       pagelen ::
                                                                                           pos_integer() |
                                                                                           undefined,
                                                                                       options ::
                                                                                           z_search:search_options(),
                                                                                       total ::
                                                                                           non_neg_integer() |
                                                                                           undefined,
                                                                                       pages ::
                                                                                           non_neg_integer() |
                                                                                           undefined,
                                                                                       is_total_estimated ::
                                                                                           boolean(),
                                                                                       next ::
                                                                                           pos_integer() |
                                                                                           false,
                                                                                       prev ::
                                                                                           pos_integer(),
                                                                                       facets ::
                                                                                           #{binary() =>
                                                                                                 map()} |
                                                                                           undefined}) |
                                                                undefined,
                                                            extra :: list(),
                                                            assoc :: boolean(),
                                                            search_sql_terms :: list() | undefined},
                                                z:context()) ->
                                                   #search_result{search_name :: binary() | atom(),
                                                                  search_args ::
                                                                      map() | proplists:proplist(),
                                                                  result :: list(),
                                                                  page :: pos_integer(),
                                                                  pagelen :: pos_integer() | undefined,
                                                                  options :: z_search:search_options(),
                                                                  total :: non_neg_integer() | undefined,
                                                                  pages :: non_neg_integer() | undefined,
                                                                  is_total_estimated :: boolean(),
                                                                  next :: pos_integer() | false,
                                                                  prev :: pos_integer(),
                                                                  facets ::
                                                                      #{binary() => map()} | undefined}) |
                                           undefined} |
                     #search_result{search_name :: binary() | atom(),
                                    search_args :: map() | proplists:proplist(),
                                    result :: list(),
                                    page :: pos_integer(),
                                    pagelen :: pos_integer() | undefined,
                                    options :: z_search:search_options(),
                                    total :: non_neg_integer() | undefined,
                                    pages :: non_neg_integer() | undefined,
                                    is_total_estimated :: boolean(),
                                    next :: pos_integer() | false,
                                    prev :: pos_integer(),
                                    facets :: #{binary() => map()} | undefined}.

expand_content_groups(ContentGroups, Context)

-spec expand_content_groups(ContentGroups, Context) -> {WithDefaultGroup, GroupsAndSubgroups}
                               when
                                   ContentGroups :: [m_rsc:resource()],
                                   Context :: z:context(),
                                   WithDefaultGroup :: boolean(),
                                   GroupsAndSubgroups :: [m_rsc:resource_id()].

expand_object_predicates(Bin, Context)

extract_value_op(Value, DefaultOperator)

-spec extract_value_op(Value, DefaultOperator) -> {Operator, Value1}
                          when
                              Value :: binary() | term(),
                              DefaultOperator :: binary(),
                              Operator :: binary(),
                              Value1 :: term().

Extract the operator from the value.

parse_request_args(Args)

-spec parse_request_args([{binary(), term()}]) -> [{binary(), term()}].

qterm(Term, IsNested, Context)

-spec qterm(Term, IsNested, Context) -> QueryTerms
               when
                   Term :: list() | map(),
                   IsNested :: boolean(),
                   Context :: z:context(),
                   QueryTerms ::
                       list() |
                       #search_sql_term{label :: term(),
                                        select :: term(),
                                        tables :: term(),
                                        join_inner :: term(),
                                        join_left :: term(),
                                        where :: term(),
                                        sort :: term(),
                                        asort :: term(),
                                        zsort :: term(),
                                        cats :: term(),
                                        cats_exclude :: term(),
                                        cats_exact :: term(),
                                        extra :: term(),
                                        args :: term()}.

search(Query, Context)

-spec search(Query, Context) -> SqlTerms | EmptyResult
                when
                    Query :: map() | proplists:proplist(),
                    Context :: z:context(),
                    SqlTerms ::
                        #search_sql_terms{terms ::
                                              [#search_sql_term{label :: term(),
                                                                select :: term(),
                                                                tables :: term(),
                                                                join_inner :: term(),
                                                                join_left :: term(),
                                                                where :: term(),
                                                                sort :: term(),
                                                                asort :: term(),
                                                                zsort :: term(),
                                                                cats :: term(),
                                                                cats_exclude :: term(),
                                                                cats_exact :: term(),
                                                                extra :: term(),
                                                                args :: term()} |
                                               #search_sql_nested{terms ::
                                                                      [#search_sql_term{label :: term(),
                                                                                        select :: term(),
                                                                                        tables :: term(),
                                                                                        join_inner ::
                                                                                            term(),
                                                                                        join_left ::
                                                                                            term(),
                                                                                        where :: term(),
                                                                                        sort :: term(),
                                                                                        asort :: term(),
                                                                                        zsort :: term(),
                                                                                        cats :: term(),
                                                                                        cats_exclude ::
                                                                                            term(),
                                                                                        cats_exact ::
                                                                                            term(),
                                                                                        extra :: term(),
                                                                                        args :: term()} |
                                                                       #search_sql_nested{}],
                                                                  operator :: binary()}],
                                          post_func ::
                                              fun((#search_result{search_name :: binary() | atom(),
                                                                  search_args ::
                                                                      map() | proplists:proplist(),
                                                                  result :: list(),
                                                                  page :: pos_integer(),
                                                                  pagelen :: pos_integer() | undefined,
                                                                  options :: z_search:search_options(),
                                                                  total :: non_neg_integer() | undefined,
                                                                  pages :: non_neg_integer() | undefined,
                                                                  is_total_estimated :: boolean(),
                                                                  next :: pos_integer() | false,
                                                                  prev :: pos_integer(),
                                                                  facets ::
                                                                      #{binary() => map()} | undefined},
                                                   #search_sql{select :: iodata(),
                                                               from :: iodata(),
                                                               where :: iodata(),
                                                               order :: iodata(),
                                                               group_by :: iodata(),
                                                               limit :: term(),
                                                               tables :: list(),
                                                               args :: list(),
                                                               cats :: list(),
                                                               cats_exclude :: list(),
                                                               cats_exact :: list(),
                                                               run_func :: function() | undefined,
                                                               post_func ::
                                                                   fun((#search_result{search_name ::
                                                                                           binary() |
                                                                                           atom(),
                                                                                       search_args ::
                                                                                           map() |
                                                                                           proplists:proplist(),
                                                                                       result :: list(),
                                                                                       page ::
                                                                                           pos_integer(),
                                                                                       pagelen ::
                                                                                           pos_integer() |
                                                                                           undefined,
                                                                                       options ::
                                                                                           z_search:search_options(),
                                                                                       total ::
                                                                                           non_neg_integer() |
                                                                                           undefined,
                                                                                       pages ::
                                                                                           non_neg_integer() |
                                                                                           undefined,
                                                                                       is_total_estimated ::
                                                                                           boolean(),
                                                                                       next ::
                                                                                           pos_integer() |
                                                                                           false,
                                                                                       prev ::
                                                                                           pos_integer(),
                                                                                       facets ::
                                                                                           #{binary() =>
                                                                                                 map()} |
                                                                                           undefined},
                                                                        #search_sql{},
                                                                        z:context()) ->
                                                                           #search_result{search_name ::
                                                                                              binary() |
                                                                                              atom(),
                                                                                          search_args ::
                                                                                              map() |
                                                                                              proplists:proplist(),
                                                                                          result ::
                                                                                              list(),
                                                                                          page ::
                                                                                              pos_integer(),
                                                                                          pagelen ::
                                                                                              pos_integer() |
                                                                                              undefined,
                                                                                          options ::
                                                                                              z_search:search_options(),
                                                                                          total ::
                                                                                              non_neg_integer() |
                                                                                              undefined,
                                                                                          pages ::
                                                                                              non_neg_integer() |
                                                                                              undefined,
                                                                                          is_total_estimated ::
                                                                                              boolean(),
                                                                                          next ::
                                                                                              pos_integer() |
                                                                                              false,
                                                                                          prev ::
                                                                                              pos_integer(),
                                                                                          facets ::
                                                                                              #{binary() =>
                                                                                                    map()} |
                                                                                              undefined}) |
                                                                   undefined,
                                                               extra :: list(),
                                                               assoc :: boolean(),
                                                               search_sql_terms :: list() | undefined},
                                                   z:context()) ->
                                                      #search_result{search_name :: binary() | atom(),
                                                                     search_args ::
                                                                         map() | proplists:proplist(),
                                                                     result :: list(),
                                                                     page :: pos_integer(),
                                                                     pagelen ::
                                                                         pos_integer() | undefined,
                                                                     options ::
                                                                         z_search:search_options(),
                                                                     total ::
                                                                         non_neg_integer() | undefined,
                                                                     pages ::
                                                                         non_neg_integer() | undefined,
                                                                     is_total_estimated :: boolean(),
                                                                     next :: pos_integer() | false,
                                                                     prev :: pos_integer(),
                                                                     facets ::
                                                                         #{binary() => map()} |
                                                                         undefined}) |
                                              undefined},
                    EmptyResult ::
                        #search_result{search_name :: binary() | atom(),
                                       search_args :: map() | proplists:proplist(),
                                       result :: list(),
                                       page :: pos_integer(),
                                       pagelen :: pos_integer() | undefined,
                                       options :: z_search:search_options(),
                                       total :: non_neg_integer() | undefined,
                                       pages :: non_neg_integer() | undefined,
                                       is_total_estimated :: boolean(),
                                       next :: pos_integer() | false,
                                       prev :: pos_integer(),
                                       facets :: #{binary() => map()} | undefined}.

Build a SQL search query from the filter arguments.

sql_safe(String)

term_op_expr(Ref, Op, Value, Type)

-spec term_op_expr(Ref, Op, Value, Type) -> list()
                      when
                          Ref :: iodata(),
                          Op :: binary(),
                          Value :: iodata() | atom(),
                          Type :: text | number.