Class: Sphinx::Client

1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938

# File 'lib/sphinx/client.rb', line 1868

def build_excerpts(docs, index, words, opts = {})
  raise ArgumentError, '"docs" argument must be Array'   unless docs.kind_of?(Array)
  raise ArgumentError, '"index" argument must be String' unless index.kind_of?(String) or index.kind_of?(Symbol)
  raise ArgumentError, '"words" argument must be String' unless words.kind_of?(String)
  raise ArgumentError, '"opts" argument must be Hash'    unless opts.kind_of?(Hash)

  docs.each do |doc|
    raise ArgumentError, '"docs" argument must be Array of Strings' unless doc.kind_of?(String)
  end

  # fixup options
  opts = HashWithIndifferentAccess.new(
    :before_match         => '<b>',
    :after_match          => '</b>',
    :chunk_separator      => ' ... ',
    :limit                => 256,
    :limit_passages       => 0,
    :limit_words          => 0,
    :around               => 5,
    :exact_phrase         => false,
    :single_passage       => false,
    :use_boundaries       => false,
    :weight_order         => false,
    :query_mode           => false,
    :force_all_words      => false,
    :start_passage_id     => 1,
    :load_files           => false,
    :html_strip_mode      => 'index',
    :allow_empty          => false,
    :passage_boundary     => 'none',
    :emit_zones           => false,
    :load_files_scattered => false
  ).update(opts)

  # build request

  # v.1.2 req
  flags  = 1
  flags |= 2    if opts[:exact_phrase]
  flags |= 4    if opts[:single_passage]
  flags |= 8    if opts[:use_boundaries]
  flags |= 16   if opts[:weight_order]
  flags |= 32   if opts[:query_mode]
  flags |= 64   if opts[:force_all_words]
  flags |= 128  if opts[:load_files]
  flags |= 256  if opts[:allow_empty]
  flags |= 512  if opts[:emit_zones]
  flags |= 1024 if opts[:load_files_scattered]

  request = Request.new
  request.put_int 0, flags # mode=0, flags=1 (remove spaces)
  # req index
  request.put_string index.to_s
  # req words
  request.put_string words

  # options
  request.put_string opts[:before_match], opts[:after_match], opts[:chunk_separator]
  request.put_int opts[:limit].to_i, opts[:around].to_i
  request.put_int opts[:limit_passages].to_i, opts[:limit_words].to_i, opts[:start_passage_id].to_i
  request.put_string opts[:html_strip_mode], opts[:passage_boundary]

  # documents
  request.put_int docs.size
  request.put_string(*docs)

  response = perform_request(:excerpt, request)

  # parse response
  docs.map { response.get_string }
end

1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001

# File 'lib/sphinx/client.rb', line 1976

def build_keywords(query, index, hits)
  raise ArgumentError, '"query" argument must be String' unless query.kind_of?(String)
  raise ArgumentError, '"index" argument must be String' unless index.kind_of?(String) or index.kind_of?(Symbol)
  raise ArgumentError, '"hits" argument must be Boolean' unless hits.kind_of?(TrueClass) or hits.kind_of?(FalseClass)

  # build request
  request = Request.new
  # v.1.0 req
  request.put_string query # req query
  request.put_string index # req index
  request.put_int hits ? 1 : 0

  response = perform_request(:keywords, request)

  # parse response
  nwords = response.get_int
  (0...nwords).map do
    tokenized = response.get_string
    normalized = response.get_string

    entry = HashWithIndifferentAccess.new('tokenized' => tokenized, 'normalized' => normalized)
    entry['docs'], entry['hits'] = response.get_ints(2) if hits

    entry
  end
end

2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277

# File 'lib/sphinx/client.rb', line 2265

def close
  if @servers.size > 1
    @error = 'too many servers. persistent socket allowed only for a single server.'
    return false
  end

  unless @servers.first.persistent?
    @error = 'not connected'
    return false;
  end

  @servers.first.close_persistent!
end

199
200
201

# File 'lib/sphinx/client.rb', line 199

def connect_error?
  @connerror || false
end

2123
2124
2125

# File 'lib/sphinx/client.rb', line 2123

def escape_string(string)
  string.to_s.gsub(/([\\()|\-!@~"&\/\^\$=])/, '\\\\\\1')
end

2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198

# File 'lib/sphinx/client.rb', line 2187

def flush_attributes
  request = Request.new
  response = perform_request(:flushattrs, request)

  # parse response
  begin
    response.get_int
  rescue EOFError
    @error = 'unexpected response length'
    -1
  end
end

103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

# File 'lib/sphinx/client.rb', line 103

def inspect
  params = {
    :error => @error,
    :warning => @warning,
    :connect_error => @connerror,
    :servers => @servers,
    :connect_timeout => { :timeout => @timeout, :retries => @retries },
    :request_timeout => { :timeout => @reqtimeout, :retries => @reqretries },
    :retries => { :count => @retrycount, :delay => @retrydelay },
    :limits => { :offset => @offset, :limit => @limit, :max => @maxmatches, :cutoff => @cutoff },
    :max_query_time => @maxquerytime,
    :overrides => @overrides,
    :select => @select,
    :match_mode => @mode,
    :ranking => { :mode => @ranker, :expression => @rankexpr },
    :sort_mode => { :mode => @sort, :sort_by => @sortby },
    :weights => @weights,
    :field_weights => @fieldweights,
    :index_weights => @indexweights,
    :id_range => { :min => @min_id, :max => @max_id },
    :filters => @filters,
    :geo_anchor => @anchor,
    :group_by => { :attribute => @groupby, :func => @groupfunc, :sort => @groupsort },
    :group_distinct => @groupdistinct,
    :query_flags => { :bitset => @query_flags, :predicted_time => @predictedtime },
    :outer_select => { :has_outer => @hasouter, :sort_by => @outerorderby, :offset => @outeroffset, :limit => @outerlimit},
  }

  "<Sphinx::Client: %d servers, params: %s>" % [@servers.length, params.inspect]
end

156
157
158

# File 'lib/sphinx/client.rb', line 156

def last_error
  @error
end

180
181
182

# File 'lib/sphinx/client.rb', line 180

def last_warning
  @warning
end

2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244

# File 'lib/sphinx/client.rb', line 2225

def open
  if @servers.size > 1
    @error = 'too many servers. persistent socket allowed only for a single server.'
    return false
  end

  if @servers.first.persistent?
    @error = 'already connected'
    return false;
  end

  request = Request.new
  request.put_int(1)

  perform_request(:persist, request, nil) do |server, socket|
    server.make_persistent!(socket)
  end

  true
end

2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343

# File 'lib/sphinx/client.rb', line 2306

def perform_request(command, request, additional = nil, server = nil)
  if server
    attempts = 1
  else
    server = case request
      when String
        Zlib.crc32(request)
      when Request
        request.crc32
      else
        raise ArgumentError, "request argument must be String or Sphinx::Request"
    end
    attempts = nil
  end

  with_server(server, attempts) do |srv|
    logger.info { "[sphinx] #{command} on server #{srv}" } if logger

    cmd = command.to_s.upcase
    command_id = Sphinx::Client.const_get("SEARCHD_COMMAND_#{cmd}")
    command_ver = Sphinx::Client.const_get("VER_COMMAND_#{cmd}")

    with_socket(srv) do |socket|
      additional = Array(additional)
      len = request.to_s.length + (additional.size * 4)
      header = [command_id, command_ver, len].pack('nnN')
      header << additional.pack('N' * additional.size) unless additional.empty?

      socket.write(header + request.to_s)

      if block_given?
        yield srv, socket
      else
        parse_response(socket, command_ver)
      end
    end
  end
end

1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483

# File 'lib/sphinx/client.rb', line 1454

def query(query, index = '*', comment = '', &block)
  @reqs = []

  if block_given?
    if block.arity > 0
      yield self
    else
      begin
        @inside_eval = true
        instance_eval(&block)
      ensure
        @inside_eval = false
      end
    end
  end

  logger.debug { "[sphinx] query('#{query}', '#{index}', '#{comment}'), #{self.inspect}" } if logger

  self.add_query(query, index, comment, false)
  results = self.run_queries

  # probably network error; error message should be already filled
  return false unless results.instance_of?(Array)

  @error = results[0]['error']
  @warning = results[0]['warning']

  return false if results[0]['status'] == SEARCHD_ERROR
  return results[0]
end

1293
1294
1295
1296
1297

# File 'lib/sphinx/client.rb', line 1293

def reset_filters
  @filters = []
  @anchor = []
  self
end

1317
1318
1319
1320
1321
1322
1323

# File 'lib/sphinx/client.rb', line 1317

def reset_group_by
  @groupby       = ''
  @groupfunc     = SPH_GROUPBY_DAY
  @groupsort     = '@group desc'
  @groupdistinct = ''
  self
end

1353
1354
1355
1356
1357
1358
1359

# File 'lib/sphinx/client.rb', line 1353

def reset_outer_select
  @outerorderby = ''
  @outeroffset = 0
  @outerlimit = 0
  @hasouter = 0
  self
end

1340
1341
1342
1343

# File 'lib/sphinx/client.rb', line 1340

def reset_overrides
  @overrides = []
  self
end

1346
1347
1348
1349
1350

# File 'lib/sphinx/client.rb', line 1346

def reset_query_flag
  @query_flags = 0
  @predictedtime = 0
  self
end

1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811

# File 'lib/sphinx/client.rb', line 1717

def run_queries
  logger.debug { "[sphinx] run_queries(#{@reqs.length} queries)" } if logger
  if @reqs.empty?
    @error = 'No queries defined, issue add_query() first'
    return false
  end

  reqs, nreqs = @reqs.join(''), @reqs.length
  @reqs = []
  response = perform_request(:search, reqs, [0, nreqs])

  # parse response
  (1..nreqs).map do
    result = HashWithIndifferentAccess.new(:error => '', :warning => '')

    # extract status
    status = result[:status] = response.get_int
    if status != SEARCHD_OK
      message = response.get_string
      if status == SEARCHD_WARNING
        result[:warning] = message
      else
        result[:error] = message
        next result
      end
    end

    # read schema
    nfields = response.get_int
    result[:fields] = (1..nfields).map { response.get_string }

    attrs_names_in_order = []
    nattrs = response.get_int
    attrs = nattrs.times.inject(HashWithIndifferentAccess.new) do |hash, idx|
      name, type = response.get_string, response.get_int
      hash[name] = type
      attrs_names_in_order << name
      hash
    end
    result[:attrs] = attrs

    # read match count
    count, id64 = response.get_ints(2)

    # read matches
    result[:matches] = (1..count).map do
      doc = id64 == 0 ? response.get_int : response.get_int64
      weight = response.get_int

      # This is a single result put in the result['matches'] array
      match = HashWithIndifferentAccess.new(:id => doc, :weight => weight)
      match[:attrs] = attrs_names_in_order.inject(HashWithIndifferentAccess.new) do |hash, name|
        hash[name] = case attrs[name]
          when SPH_ATTR_BIGINT
            # handle 64-bit ints
            response.get_int64
          when SPH_ATTR_FLOAT
            # handle floats
            response.get_float
          when SPH_ATTR_STRING
            # handle string
            response.get_string
          when SPH_ATTR_FACTORS
            # ???
            response.get_int
          when SPH_ATTR_MULTI
            # handle array of integers
            val = response.get_int
            response.get_ints(val) if val > 0
          when SPH_ATTR_MULTI64
            # handle array of 64-bit integers
            val = response.get_int
            (val / 2).times.map { response.get_int64 }
          else
            # handle everything else as unsigned ints
            response.get_int
        end
        hash
      end
      match
    end
    result[:total], result[:total_found], msecs = response.get_ints(3)
    result[:time] = '%.3f' % (msecs / 1000.0)

    nwords = response.get_int
    result[:words] = nwords.times.inject({}) do |hash, idx|
      word = response.get_string
      docs, hits = response.get_ints(2)
      hash[word] = HashWithIndifferentAccess.new(:docs => docs, :hits => hits)
      hash
    end

    result
  end
end

2577
2578
2579
2580
2581
2582
2583
2584
2585

# File 'lib/sphinx/client.rb', line 2577

def set_bit(bitset, index, value)
  bit = 1 << index
  if value == true || value == 1
    bitset |= bit
  elsif bitset & bit > 0
    bitset ^= bit
  end
  bitset
end

333
334
335
336
337
338
339
340
341

# File 'lib/sphinx/client.rb', line 333

def set_connect_timeout(timeout, retries = 1)
  raise ArgumentError, '"timeout" argument must be Integer'        unless timeout.kind_of?(Integer)
  raise ArgumentError, '"retries" argument must be Integer'        unless retries.kind_of?(Integer)
  raise ArgumentError, '"retries" argument must be greater than 0' unless retries > 0

  @timeout = timeout
  @retries = retries
  self
end

882
883
884
885
886
887
888
889
890
891
892

# File 'lib/sphinx/client.rb', line 882

def set_field_weights(weights)
  raise ArgumentError, '"weights" argument must be Hash' unless weights.kind_of?(Hash)
  weights.each do |name, weight|
    unless (name.kind_of?(String) or name.kind_of?(Symbol)) and weight.kind_of?(Integer)
      raise ArgumentError, '"weights" argument must be Hash map of strings to integers'
    end
  end

  @fieldweights = weights
  self
end

1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015

# File 'lib/sphinx/client.rb', line 1004

def set_filter(attribute, values, exclude = false)
  raise ArgumentError, '"attribute" argument must be String or Symbol' unless attribute.kind_of?(String) or attribute.kind_of?(Symbol)
  values = [values] if values.kind_of?(Integer)
  raise ArgumentError, '"values" argument must be Array'               unless values.kind_of?(Array)
  raise ArgumentError, '"values" argument must be Array of Integers'   unless values.all? { |v| v.kind_of?(Integer) }
  raise ArgumentError, '"exclude" argument must be Boolean'            unless [TrueClass, FalseClass].include?(exclude.class)

  if values.any?
    @filters << { 'type' => SPH_FILTER_VALUES, 'attr' => attribute.to_s, 'exclude' => exclude, 'values' => values }
  end
  self
end

1093
1094
1095
1096
1097
1098
1099
1100
1101
1102

# File 'lib/sphinx/client.rb', line 1093

def set_filter_float_range(attribute, min, max, exclude = false)
  raise ArgumentError, '"attribute" argument must be String or Symbol' unless attribute.kind_of?(String) or attribute.kind_of?(Symbol)
  raise ArgumentError, '"min" argument must be Numeric'                unless min.kind_of?(Numeric)
  raise ArgumentError, '"max" argument must be Numeric'                unless max.kind_of?(Numeric)
  raise ArgumentError, '"max" argument greater or equal to "min"'      unless min <= max
  raise ArgumentError, '"exclude" argument must be Boolean'            unless exclude.kind_of?(TrueClass) or exclude.kind_of?(FalseClass)

  @filters << { 'type' => SPH_FILTER_FLOATRANGE, 'attr' => attribute.to_s, 'exclude' => exclude, 'min' => min.to_f, 'max' => max.to_f }
  self
end

1050
1051
1052
1053
1054
1055
1056
1057
1058
1059

# File 'lib/sphinx/client.rb', line 1050

def set_filter_range(attribute, min, max, exclude = false)
  raise ArgumentError, '"attribute" argument must be String or Symbol' unless attribute.kind_of?(String) or attribute.kind_of?(Symbol)
  raise ArgumentError, '"min" argument must be Integer'                unless min.kind_of?(Integer)
  raise ArgumentError, '"max" argument must be Integer'                unless max.kind_of?(Integer)
  raise ArgumentError, '"max" argument greater or equal to "min"'      unless min <= max
  raise ArgumentError, '"exclude" argument must be Boolean'            unless exclude.kind_of?(TrueClass) or exclude.kind_of?(FalseClass)

  @filters << { 'type' => SPH_FILTER_RANGE, 'attr' => attribute.to_s, 'exclude' => exclude, 'min' => min, 'max' => max }
  self
end

1136
1137
1138
1139
1140
1141
1142
1143
1144

# File 'lib/sphinx/client.rb', line 1136

def set_geo_anchor(attrlat, attrlong, lat, long)
  raise ArgumentError, '"attrlat" argument must be String or Symbol'  unless attrlat.kind_of?(String)  or attrlat.kind_of?(Symbol)
  raise ArgumentError, '"attrlong" argument must be String or Symbol' unless attrlong.kind_of?(String) or attrlong.kind_of?(Symbol)
  raise ArgumentError, '"lat" argument must be Numeric'               unless lat.kind_of?(Numeric)
  raise ArgumentError, '"long" argument must be Numeric'              unless long.kind_of?(Numeric)

  @anchor = { 'attrlat' => attrlat.to_s, 'attrlong' => attrlong.to_s, 'lat' => lat.to_f, 'long' => long.to_f }
  self
end

1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220

# File 'lib/sphinx/client.rb', line 1199

def set_group_by(attribute, func, groupsort = '@group desc')
  raise ArgumentError, '"attribute" argument must be String or Symbol' unless attribute.kind_of?(String)  or attribute.kind_of?(Symbol)
  raise ArgumentError, '"groupsort" argument must be String'           unless groupsort.kind_of?(String)

  case func
    when String, Symbol
      begin
        func = self.class.const_get("SPH_GROUPBY_#{func.to_s.upcase}")
      rescue NameError
        raise ArgumentError, "\"func\" argument value \"#{func}\" is invalid"
      end
    when Fixnum
      raise ArgumentError, "\"func\" argument value \"#{func}\" is invalid" unless (SPH_GROUPBY_DAY..SPH_GROUPBY_ATTRPAIR).include?(func)
    else
      raise ArgumentError, '"func" argument must be Fixnum, String, or Symbol'
  end

  @groupby = attribute.to_s
  @groupfunc = func
  @groupsort = groupsort
  self
end

1265
1266
1267
1268
1269
1270

# File 'lib/sphinx/client.rb', line 1265

def set_group_distinct(attribute)
  raise ArgumentError, '"attribute" argument must be String or Symbol' unless attribute.kind_of?(String)  or attribute.kind_of?(Symbol)

  @groupdistinct = attribute.to_s
  self
end

963
964
965
966
967
968
969
970
971

# File 'lib/sphinx/client.rb', line 963

def set_id_range(min, max)
  raise ArgumentError, '"min" argument must be Integer' unless min.kind_of?(Integer)
  raise ArgumentError, '"max" argument must be Integer' unless max.kind_of?(Integer)
  raise ArgumentError, '"max" argument greater or equal to "min"' unless min <= max

  @min_id = min
  @max_id = max
  self
end

928
929
930
931
932
933
934
935
936
937
938

# File 'lib/sphinx/client.rb', line 928

def set_index_weights(weights)
  raise ArgumentError, '"weights" argument must be Hash' unless weights.kind_of?(Hash)
  weights.each do |index, weight|
    unless (index.kind_of?(String) or index.kind_of?(Symbol)) and weight.kind_of?(Integer)
      raise ArgumentError, '"weights" argument must be Hash map of strings to integers'
    end
  end

  @indexweights = weights
  self
end

459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475

# File 'lib/sphinx/client.rb', line 459

def set_limits(offset, limit, max = 0, cutoff = 0)
  raise ArgumentError, '"offset" argument must be Integer' unless offset.kind_of?(Integer)
  raise ArgumentError, '"limit" argument must be Integer'  unless limit.kind_of?(Integer)
  raise ArgumentError, '"max" argument must be Integer'    unless max.kind_of?(Integer)
  raise ArgumentError, '"cutoff" argument must be Integer' unless cutoff.kind_of?(Integer)

  raise ArgumentError, '"offset" argument should be greater or equal to zero' unless offset >= 0
  raise ArgumentError, '"limit" argument should be greater to zero'           unless limit > 0
  raise ArgumentError, '"max" argument should be greater or equal to zero'    unless max >= 0
  raise ArgumentError, '"cutoff" argument should be greater or equal to zero' unless cutoff >= 0

  @offset = offset
  @limit = limit
  @maxmatches = max if max > 0
  @cutoff = cutoff if cutoff > 0
  self
end

698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714

# File 'lib/sphinx/client.rb', line 698

def set_match_mode(mode)
  case mode
    when String, Symbol
      begin
        mode = self.class.const_get("SPH_MATCH_#{mode.to_s.upcase}")
      rescue NameError
        raise ArgumentError, "\"mode\" argument value \"#{mode}\" is invalid"
      end
    when Fixnum
      raise ArgumentError, "\"mode\" argument value \"#{mode}\" is invalid" unless (SPH_MATCH_ALL..SPH_MATCH_EXTENDED2).include?(mode)
    else
      raise ArgumentError, '"mode" argument must be Fixnum, String, or Symbol'
  end

  @mode = mode
  self
end

495
496
497
498
499
500
501

# File 'lib/sphinx/client.rb', line 495

def set_max_query_time(max)
  raise ArgumentError, '"max" argument must be Integer' unless max.kind_of?(Integer)
  raise ArgumentError, '"max" argument should be greater or equal to zero' unless max >= 0

  @maxquerytime = max
  self
end

659
660
661
662
663
664
665
666
667
668
669
670
671
672

# File 'lib/sphinx/client.rb', line 659

def set_outer_select(orderby, offset, limit)
  raise ArgumentError, '"orderby" argument must be String' unless orderby.kind_of?(String)
  raise ArgumentError, '"offset" argument must be Integer' unless offset.kind_of?(Integer)
  raise ArgumentError, '"limit" argument must be Integer'  unless limit.kind_of?(Integer)

  raise ArgumentError, '"offset" argument should be greater or equal to zero' unless offset >= 0
  raise ArgumentError, '"limit" argument should be greater to zero'           unless limit > 0

  @outerorderby = orderby
  @outeroffset = offset
  @outerlimit = limit
  @hasouter = true
  self
end

536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569

# File 'lib/sphinx/client.rb', line 536

def set_override(attribute, attrtype, values)
  raise ArgumentError, '"attribute" argument must be String or Symbol' unless attribute.kind_of?(String) or attribute.kind_of?(Symbol)

  case attrtype
    when String, Symbol
      begin
        attrtype = self.class.const_get("SPH_ATTR_#{attrtype.to_s.upcase}")
      rescue NameError
        raise ArgumentError, "\"attrtype\" argument value \"#{attrtype}\" is invalid"
      end
    when Fixnum
      raise ArgumentError, "\"attrtype\" argument value \"#{attrtype}\" is invalid" unless (SPH_ATTR_INTEGER..SPH_ATTR_BIGINT).include?(attrtype)
    else
      raise ArgumentError, '"attrtype" argument must be Fixnum, String, or Symbol'
  end

  raise ArgumentError, '"values" argument must be Hash' unless values.kind_of?(Hash)

  values.each do |id, value|
    raise ArgumentError, '"values" argument must be Hash map of Integer to Integer or Time' unless id.kind_of?(Integer)
    case attrtype
      when SPH_ATTR_TIMESTAMP
        raise ArgumentError, '"values" argument must be Hash map of Integer to Numeric' unless value.kind_of?(Integer) or value.kind_of?(Time)
      when SPH_ATTR_FLOAT
        raise ArgumentError, '"values" argument must be Hash map of Integer to Numeric' unless value.kind_of?(Numeric)
      else
        # SPH_ATTR_INTEGER, SPH_ATTR_ORDINAL, SPH_ATTR_BOOL, SPH_ATTR_BIGINT
        raise ArgumentError, '"values" argument must be Hash map of Integer to Integer' unless value.kind_of?(Integer)
    end
  end

  @overrides << { 'attr' => attribute.to_s, 'type' => attrtype, 'values' => values }
  self
end

639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656

# File 'lib/sphinx/client.rb', line 639

def set_query_flag(flag_name, flag_value)
  raise ArgumentError, 'unknown "flag_name" argument value' unless QUERY_FLAGS.has_key?(flag_name)

  flag   = QUERY_FLAGS[flag_name]
  values = QUERY_FLAGS[flag_name][:values]

  if flag_name.to_s == 'max_predicted_time'
    raise ArgumentError, "\"flag_value\" should be a positive integer for \"max_predicted_time\" flag" unless flag_value.kind_of?(Integer) and flag_value >= 0

    @predictedtime = flag_value
  elsif !values.include?(flag_value)
    raise ArgumentError, "unknown \"flag_value\", should be one of #{values.inspect}"
  end

  is_set = values.respond_to?(:call) ? values.call(flag_value) : values.index(flag_value) == 1
  @query_flags = set_bit(@query_flags, flag[:index], is_set)
  self
end