Module: Redis::Commands::Search

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 316

def ft_aggregate(index_name, query, *args)
  command =
    case query
    when AggregateRequest
      ["FT.AGGREGATE", index_name] + query.to_redis_args
    when Cursor
      ["FT.CURSOR", "READ", index_name] + query.build_args
    else
      # Raw query string: default to DIALECT 2 (matching redis-py) unless one was passed.
      base = ["FT.AGGREGATE", index_name, query, *args]
      base += ["DIALECT", DEFAULT_DIALECT] unless args.flatten.map(&:to_s).include?("DIALECT")
      base
    end

  send_command(command) { |reply| ResultParser.aggregate(reply) }
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 533

def ft_aliasadd(alias_name, index_name)
  send_command(["FT.ALIASADD", alias_name, index_name])
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 550

def ft_aliasdel(alias_name)
  send_command(["FT.ALIASDEL", alias_name])
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 559

def ft_aliaslist(index_name)
  send_command(["FT.ALIASLIST", index_name])
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 542

def ft_aliasupdate(alias_name, index_name)
  send_command(["FT.ALIASUPDATE", alias_name, index_name])
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 349

def ft_alter(index_name, field_or_args)
  args = [index_name, "SCHEMA", "ADD"]
  if field_or_args.respond_to?(:to_args)
    args += field_or_args.to_args
  elsif field_or_args.is_a?(Array)
    args += field_or_args
  else
    raise ArgumentError, "field_or_args must be a Field object or an array"
  end
  send_command([:"FT.ALTER", *args])
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 602

def ft_config_get(option)
  send_command(["FT.CONFIG", "GET", option]) { |reply| ResultParser.config_get(reply) }
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 594

def ft_config_set(option, value)
  send_command(["FT.CONFIG", "SET", option, value])
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 37

def ft_create(
  index_name, schema, storage_type = nil,
  prefix: nil, stopwords: nil, max_text_fields: false,
  skip_initial_scan: false, definition: nil, temporary: nil,
  no_term_offsets: false, no_highlight: false,
  no_field_flags: false, no_term_frequencies: false, **_options
)
  raise ArgumentError, "schema must be a Schema object" unless schema.is_a?(Schema)

  args = [index_name]

  # Use IndexDefinition if provided, otherwise use legacy parameters
  if definition
    # The definition supplies the ON/PREFIX/FILTER clause. When it doesn't declare an index
    # type, fall back to the storage_type keyword so e.g. a JSON index isn't silently created
    # as HASH. Normalize to the uppercase HASH/JSON form some Query Engine versions require.
    args += ["ON", storage_type.to_s.upcase] if definition.index_type.nil? && storage_type
    args += definition.args
  else
    # Normalize the ON token to HASH/JSON; a lowercase value is rejected by some
    # Query Engine versions (and IndexType/the docs use the uppercase form).
    args += ["ON", storage_type.to_s.upcase] if storage_type
    args += ["PREFIX", 1, "#{prefix}:"] if prefix
  end

  args << "MAXTEXTFIELDS" if max_text_fields

  if temporary
    args << "TEMPORARY"
    args << temporary
  end

  args << "NOOFFSETS" if no_term_offsets
  args << "NOHL" if no_highlight
  args << "NOFIELDS" if no_field_flags
  args << "NOFREQS" if no_term_frequencies
  args << "SKIPINITIALSCAN" if skip_initial_scan

  # Stopwords
  if stopwords
    args += ['STOPWORDS', stopwords.size]
    stopwords.each do |stopword|
      args << stopword
    end
  end

  # Schema Fields
  args += ["SCHEMA"]
  schema.fields.each do |field|
    args += field.to_args
  end

  send_command([:"FT.CREATE", *args])
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 376

def ft_cursor_del(index_name, cursor_id)
  send_command(["FT.CURSOR", "DEL", index_name, cursor_id])
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 367

def ft_cursor_read(index_name, cursor_id)
  send_command(["FT.CURSOR", "READ", index_name, cursor_id]) { |reply| ResultParser.aggregate(reply) }
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 568

def ft_dictadd(dict_name, *terms)
  send_command(["FT.DICTADD", dict_name] + terms)
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 577

def ft_dictdel(dict_name, *terms)
  send_command(["FT.DICTDEL", dict_name] + terms)
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 585

def ft_dictdump(dict_name)
  send_command(["FT.DICTDUMP", dict_name])
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 297

def ft_dropindex(index_name, delete_documents: false)
  args = ["FT.DROPINDEX", index_name]
  args << 'DD' if delete_documents
  send_command(args)
end

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

def ft_explain(index_name, query)
  send_command(["FT.EXPLAIN", index_name, query])
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 400

def ft_hybrid_search(
  index_name, query:, combine_method: nil, post_processing: nil,
  params_substitution: nil, timeout: nil, cursor: nil, **_options
)
  args = ["FT.HYBRID", index_name]
  args.concat(query.args)
  args.concat(combine_method.args) if combine_method
  args.concat(post_processing.build_args) if post_processing
  if params_substitution
    args << "PARAMS" << params_substitution.size * 2
    params_substitution.each do |key, value|
      args << key.to_s << value
    end
  end
  args.concat(["TIMEOUT", timeout]) if timeout
  args.concat(cursor.build_args) if cursor
  # NOTE: unlike FT.SEARCH/FT.AGGREGATE, FT.HYBRID does NOT accept a DIALECT token (the
  # server rejects it: "DIALECT is not supported in FT.HYBRID or any of its subqueries").
  # Its legs use the server's search-default-dialect config, so do not append DEFAULT_DIALECT.
  send_command(args) { |reply| ResultParser.hybrid(reply) }
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 288

def ft_info(index_name)
  send_command(["FT.INFO", index_name]) { |reply| ResultParser.hashify_info(reply) }
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 385

def ft_profile(index_name, *args)
  send_command(["FT.PROFILE", index_name] + args)
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 173

def ft_search(index_name, query, **options)
  args = [index_name, query]

  args << "NOCONTENT" if options[:no_content]
  args << "VERBATIM" if options[:verbatim]
  args << "NOSTOPWORDS" if options[:no_stopwords]
  # EXPLAINSCORE requires WITHSCORES, so emit WITHSCORES whenever an explanation is asked for.
  args << "WITHSCORES" if options[:with_scores] || options[:explain_score]
  args << "WITHPAYLOADS" if options[:with_payloads]
  args << "SCORER" << options[:scorer] if options[:scorer]
  args << "EXPLAINSCORE" if options[:explain_score]
  args << "LANGUAGE" << options[:language] if options[:language]
  args << "SLOP" << options[:slop] if options[:slop]
  args << "INORDER" if options[:in_order]
  args << "TIMEOUT" << options[:timeout] if options[:timeout]
  args << "EXPANDER" << options[:expander] if options[:expander]
  if options[:limit_fields] && !options[:limit_fields].empty?
    args << "INFIELDS" << options[:limit_fields].size
    args.concat(options[:limit_fields].map(&:to_s))
  end
  args << "LIMIT" << options[:limit][0] << options[:limit][1] if options[:limit]

  # Handle both :sortby (array format) and :sort_by (convenience format)
  if options[:sortby]
    args << "SORTBY" << options[:sortby][0] << options[:sortby][1]
  elsif options[:sort_by]
    # Default to ASC when :asc is omitted (matching Index#search, Query#sort_by and the
    # server's own SORTBY default); only an explicit asc: false sorts descending.
    direction = options[:asc] == false ? 'DESC' : 'ASC'
    args << "SORTBY" << options[:sort_by] << direction
  end

  options[:filter]&.each do |field, min, max|
    args << "FILTER" << field << min << max
  end

  options[:geo_filter]&.each do |field, lon, lat, radius, unit|
    args << "GEOFILTER" << field << lon << lat << radius << unit
  end

  if options[:limit_ids] && !options[:limit_ids].empty?
    args << "INKEYS" << options[:limit_ids].size
    args.concat(options[:limit_ids])
  end

  if options[:return] && !options[:return].empty?
    args << "RETURN" << options[:return].size
    args.concat(options[:return])
  end

  if options[:summarize]
    args << "SUMMARIZE"
    if options[:summarize][:fields]&.any?
      args << "FIELDS" << options[:summarize][:fields].size
      args.concat(options[:summarize][:fields].map(&:to_s))
    end
    args << "FRAGS" << options[:summarize][:frags] if options[:summarize][:frags]
    args << "LEN" << options[:summarize][:len] if options[:summarize][:len]
    args << "SEPARATOR" << options[:summarize][:separator] if options[:summarize][:separator]
  end

  if options[:highlight]
    args << "HIGHLIGHT"
    if options[:highlight][:fields]&.any?
      args << "FIELDS" << options[:highlight][:fields].size
      args.concat(options[:highlight][:fields].map(&:to_s))
    end
    if options[:highlight][:tags]
      args << "TAGS" << options[:highlight][:tags][0] << options[:highlight][:tags][1]
    end
  end

  if options[:params]
    if options[:params].is_a?(Hash)
      args << "PARAMS" << (options[:params].length * 2)
      options[:params].each do |k, v|
        args << k.to_s << v
      end
    else
      args << "PARAMS" << options[:params].length
      args.concat(options[:params])
    end
  end

  # Default to DIALECT 2 (matching redis-py) unless the caller specified one. An explicit
  # dialect: nil (e.g. flowing from an unset Query option) falls back to the default too, so
  # it behaves the same as omitting the keyword rather than deferring to the server default.
  dialect = options[:dialect] || DEFAULT_DIALECT
  args << "DIALECT" << dialect

  # WITHSCORES is emitted for explain_score too (EXPLAINSCORE requires it), so the RESP2
  # parser must expect a score column in the same cases or it mis-reads the reply layout.
  with_scores = options[:with_scores] || options[:explain_score]
  with_payloads = options[:with_payloads]
  no_content = options[:no_content]
  decode_fields = options[:decode_fields] || {}

  send_command(["FT.SEARCH"] + args.flatten.compact) do |reply|
    ResultParser.search(
      reply,
      with_scores: !!with_scores,
      with_payloads: !!with_payloads,
      no_content: !!no_content,
      decode_fields: decode_fields
    )
  end
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 487

def ft_spellcheck(index_name, query, distance: nil, include: nil, exclude: nil)
  args = ["FT.SPELLCHECK", index_name, query]
  args += ["DISTANCE", distance] if distance
  args += ["TERMS", "INCLUDE", include] if include
  args += ["TERMS", "EXCLUDE", exclude] if exclude

  send_command(args) { |reply| ResultParser.spellcheck(reply) }
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 431

def ft_sugadd(key, string, score, options = {})
  args = ["FT.SUGADD", key, string, score]
  args << 'INCR' if options[:incr]
  args << 'PAYLOAD' << options[:payload] if options[:payload]
  send_command(args)
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 470

def ft_sugdel(key, string)
  send_command(["FT.SUGDEL", key, string])
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 448

def ft_sugget(key, prefix, options = {})
  args = ["FT.SUGGET", key, prefix]
  args << 'FUZZY' if options[:fuzzy]
  args << 'WITHSCORES' if options[:withscores] || options[:with_scores]
  args << 'WITHPAYLOADS' if options[:withpayloads] || options[:with_payloads]
  args << 'MAX' << options[:max] if options[:max]
  send_command(args)
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 461

def ft_suglen(key)
  send_command(["FT.SUGLEN", key])
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 514

def ft_syndump(index_name)
  send_command(["FT.SYNDUMP", index_name]) { |reply| ResultParser.syndump(reply) }
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 503

def ft_synupdate(index_name, group_id, *terms, skip_initial_scan: false)
  args = [index_name, group_id]
  args << "SKIPINITIALSCAN" if skip_initial_scan
  args += terms
  send_command(["FT.SYNUPDATE"] + args)
end

# File 'lib/redis/commands/modules/search/miscellaneous.rb', line 524

def ft_tagvals(index_name, field_name)
  send_command(["FT.TAGVALS", index_name, field_name])
end