Class: NaranyaEcm::Search::Query

Inherits:

Hash

• Object
• Hash
• NaranyaEcm::Search::Query

Defined in:

lib/naranya_ecm/search/query.rb

Class Method Summary

• .build_searchkick_like(term, options = {}) ⇒ Object

Class Method Details

.build_searchkick_like(term, options = {}) ⇒ Object

# File 'lib/naranya_ecm/search/query.rb', line 5

def build_searchkick_like(term, options = {})
  if term.is_a?(Hash)
    options = term
    term = nil
  else
    term = term.to_s
  end

  fields =
    if options[:fields]
      if options[:autocomplete]
        options[:fields].map{|f| "#{f}.autocomplete" }
      else
        options[:fields].map do |value|
          k, v = value.is_a?(Hash) ? value.to_a.first : [value, :word]
          "#{k}.#{v == :word ? "analyzed" : v}"
        end
      end
    else
      ["_all"]
    end

  operator = options[:partial] ? "or" : "and"

  # model and eagar loading
  load = options[:load].nil? ? true : options[:load]
  load = (options[:include] ? {include: options[:include]} : true) if load

  # pagination
  page = [options[:page].to_i, 1].max
  per_page = (options[:limit] || options[:per_page] || 10).to_i
  offset = options[:offset] || (page - 1) * per_page

  all = term == "*"

  if options[:query]
    payload = options[:query]
  elsif options[:similar]
    payload = {
      more_like_this: {
        fields: fields,
        like_text: term,
        min_doc_freq: 1,
        min_term_freq: 1,
        analyzer: "searchkick_search2"
      }
    }
  elsif all
    payload = {
      match_all: {}
    }
  else
    if options[:autocomplete]
      payload = {
        multi_match: {
          fields: fields,
          query: term,
          analyzer: "searchkick_autocomplete_search"
        }
      }
    else
      queries = []
      fields.each do |field|
        if field == "_all" or field.end_with?(".analyzed")
          shared_options = {
            fields: [field],
            query: term,
            use_dis_max: false,
            operator: operator,
            cutoff_frequency: 0.001
          }
          queries.concat [
            {multi_match: shared_options.merge(boost: 10, analyzer: "searchkick_search")},
            {multi_match: shared_options.merge(boost: 10, analyzer: "searchkick_search2")}
          ]
          if options[:misspellings] != false
            distance = (options[:misspellings].is_a?(Hash) && options[:misspellings][:distance]) || 1
            queries.concat [
              {multi_match: shared_options.merge(fuzziness: distance, max_expansions: 3, analyzer: "searchkick_search")},
              {multi_match: shared_options.merge(fuzziness: distance, max_expansions: 3, analyzer: "searchkick_search2")}
            ]
          end
        else
          queries << {
            multi_match: {
              fields: [field],
              query: term,
              analyzer: "searchkick_autocomplete_search"
            }
          }
        end
      end

      payload = {
        dis_max: {
          queries: queries
        }
      }
    end

  end

  custom_filters = []

  if options[:boost]
    custom_filters << {
      filter: {
        exists: {
          field: options[:boost]
        }
      },
      script: "log(doc['#{options[:boost]}'].value + 2.718281828)"
    }
  end

  if custom_filters.any?
    payload = {
      custom_filters_score: {
        query: payload,
        filters: custom_filters,
        score_mode: "total"
      }
    }
  end

  payload = {
    query: payload,
    size: per_page,
    from: offset
  }
  payload[:explain] = options[:explain] if options[:explain]

  # order
  if options[:order]
    order = options[:order].is_a?(Enumerable) ? options[:order] : {options[:order] => :asc}
    payload[:sort] = Hash[ order.map{|k, v| [k.to_s == "id" ? :_id : k, v] } ]
  end

  term_filters =
    proc do |field, value|
      if value.is_a?(Array) # in query
        if value.any?
          {or: value.map{|v| term_filters.call(field, v) }}
        else
          {terms: {field => value}} # match nothing
        end
      elsif value.nil?
        {missing: {"field" => field, existence: true, null_value: true}}
      else
        {term: {field => value}}
      end
    end

  # where
  where_filters =
    proc do |where|
      filters = []
      (where || {}).each do |field, value|
        field = :_id if field.to_s == "id"

        if field == :or
          value.each do |or_clause|
            filters << {or: or_clause.map{|or_statement| {and: where_filters.call(or_statement)} }}
          end
        else
          # expand ranges
          if value.is_a?(Range)
            value = {gte: value.first, (value.exclude_end? ? :lt : :lte) => value.last}
          end

          if value.is_a?(Hash)
            if value[:near]
              filters << {
                geo_distance: {
                  field => value.delete(:near).map(&:to_f).reverse,
                  distance: value.delete(:within) || "50mi"
                }
              }
            end

            if value[:top_left]
              filters << {
                geo_bounding_box: {
                  field => {
                    top_left: value.delete(:top_left).map(&:to_f).reverse,
                    bottom_right: value.delete(:bottom_right).map(&:to_f).reverse
                  }
                }
              }
            end

            value.each do |op, op_value|
              if op == :not # not equal
                filters << {not: term_filters.call(field, op_value)}
              elsif op == :all
                filters << {terms: {field => op_value, execution: "and"}}
              else
                range_query =
                  case op
                  when :gt
                    {from: op_value, include_lower: false}
                  when :gte
                    {from: op_value, include_lower: true}
                  when :lt
                    {to: op_value, include_upper: false}
                  when :lte
                    {to: op_value, include_upper: true}
                  else
                    raise "Unknown where operator"
                  end
                filters << {range: {field => range_query}}
              end
            end
          else
            filters << term_filters.call(field, value)
          end
        end
      end
      filters
    end

  # filters
  filters = where_filters.call(options[:where])
  if filters.any?
    payload[:filter] = {
      and: filters
    }
  end

  # facets
  facet_limits = {}
  if options[:facets]
    facets = options[:facets] || {}
    if facets.is_a?(Array) # convert to more advanced syntax
      facets = Hash[ facets.map{|f| [f, {}] } ]
    end

    payload[:facets] = {}
    facets.each do |field, facet_options|
      # ask for extra facets due to
      # https://github.com/elasticsearch/elasticsearch/issues/1305

      if facet_options[:ranges]
        payload[:facets][field] = {
          range: {
            field.to_sym => facet_options[:ranges]
          }
        }
      else
        payload[:facets][field] = {
          terms: {
            field: field,
            size: facet_options[:limit] ? facet_options[:limit] + 150 : 100000
          }
        }
      end

      facet_limits[field] = facet_options[:limit] if facet_options[:limit]

      # offset is not possible
      # http://elasticsearch-users.115913.n3.nabble.com/Is-pagination-possible-in-termsStatsFacet-td3422943.html

      facet_filters = where_filters.call(facet_options[:where])
      if facet_filters.any?
        payload[:facets][field][:facet_filter] = {
          and: {
            filters: facet_filters
          }
        }
      end
    end
  end

  # highlight
  if options[:highlight]
    payload[:highlight] = {
      fields: Hash[ fields.map{|f| [f, {}] } ]
    }
    if options[:highlight].is_a?(Hash) and tag = options[:highlight][:tag]
      payload[:highlight][:pre_tags] = [tag]
      payload[:highlight][:post_tags] = [tag.to_s.gsub(/\A</, "</")]
    end
  end

  payload[:_source] = 'updated_at'

  self.new.merge payload
end