sphinx 0.9.10.2122 → 2.1.1.3711

data/lib/sphinx/constants.rb

@@ -24,9 +24,6 @@ module Sphinx
     # status command
     # @private
     SEARCHD_COMMAND_STATUS     = 5
-    # query command
-    # @private
-    SEARCHD_COMMAND_QUERY      = 6
     # flushattrs command
     # @private
     SEARCHD_COMMAND_FLUSHATTRS = 7
@@ -37,13 +34,13 @@ module Sphinx
 
     # search command version
     # @private
-    VER_COMMAND_SEARCH     = 0x117
+    VER_COMMAND_SEARCH     = 0x11D
     # excerpt command version
     # @private
-    VER_COMMAND_EXCERPT    = 0x100
+    VER_COMMAND_EXCERPT    = 0x104
     # update command version
     # @private
-    VER_COMMAND_UPDATE     = 0x102
+    VER_COMMAND_UPDATE     = 0x103
     # keywords command version
     # @private
     VER_COMMAND_KEYWORDS   = 0x100
@@ -116,6 +113,8 @@ module Sphinx
     SPH_RANK_FIELDMASK      = 6
     # codename SPH04, phrase proximity + bm25 + head/exact boost
     SPH_RANK_SPH04          = 7
+    # lets you specify the ranking formula in run time
+    SPH_RANK_EXPR           = 8
 
     #=================================================================
     # Known sort modes
@@ -164,8 +163,12 @@ module Sphinx
     SPH_ATTR_BIGINT    = 6
     # string (binary; in-memory)
     SPH_ATTR_STRING    = 7
+    # ???
+    SPH_ATTR_FACTORS   = 1001
     # this attr has multiple values (0 or more)
-    SPH_ATTR_MULTI     = 0x40000000
+    SPH_ATTR_MULTI     = 0x40000001
+    # this attr has multiple 64-bit values (0 or more)
+    SPH_ATTR_MULTI64   = 0x40000002
 
     #=================================================================
     # Known grouping functions
@@ -183,7 +186,19 @@ module Sphinx
     SPH_GROUPBY_ATTR     = 4
     # group by sequential attrs pair
     SPH_GROUPBY_ATTRPAIR = 5
+
+    #=================================================================
+    # Known query flags
+    #=================================================================
+
+    QUERY_FLAGS = HashWithIndifferentAccess.new(
+      :reverse_scan       => { :values => [ 0, 1 ],                  :index => 0 },
+      :sort_method        => { :values => ['pq', 'kbuffer' ],        :index => 1 },
+      :max_predicted_time => { :values => lambda { |x| x > 0 },      :index => 2 },
+      :boolean_simplify   => { :values => [ false, true ],           :index => 3 },
+      :idf                => { :values => [ 'normalized', 'plain' ], :index => 4 }
+    )
   end
 
   include Constants
-end
+end

data/lib/sphinx/response.rb

@@ -10,17 +10,17 @@ module Sphinx
       @position = 0
       @size = response.length
     end
-    
+
     # Gets current stream position.
     def position
       @position
     end
-    
+
     # Gets response size.
     def size
       @size
     end
-    
+
     # Returns <tt>true</tt> when response stream is out.
     def eof?
       @position >= @size
@@ -50,7 +50,7 @@ module Sphinx
       @position += length
       return values
     end
-    
+
     # Get string from stream.
     def get_string
       length = get_int
@@ -59,7 +59,7 @@ module Sphinx
       @position += length
       return value
     end
-    
+
     # Get float from stream.
     def get_float
       raise EOFError if @position + 4 > @size
@@ -68,4 +68,4 @@ module Sphinx
       return ([uval].pack('L')).unpack('f*').first
     end
   end
-end
+end

data/lib/sphinx/timeout.rb

@@ -12,8 +12,7 @@ module Sphinx
       require 'system_timer'
       Timeout = ::SystemTimer
     end
-  rescue LoadError => e
-    puts "[sphinx] Could not load SystemTimer gem, falling back to Ruby's slower/unsafe timeout library: #{e.message}"
+  rescue LoadError
     require 'timeout'
     Timeout = ::Timeout
   end

data/lib/sphinx/version.rb

@@ -0,0 +1,3 @@
+module Sphinx
+  VERSION = '2.1.1.3711'
+end

data/spec/client_response_spec.rb

@@ -6,30 +6,41 @@ describe Sphinx::Client, 'connected' do
   before :each do
     @sphinx = Sphinx::Client.new
   end
-  
+
+  def mock_sphinx_response(fixture)
+    response = sphinx_fixture(fixture, :response)
+    @sock = SphinxFakeSocket.new(response, 'rb')
+    servers = @sphinx.instance_variable_get(:@servers)
+    servers.first.stub(:get_socket => @sock)
+  end
+
   context 'in Query method' do
     it 'should parse response' do
+      mock_sphinx_response('query')
       result = @sphinx.Query('wifi', 'test1')
       validate_results_wifi(result)
     end
 
     it 'should process 64-bit keys' do
+      mock_sphinx_response('query_id64')
       result = @sphinx.Query('wifi', 'test2')
-      result['total_found'].should == 3
-      result['matches'].length.should == 3
-      result['matches'][0]['id'].should == 4294967298
-      result['matches'][1]['id'].should == 4294967299
-      result['matches'][2]['id'].should == 4294967297
+      result['total_found'].should eq(3)
+      result['matches'].length.should eq(3)
+      result['matches'][0]['id'].should eq(4294967298)
+      result['matches'][1]['id'].should eq(4294967299)
+      result['matches'][2]['id'].should eq(4294967297)
     end
 
     it 'should process errors in Query method' do
+      mock_sphinx_response('query_error')
       @sphinx.Query('wifi', 'fakeindex').should be_false
-      @sphinx.GetLastError.should_not be_empty
+      @sphinx.GetLastError.should =~ /unknown local index/
     end
   end
-  
+
   context 'in RunQueries method' do
     it 'should parse batch-query responce' do
+      mock_sphinx_response('run_queries')
       @sphinx.AddQuery('wifi', 'test1')
       @sphinx.AddQuery('gprs', 'test1')
       results = @sphinx.RunQueries
@@ -39,6 +50,7 @@ describe Sphinx::Client, 'connected' do
     end
 
     it 'should process errors in RunQueries method' do
+      mock_sphinx_response('run_queries_error')
       @sphinx.AddQuery('wifi', 'fakeindex')
       r = @sphinx.RunQueries
       r[0]['error'].should_not be_empty
@@ -47,132 +59,133 @@ describe Sphinx::Client, 'connected' do
 
   context 'in BuildExcerpts method' do
     it 'should parse response' do
+      mock_sphinx_response('build_excerpts')
       result = @sphinx.BuildExcerpts(['what the world', 'London is the capital of Great Britain'], 'test1', 'the')
-      result.should == ['what <b>the</b> world', 'London is <b>the</b> capital of Great Britain']
+      result.should eq(['what <b>the</b> world', 'London is <b>the</b> capital of Great Britain'])
     end
   end
 
   context 'in BuildKeywords method' do
     it 'should parse response' do
+      mock_sphinx_response('build_keywords')
       result = @sphinx.BuildKeywords('wifi gprs', 'test1', true)
-      result.should == [
+      result.should eq([
         { 'normalized' => 'wifi', 'tokenized' => 'wifi', 'hits' => 6, 'docs' => 3 },
         { 'normalized' => 'gprs', 'tokenized' => 'gprs', 'hits' => 1, 'docs' => 1 }
-      ]
+      ])
     end
   end
 
   context 'in UpdateAttributes method' do
     it 'should parse response' do
-      @sphinx.UpdateAttributes('test1', ['group_id'], { 2 => [1] }).should == 1
-      result = @sphinx.Query('wifi', 'test1')
-      result['matches'][0]['attrs']['group_id'].should == 1
-      @sphinx.UpdateAttributes('test1', ['group_id'], { 2 => [2] }).should == 1
-      result = @sphinx.Query('wifi', 'test1')
-      result['matches'][0]['attrs']['group_id'].should == 2
+      mock_sphinx_response('update_attributes')
+      @sphinx.UpdateAttributes('test1', ['group_id'], { 2 => [1] }).should eq(1)
     end
 
     it 'should parse response with MVA' do
-      @sphinx.UpdateAttributes('test1', ['tags'], { 2 => [[1, 2, 3, 4, 5, 6, 7, 8, 9]] }, true).should == 1
-      result = @sphinx.Query('wifi', 'test1')
-      result['matches'][0]['attrs']['tags'].should == [1, 2, 3, 4, 5, 6, 7, 8, 9]
-      @sphinx.UpdateAttributes('test1', ['tags'], { 2 => [[5, 6, 7, 8]] }, true).should == 1
-      result = @sphinx.Query('wifi', 'test1')
-      result['matches'][0]['attrs']['tags'].should == [5, 6, 7, 8]
+      mock_sphinx_response('update_attributes_mva')
+      @sphinx.UpdateAttributes('test1', ['tags'], { 2 => [[1, 2, 3, 4, 5, 6, 7, 8, 9]] }, true).should eq(1)
     end
   end
 
   context 'in Open method' do
     it 'should open socket' do
+      mock_sphinx_response('open')
       @sphinx.Open.should be_true
       socket = @sphinx.servers.first.instance_variable_get(:@socket)
-      socket.should_not be_nil
-      socket.should be_kind_of(Sphinx::BufferedIO)
+      socket.should eq(@sock)
       socket.close
     end
-  
+
     it 'should produce an error when opened twice' do
+      mock_sphinx_response('open')
+      sock = @sock
       @sphinx.Open.should be_true
+      mock_sphinx_response('open_twice')
       @sphinx.Open.should be_false
-      @sphinx.GetLastError.should == 'already connected'
-  
+      @sphinx.GetLastError.should eq('already connected')
+
       socket = @sphinx.servers.first.instance_variable_get(:@socket)
-      socket.should be_kind_of(Sphinx::BufferedIO)
+      socket.should eq(sock)
       socket.close
     end
   end
-  
+
   context 'in Close method' do
     it 'should open socket' do
+      mock_sphinx_response('open')
       @sphinx.Open.should be_true
       @sphinx.Close.should be_true
       @sphinx.servers.first.instance_variable_get(:@socket).should be_nil
     end
-  
+
     it 'should produce socket is closed' do
       @sphinx.Close.should be_false
-      @sphinx.GetLastError.should == 'not connected'
+      @sphinx.GetLastError.should eq('not connected')
       @sphinx.servers.first.instance_variable_get(:@socket).should be_nil
-  
+
+      mock_sphinx_response('open')
       @sphinx.Open.should be_true
       @sphinx.Close.should be_true
       @sphinx.Close.should be_false
-      @sphinx.GetLastError.should == 'not connected'
+      @sphinx.GetLastError.should eq('not connected')
       @sphinx.servers.first.instance_variable_get(:@socket).should be_nil
     end
   end
 
   context 'in Status method' do
     it 'should parse response' do
+      mock_sphinx_response('status')
       response = @sphinx.Status
       response.should be_an(Array)
       response.size.should be > 10
     end
   end
 
-  context 'in FlushAttrs method' do
+  context 'in FlushAttributes method' do
     it 'should not raise an error' do
+      mock_sphinx_response('flush_attributes')
       expect {
-        @sphinx.FlushAttrs
+        @sphinx.FlushAttributes
       }.to_not raise_error
     end
   end
 
   def validate_results_wifi(result)
-    result['total_found'].should == 3
-    result['matches'].length.should == 3
+    result['total_found'].should eq(3)
+    result['matches'].length.should eq(3)
     result['time'].should_not be_nil
-    result['attrs'].should == {
+    result['attrs'].should eq({
       'group_id' => Sphinx::SPH_ATTR_INTEGER,
       'created_at' => Sphinx::SPH_ATTR_TIMESTAMP,
       'rating' => Sphinx::SPH_ATTR_FLOAT,
       'tags' => Sphinx::SPH_ATTR_MULTI | Sphinx::SPH_ATTR_INTEGER
-    }
-    result['fields'].should == [ 'name', 'description' ]
-    result['total'].should == 3
+    })
+    result['fields'].should eq([ 'name', 'description' ])
+    result['total'].should eq(3)
     result['matches'].should be_an_instance_of(Array)
 
-    result['matches'][0]['id'].should == 2
-    result['matches'][0]['weight'].should == 2
-    result['matches'][0]['attrs']['group_id'].should == 2
-    result['matches'][0]['attrs']['created_at'].should == 1175658555
-    result['matches'][0]['attrs']['tags'].should == [5, 6, 7, 8]
-    ('%0.2f' % result['matches'][0]['attrs']['rating']).should == '54.85'
-
-    result['matches'][1]['id'].should == 3
-    result['matches'][1]['weight'].should == 2
-    result['matches'][1]['attrs']['group_id'].should == 1
-    result['matches'][1]['attrs']['created_at'].should == 1175658647
-    result['matches'][1]['attrs']['tags'].should == [1, 7, 9, 10]
-    ('%0.2f' % result['matches'][1]['attrs']['rating']).should == '16.25'
-
-    result['matches'][2]['id'].should == 1
-    result['matches'][2]['weight'].should == 1
-    result['matches'][2]['attrs']['group_id'].should == 1
-    result['matches'][2]['attrs']['created_at'].should == 1175658490
-    result['matches'][2]['attrs']['tags'].should == [1, 2, 3, 4]
-    ('%0.2f' % result['matches'][2]['attrs']['rating']).should == '13.32'
-
-    result['words'].should == { 'wifi' => { 'hits' => 6, 'docs' => 3 } }
+    result['matches'][0]['id'].should eq(2)
+    result['matches'][0]['weight'].should eq(2)
+    result['matches'][0]['attrs']['group_id'].should eq(2)
+    result['matches'][0]['attrs']['created_at'].should eq(1175683755)
+    result['matches'][0]['attrs']['tags'].should eq([5, 6, 7, 8])
+    ('%0.2f' % result['matches'][0]['attrs']['rating']).should eq('54.85')
+
+    result['matches'][1]['id'].should eq(3)
+    result['matches'][1]['weight'].should eq(2)
+    result['matches'][1]['attrs']['group_id'].should eq(1)
+    result['matches'][1]['attrs']['created_at'].should eq(1175683847)
+    result['matches'][1]['attrs']['tags'].should eq([1, 7, 9, 10])
+    ('%0.2f' % result['matches'][1]['attrs']['rating']).should eq('16.25')
+
+    result['matches'][2]['id'].should eq(1)
+    result['matches'][2]['weight'].should eq(1)
+    result['matches'][2]['attrs']['group_id'].should eq(1)
+    result['matches'][2]['attrs']['created_at'].should eq(1175683690)
+    result['matches'][2]['attrs']['tags'].should eq([1, 2, 3, 4])
+    ('%0.2f' % result['matches'][2]['attrs']['rating']).should eq('13.32')
+
+    result['words'].should eq({ 'wifi' => { 'hits' => 6, 'docs' => 3 } })
   end
 end

data/spec/client_spec.rb

@@ -20,7 +20,7 @@ describe Sphinx::Client, 'disconnected' do
         2.times do
           cnt = 0
           expect {
-            @sphinx.send(:with_server) { |server| cnt += 1; server.should == @sphinx.servers[0]; raise Sphinx::SphinxConnectError }
+            @sphinx.send(:with_server) { |server| cnt += 1; server.should eq(@sphinx.servers[0]); raise Sphinx::SphinxConnectError }
           }.to raise_error(Sphinx::SphinxConnectError)
           cnt.should == 1
         end
@@ -29,24 +29,24 @@ describe Sphinx::Client, 'disconnected' do
       it 'should select server based on index' do
         @sphinx.SetServers(@servers)
         cnt = 0
-        @sphinx.send(:with_server, 0) { |server| cnt += 1; server.should == @sphinx.servers[0] }
-        cnt.should == 1
+        @sphinx.send(:with_server, 0) { |server| cnt += 1; server.should eq(@sphinx.servers[0]) }
+        cnt.should eq(1)
         cnt = 0
-        @sphinx.send(:with_server, 1) { |server| cnt += 1; server.should == @sphinx.servers[1] }
-        cnt.should == 1
+        @sphinx.send(:with_server, 1) { |server| cnt += 1; server.should eq(@sphinx.servers[1]) }
+        cnt.should eq(1)
         cnt = 0
-        @sphinx.send(:with_server, 2) { |server| cnt += 1; server.should == @sphinx.servers[0] }
-        cnt.should == 1
+        @sphinx.send(:with_server, 2) { |server| cnt += 1; server.should eq(@sphinx.servers[0]) }
+        cnt.should eq(1)
       end
 
       it 'should select given server' do
         @sphinx.SetServers(@servers)
         cnt = 0
         @sphinx.send(:with_server, @sphinx.servers[0]) { |server| cnt += 1; server.should == @sphinx.servers[0] }
-        cnt.should == 1
+        cnt.should eq(1)
         cnt = 0
         @sphinx.send(:with_server, @sphinx.servers[1]) { |server| cnt += 1; server.should == @sphinx.servers[1] }
-        cnt.should == 1
+        cnt.should eq(1)
       end
     end
 
@@ -58,36 +58,36 @@ describe Sphinx::Client, 'disconnected' do
       it 'should raise an exception on error' do
         cnt = 0
         expect {
-          @sphinx.send(:with_server) { |server| cnt += 1; server.should == @sphinx.servers[0]; raise Sphinx::SphinxConnectError }
+          @sphinx.send(:with_server) { |server| cnt += 1; server.should eq(@sphinx.servers[0]); raise Sphinx::SphinxConnectError }
         }.to raise_error(Sphinx::SphinxConnectError)
-        cnt.should == 3
+        cnt.should eq(3)
       end
 
       it 'should round-robin servers and raise an exception on error' do
         @sphinx.SetServers(@servers)
         cnt = 0
         expect {
-          @sphinx.send(:with_server) { |server| cnt += 1; server.should == @sphinx.servers[(cnt - 1) % 2]; raise Sphinx::SphinxConnectError }
+          @sphinx.send(:with_server) { |server| cnt += 1; server.should eq(@sphinx.servers[(cnt - 1) % 2]); raise Sphinx::SphinxConnectError }
         }.to raise_error(Sphinx::SphinxConnectError)
-        cnt.should == 3
+        cnt.should eq(3)
       end
 
       it 'should round-robin servers with respect to passed index and raise an exception on error' do
         @sphinx.SetServers(@servers)
         cnt = 0
         expect {
-          @sphinx.send(:with_server, 1) { |server| cnt += 1; server.should == @sphinx.servers[cnt % 2]; raise Sphinx::SphinxConnectError }
+          @sphinx.send(:with_server, 1) { |server| cnt += 1; server.should eq(@sphinx.servers[cnt % 2]); raise Sphinx::SphinxConnectError }
         }.to raise_error(Sphinx::SphinxConnectError)
-        cnt.should == 3
+        cnt.should eq(3)
       end
 
       it 'should round-robin with respect to attempts number passed' do
         @sphinx.SetServers(@servers)
         cnt = 0
         expect {
-          @sphinx.send(:with_server, 0, 5) { |server| cnt += 1; server.should == @sphinx.servers[(cnt - 1) % 2]; raise Sphinx::SphinxConnectError }
+          @sphinx.send(:with_server, 0, 5) { |server| cnt += 1; server.should eq(@sphinx.servers[(cnt - 1) % 2]); raise Sphinx::SphinxConnectError }
         }.to raise_error(Sphinx::SphinxConnectError)
-        cnt.should == 5
+        cnt.should eq(5)
       end
     end
   end
@@ -110,7 +110,7 @@ describe Sphinx::Client, 'disconnected' do
         @socket.should_receive(:read).with(4).and_return([1].pack('N'))
         cnt = 0
         @sphinx.send(:with_socket, @server) { |socket| cnt += 1; socket.should == @socket }
-        cnt.should == 1
+        cnt.should eq(1)
       end
 
       it 'should raise exception when searchd protocol is not 1+' do
@@ -120,7 +120,7 @@ describe Sphinx::Client, 'disconnected' do
         expect {
           @sphinx.send(:with_socket, @server) { cnt += 1; }
         }.to raise_error(Sphinx::SphinxConnectError, 'expected searchd protocol version 1+, got version \'0\'')
-        cnt.should == 0
+        cnt.should eq(0)
       end
 
       it 'should handle request timeouts' do
@@ -130,10 +130,10 @@ describe Sphinx::Client, 'disconnected' do
         cnt = 0
         expect {
           @sphinx.send(:with_socket, @server) { cnt += 1; sleep 2 }
-        }.to raise_error(Sphinx::SphinxResponseError, 'failed to read searchd response (msg=time\'s up!)')
-        cnt.should == 1
+        }.to raise_error(Sphinx::SphinxResponseError, 'failed to read searchd response (msg=execution expired)')
+        cnt.should eq(1)
 
-        @sphinx.GetLastError.should == 'failed to read searchd response (msg=time\'s up!)'
+        @sphinx.GetLastError.should eq('failed to read searchd response (msg=execution expired)')
         @sphinx.IsConnectError.should be_false
       end
 
@@ -144,9 +144,9 @@ describe Sphinx::Client, 'disconnected' do
         expect {
           @sphinx.send(:with_socket, @server) { cnt += 1; raise Sphinx::SphinxInternalError, 'hello' }
         }.to raise_error(Sphinx::SphinxInternalError, 'hello')
-        cnt.should == 1
+        cnt.should eq(1)
 
-        @sphinx.GetLastError.should == 'hello'
+        @sphinx.GetLastError.should eq('hello')
         @sphinx.IsConnectError.should be_false
       end
     end
@@ -167,9 +167,9 @@ describe Sphinx::Client, 'disconnected' do
         expect {
           @sphinx.send(:with_socket, @server) { cnt += 1; raise Sphinx::SphinxInternalError, 'hello' }
         }.to raise_error(Sphinx::SphinxInternalError, 'hello')
-        cnt.should == 3
+        cnt.should eq(3)
 
-        @sphinx.GetLastError.should == 'hello'
+        @sphinx.GetLastError.should eq('hello')
         @sphinx.IsConnectError.should be_false
       end
     end
@@ -206,7 +206,7 @@ describe Sphinx::Client, 'disconnected' do
       @socket.should_receive(:read).with(8).and_return([Sphinx::SEARCHD_WARNING, 1, 14].pack('n2N'))
       @socket.should_receive(:read).with(14).and_return([5].pack('N') + 'helloworld')
       @sphinx.send(:parse_response, @socket, 1).should == 'world'
-      @sphinx.GetLastWarning.should == 'hello'
+      @sphinx.GetLastWarning.should eq('hello')
     end
 
     it 'should raise exception when SEARCHD_ERROR received' do
@@ -313,24 +313,26 @@ describe Sphinx::Client, 'disconnected' do
 
     describe 'with rank' do
       [ :proximity_bm25, :bm25, :none, :wordcount, :proximity, :matchany, :fieldmask, :sph04 ].each do |rank|
+        expr = rank == :expr ? '' : 'sum(lcs*user_weight)*1000+bm25'
+
         it "should generate valid request for SPH_RANK_#{rank.to_s.upcase}" do
           expected = sphinx_fixture("ranking_#{rank}")
           @sock.should_receive(:write).with(expected)
-          @sphinx.SetRankingMode(Sphinx::Client.const_get("SPH_RANK_#{rank.to_s.upcase}"))
+          @sphinx.SetRankingMode(Sphinx::Client.const_get("SPH_RANK_#{rank.to_s.upcase}"), expr)
           sphinx_safe_call { @sphinx.Query('query') }
         end
 
         it "should generate valid request for \"#{rank}\"" do
           expected = sphinx_fixture("ranking_#{rank}")
           @sock.should_receive(:write).with(expected)
-          @sphinx.SetRankingMode(rank.to_s)
+          @sphinx.SetRankingMode(rank.to_s, expr)
           sphinx_safe_call { @sphinx.Query('query') }
         end
 
         it "should generate valid request for :#{rank}" do
           expected = sphinx_fixture("ranking_#{rank}")
           @sock.should_receive(:write).with(expected)
-          @sphinx.SetRankingMode(rank)
+          @sphinx.SetRankingMode(rank, expr)
           sphinx_safe_call { @sphinx.Query('query') }
         end
       end
@@ -535,7 +537,7 @@ describe Sphinx::Client, 'disconnected' do
     end
 
     it 'should generate valid request for SetOverride' do
-      expected = sphinx_fixture('set_override')
+      expected = sphinx_fixture('override')
       @sock.should_receive(:write).with(expected)
       @sphinx.SetOverride('attr1', Sphinx::SPH_ATTR_INTEGER, { 10 => 20 })
       @sphinx.SetOverride('attr2', Sphinx::SPH_ATTR_FLOAT, { 11 => 30.3 })
@@ -549,6 +551,41 @@ describe Sphinx::Client, 'disconnected' do
       @sphinx.SetSelect('attr1, attr2')
       sphinx_safe_call { @sphinx.Query('query') }
     end
+
+    it 'should generate valid request for SetOuterSelect' do
+      expected = sphinx_fixture('outer_select')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetOuterSelect('attr', 10, 100)
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request for SetQueryFlag' do
+      expected = sphinx_fixture('query_flag')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetQueryFlag('reverse_scan', 1)
+      @sphinx.SetQueryFlag('sort_method', 'kbuffer')
+      @sphinx.SetQueryFlag('max_predicted_time', 15)
+      @sphinx.SetQueryFlag('boolean_simplify', true)
+      @sphinx.SetQueryFlag('idf', 'plain')
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
+
+    it 'should generate valid request for SetQueryFlag after flag reset' do
+      expected = sphinx_fixture('query_flag_after_reset')
+      @sock.should_receive(:write).with(expected)
+      @sphinx.SetQueryFlag('reverse_scan', 1)
+      @sphinx.SetQueryFlag('sort_method', 'kbuffer')
+      @sphinx.SetQueryFlag('max_predicted_time', 15)
+      @sphinx.SetQueryFlag('boolean_simplify', true)
+      @sphinx.SetQueryFlag('idf', 'plain')
+
+      @sphinx.SetQueryFlag('reverse_scan', 0)
+      @sphinx.SetQueryFlag('sort_method', 'pq')
+      @sphinx.SetQueryFlag('max_predicted_time', 0)
+      @sphinx.SetQueryFlag('boolean_simplify', false)
+      @sphinx.SetQueryFlag('idf', 'normalized')
+      sphinx_safe_call { @sphinx.Query('query') }
+    end
   end
 
   context 'in RunQueries method' do