Class: Redis::Commands::Search::Index

# File 'lib/redis/commands/modules/search/index.rb', line 69

def self.key_prefix(prefix, definition)
  if definition.is_a?(IndexDefinition) && definition.prefixes.size == 1
    definition.prefixes.first
  elsif prefix
    "#{prefix}:"
  end
end

# File 'lib/redis/commands/modules/search/index.rb', line 81

def self.resolve_storage_type(storage_type, definition)
  type = definition&.index_type || storage_type
  type.to_s.casecmp?(IndexType::JSON) ? IndexType::JSON : IndexType::HASH
end

# File 'lib/redis/commands/modules/search/index.rb', line 15

attr_reader :name, :prefix

# File 'lib/redis/commands/modules/search/index.rb', line 15

attr_reader :name, :prefix

# File 'lib/redis/commands/modules/search/index.rb', line 259

def aggregate(query, *args)
  @redis.ft_aggregate(@name, query, *args)
end

# File 'lib/redis/commands/modules/search/index.rb', line 294

def alter(field_or_args)
  @redis.ft_alter(@name, field_or_args)
end

# File 'lib/redis/commands/modules/search/index.rb', line 249

def drop(delete_documents: false)
  @redis.ft_dropindex(@name, delete_documents: delete_documents)
end

# File 'lib/redis/commands/modules/search/index.rb', line 285

def explain(query)
  @redis.ft_explain(@name, query)
end

# File 'lib/redis/commands/modules/search/index.rb', line 272

def hybrid_search(query:, combine_method: nil, post_processing: nil,
                  params_substitution: nil, timeout: nil, cursor: nil)
  @redis.ft_hybrid_search(
    @name,
    query: query, combine_method: combine_method, post_processing: post_processing,
    params_substitution: params_substitution, timeout: timeout, cursor: cursor
  )
end

# File 'lib/redis/commands/modules/search/index.rb', line 241

def info
  @redis.ft_info(@name)
end

# File 'lib/redis/commands/modules/search/index.rb', line 338

def profile(*args)
  @redis.ft_profile(@name, *args)
end

# File 'lib/redis/commands/modules/search/index.rb', line 157

def search(query = nil, query_params: nil, params: nil, dialect: nil,
           nocontent: nil, verbatim: nil, no_stopwords: nil, with_scores: nil,
           with_payloads: nil, slop: nil, in_order: nil, language: nil,
           return_fields: nil, summarize: nil, highlight: nil, sort_by: nil, asc: nil,
           scorer: nil, explain_score: nil, &block)
  if block_given?
    query = Query.build(&block)
  elsif query.is_a?(String)
    query = Query.new(query)
  end

  raise ArgumentError, "Invalid query" unless query.is_a?(Query)

  query_string = query.to_redis_args.first

  sort_order = asc == false ? "DESC" : "ASC"
  sortby = sort_by ? [sort_by, sort_order] : query.options[:sortby]
  limit_ids = query.limit_ids_value
  # INKEYS needs full Redis keys. Prepend the index prefix to logical ids (mirroring
  # #add), but leave ids that already carry it alone so callers passing full keys don't
  # get a doubled prefix that matches nothing.
  if limit_ids && @prefix
    limit_ids = limit_ids.map { |id| id.to_s.start_with?(@prefix) ? id : "#{@prefix}#{id}" }
  end

  # An empty RETURN list is not a meaningful per-call value (it would just omit RETURN and
  # return all fields), so treat it as "unset" and fall back to the Query's RETURN list.
  return_fields = nil if return_fields.is_a?(Array) && return_fields.empty?

  # Build a fresh options hash per call. A per-call keyword argument wins when explicitly
  # given (including +false+, to turn a flag off); +nil+ falls back to whatever the Query
  # was built with. The Query is never mutated, so reusing one Query across searches never
  # leaks options between calls and per-call flags can both enable and disable.
  pick = ->(call_value, query_value) { call_value.nil? ? query_value : call_value }

  options = {
    filter: query.filters,
    geo_filter: query.geo_filters,
    limit_ids: limit_ids,
    limit: query.options[:limit],
    sortby: sortby,
    dialect: pick.call(dialect, query.options[:dialect]),
    return: pick.call(return_fields, query.return_fields),
    decode_fields: query.return_fields_decode,
    highlight: pick.call(highlight, query.highlight_options),
    summarize: pick.call(summarize, query.summarize_options),
    verbatim: pick.call(verbatim, query.verbatim_value),
    no_stopwords: pick.call(no_stopwords, query.no_stopwords_value),
    no_content: pick.call(nocontent, query.no_content_value),
    with_scores: pick.call(with_scores, query.options[:withscores]),
    scorer: pick.call(scorer, query.options[:scorer]),
    explain_score: pick.call(explain_score, query.options[:explainscore]),
    language: pick.call(language, query.language_value),
    with_payloads: pick.call(with_payloads, query.with_payloads_value),
    slop: pick.call(slop, query.slop_value),
    in_order: pick.call(in_order, query.in_order_value),
    timeout: query.timeout_value,
    limit_fields: query.limit_fields_value,
    expander: query.expander_value
  }
  substitutions = query_params || params
  options[:params] = substitutions if substitutions

  result = @redis.ft_search(@name, query_string, **options)

  # Strip the index prefix from document IDs if one is set, so callers see the
  # logical doc id they passed to #add rather than the underlying Redis key.
  if @prefix && result.is_a?(SearchResult)
    result.documents.map! do |doc|
      next doc unless doc.id.is_a?(String) && doc.id.start_with?(@prefix)

      Document.new(
        doc.id.delete_prefix(@prefix),
        attributes: doc.attributes, score: doc.score, payload: doc.payload
      )
    end
  end

  result
end

# File 'lib/redis/commands/modules/search/index.rb', line 305

def spellcheck(query, distance: nil, include: nil, exclude: nil)
  @redis.ft_spellcheck(@name, query, distance: distance, include: include, exclude: exclude)
end

# File 'lib/redis/commands/modules/search/index.rb', line 322

def syndump
  @redis.ft_syndump(@name)
end

# File 'lib/redis/commands/modules/search/index.rb', line 315

def synupdate(group_id, *terms, skip_initial_scan: false)
  @redis.ft_synupdate(@name, group_id, *terms, skip_initial_scan: skip_initial_scan)
end

# File 'lib/redis/commands/modules/search/index.rb', line 330

def tagvals(field_name)
  @redis.ft_tagvals(@name, field_name)
end