riddle 1.3.2 → 1.3.3

data/README.textile

@@ -85,3 +85,4 @@ Thanks to the following people who have contributed to Riddle in some shape or f
 * Matt Todd
 * Paco Guzmán
 * Greg Weber
+* Enrico Thierbach

data/lib/riddle.rb

@@ -57,6 +57,7 @@ require 'riddle/auto_version'
 require 'riddle/client'
 require 'riddle/configuration'
 require 'riddle/controller'
+require 'riddle/query'
 
 Riddle.loaded_version = nil
 Riddle::AutoVersion.configure

data/lib/riddle/auto_version.rb

@@ -8,7 +8,7 @@ class Riddle::AutoVersion
       require "riddle/#{version}"
     when /1.10/
       require 'riddle/1.10'
-    when /2.0.1/
+    when /2.0.\d/
       require 'riddle/2.0.1'
     end
   end

data/lib/riddle/client.rb

@@ -254,18 +254,23 @@ module Riddle
           result[:attribute_names] << attribute_name
         end
 
+        result_attribute_names_and_types = result[:attribute_names].
+          inject([]) { |array, attr| array.push([ attr, result[:attributes][attr] ]) }
+
         matches   = response.next_int
         is_64_bit = response.next_int
-        for i in 0...matches
+        
+        result[:matches] = (0...matches).map do |i|
           doc = is_64_bit > 0 ? response.next_64bit_int : response.next_int
           weight = response.next_int
 
-          result[:matches] << {:doc => doc, :weight => weight, :index => i, :attributes => {}}
-          result[:attribute_names].each do |attr|
-            result[:matches].last[:attributes][attr] = attribute_from_type(
-              result[:attributes][attr], response
-            )
+          current_match_attributes = {}
+
+          result_attribute_names_and_types.each do |attr, type|
+            current_match_attributes[attr] = attribute_from_type(type, response)
           end
+          
+          {:doc => doc, :weight => weight, :index => i, :attributes => current_match_attributes}
         end
 
         result[:total] = response.next_int.to_i || 0
@@ -621,7 +626,7 @@ module Riddle
         when :search
           if Versions[command] >= 0x118
             socket.send request_header(command, message.length) + 
-              [messages.length, 0].pack('NN') + message, 0
+              [0, messages.length].pack('NN') + message, 0
           else
             socket.send request_header(command, message.length) +
               [messages.length].pack('N') + message, 0
@@ -803,20 +808,28 @@ module Riddle
       
       message.to_s
     end
+
+    AttributeHandlers = {
+      AttributeTypes[:integer] =>           :next_int,
+      AttributeTypes[:timestamp] =>         :next_int,
+      AttributeTypes[:ordinal] =>           :next_int,
+      AttributeTypes[:bool] =>              :next_int,
+      AttributeTypes[:float] =>             :next_float,
+      AttributeTypes[:bigint] =>            :next_64bit_int,
+      AttributeTypes[:string] =>            :next,
+
+      AttributeTypes[:multi] + AttributeTypes[:integer]   => :next_int_array,
+      AttributeTypes[:multi] + AttributeTypes[:timestamp] => :next_int_array,
+      AttributeTypes[:multi] + AttributeTypes[:ordinal]   => :next_int_array,
+      AttributeTypes[:multi] + AttributeTypes[:bool]      => :next_int_array,
+      AttributeTypes[:multi] + AttributeTypes[:float]     => :next_float_array,
+      AttributeTypes[:multi] + AttributeTypes[:bigint]    => :next_64bit_int_array,
+      AttributeTypes[:multi] + AttributeTypes[:string]    => :next_array
+    }
     
     def attribute_from_type(type, response)
-      type -= AttributeTypes[:multi] if is_multi = type > AttributeTypes[:multi]
-      
-      case type
-      when AttributeTypes[:float]
-        is_multi ? response.next_float_array    : response.next_float
-      when AttributeTypes[:bigint]
-        is_multi ? response.next_64bit_int_arry : response.next_64bit_int
-      when AttributeTypes[:string]
-        is_multi ? response.next_array          : response.next
-      else
-        is_multi ? response.next_int_array      : response.next_int
-      end
+      handler = AttributeHandlers[type]
+      response.send handler
     end
     
     def excerpt_flags(options)

data/lib/riddle/configuration/index.rb

@@ -2,23 +2,25 @@ module Riddle
   class Configuration
     class Index < Riddle::Configuration::Section
       self.settings = [:type, :source, :path, :docinfo, :mlock, :morphology,
-        :min_stemming_len, :stopwords, :wordforms, :exceptions, :min_word_len,
-        :charset_dictpath, :charset_type, :charset_table, :ignore_chars,
-        :min_prefix_len, :min_infix_len, :prefix_fields, :infix_fields,
-        :enable_star, :expand_keywords, :ngram_len, :ngram_chars,
-        :phrase_boundary, :phrase_boundary_step, :blend_chars, :html_strip,
+        :dict, :index_sp, :index_zones, :min_stemming_len, :stopwords,
+        :wordforms, :exceptions, :min_word_len, :charset_dictpath,
+        :charset_type, :charset_table, :ignore_chars, :min_prefix_len,
+        :min_infix_len, :prefix_fields, :infix_fields, :enable_star,
+        :expand_keywords, :ngram_len, :ngram_chars, :phrase_boundary,
+        :phrase_boundary_step, :blend_chars, :blend_mode, :html_strip,
         :html_index_attrs, :html_remove_elements, :preopen, :ondisk_dict,
         :inplace_enable, :inplace_hit_gap, :inplace_docinfo_gap,
         :inplace_reloc_factor, :inplace_write_factor, :index_exact_words,
         :overshort_step, :stopwords_step, :hitless_words]
       
       attr_accessor :name, :parent, :type, :sources, :path, :docinfo, :mlock,
-        :morphologies, :min_stemming_len, :stopword_files, :wordform_files,
-        :exception_files, :min_word_len, :charset_dictpath, :charset_type,
-        :charset_table, :ignore_characters, :min_prefix_len, :min_infix_len,
-        :prefix_field_names, :infix_field_names, :enable_star, :expand_keywords,
-        :ngram_len, :ngram_characters, :phrase_boundaries,
-        :phrase_boundary_step, :blend_chars, :html_strip, :html_index_attrs,
+        :morphologies, :dict, :index_sp, :index_zones, :min_stemming_len,
+        :stopword_files, :wordform_files, :exception_files, :min_word_len,
+        :charset_dictpath, :charset_type, :charset_table, :ignore_characters,
+        :min_prefix_len, :min_infix_len, :prefix_field_names,
+        :infix_field_names, :enable_star, :expand_keywords, :ngram_len,
+        :ngram_characters, :phrase_boundaries, :phrase_boundary_step,
+        :blend_chars, :blend_mode, :html_strip, :html_index_attrs,
         :html_remove_element_tags, :preopen, :ondisk_dict, :inplace_enable,
         :inplace_hit_gap, :inplace_docinfo_gap, :inplace_reloc_factor,
         :inplace_write_factor, :index_exact_words, :overshort_step,

data/lib/riddle/configuration/searchd.rb

@@ -2,13 +2,16 @@ module Riddle
   class Configuration
     class Searchd < Riddle::Configuration::Section
       self.settings = [:listen, :address, :port, :log, :query_log,
-        :read_timeout, :client_timeout, :max_children, :pid_file, :max_matches,
-        :seamless_rotate, :preopen_indexes, :unlink_old, :attr_flush_period,
-        :ondisk_dict_default, :max_packet_size, :mva_updates_pool,
-        :crash_log_path, :max_filters, :max_filter_values, :listen_backlog,
-        :read_buffer, :read_unhinted, :max_batch_queries, :subtree_docs_cache,
-        :subtree_hits_cache, :workers, :dist_threads, :binlog_path,
-        :binlog_flush, :binlog_max_log_size, :client_key]
+        :query_log_format, :read_timeout, :client_timeout, :max_children,
+        :pid_file, :max_matches, :seamless_rotate, :preopen_indexes,
+        :unlink_old, :attr_flush_period, :ondisk_dict_default, :max_packet_size,
+        :mva_updates_pool, :crash_log_path, :max_filters, :max_filter_values,
+        :listen_backlog, :read_buffer, :read_unhinted, :max_batch_queries,
+        :subtree_docs_cache, :subtree_hits_cache, :workers, :dist_threads,
+        :binlog_path, :binlog_flush, :binlog_max_log_size, :collation_server,
+        :collation_libc_locale, :plugin_dir, :mysql_version_string,
+        :rt_flush_period, :thread_stack, :expansion_limit,
+        :compat_sphinxql_magics, :watchdog, :client_key]
       
       attr_accessor *self.settings
             

data/lib/riddle/configuration/sql_source.rb

@@ -8,10 +8,10 @@ module Riddle
         :sql_query_killlist, :sql_attr_uint, :sql_attr_bool, :sql_attr_bigint,
         :sql_attr_timestamp, :sql_attr_str2ordinal, :sql_attr_float,
         :sql_attr_multi, :sql_attr_string, :sql_attr_str2wordcount,
-        :sql_field_string, :sql_field_str2wordcount, :sql_query_post,
-        :sql_query_post_index, :sql_ranged_throttle, :sql_query_info,
-        :mssql_winauth, :mssql_unicode, :unpack_zlib, :unpack_mysqlcompress,
-        :unpack_mysqlcompress_maxsize]
+        :sql_column_buffers, :sql_field_string, :sql_field_str2wordcount,
+        :sql_query_post, :sql_query_post_index, :sql_ranged_throttle,
+        :sql_query_info, :mssql_winauth, :mssql_unicode, :unpack_zlib,
+        :unpack_mysqlcompress, :unpack_mysqlcompress_maxsize]
       
       attr_accessor *self.settings
       

data/lib/riddle/query.rb

@@ -0,0 +1,88 @@
+module Riddle::Query
+  def self.connection(address = '127.0.0.1', port = 9312)
+    require 'mysql2'
+    
+    # If you use localhost, MySQL insists on a socket connection, but Sphinx
+    # requires a TCP connection. Using 127.0.0.1 fixes that.
+    address = '127.0.0.1' if address == 'localhost'
+    
+    Mysql2::Client.new(
+      :host => address,
+      :port => port
+    )
+  end
+  
+  def self.meta
+    'SHOW META'
+  end
+  
+  def self.warnings
+    'SHOW WARNINGS'
+  end
+  
+  def self.status
+    'SHOW STATUS'
+  end
+  
+  def self.tables
+    'SHOW TABLES'
+  end
+  
+  def self.variables
+    'SHOW VARIABLES'
+  end
+  
+  def self.collation
+    'SHOW COLLATION'
+  end
+  
+  def self.describe(index)
+    "DESCRIBE #{index}"
+  end
+  
+  def self.begin
+    'BEGIN'
+  end
+  
+  def self.commit
+    'COMMIT'
+  end
+  
+  def self.rollback
+    'ROLLBACK'
+  end
+  
+  def self.set(variable, values, global = true)
+    values = "(#{values.join(', ')})" if values.is_a?(Array)
+    "SET#{ ' GLOBAL' if global } #{variable} = #{values}"
+  end
+  
+  def self.snippets(data, index, query, options = nil)
+    options = ', ' + options.keys.collect { |key|
+      "#{options[key]} AS #{key}"
+    }.join(', ') unless options.nil?
+    
+    "CALL SNIPPETS('#{data}', '#{index}', '#{query}'#{options})"
+  end
+  
+  def self.create_function(name, type, file)
+    type = type.to_s.upcase
+    "CREATE FUNCTION #{name} RETURNS #{type} SONAME '#{file}'"
+  end
+  
+  def self.drop_function(name)
+    "DROP FUNCTION #{name}"
+  end
+  
+  def self.update(index, id, values = {})
+    values = values.keys.collect { |key|
+      "#{key} = #{values[key]}"
+    }.join(', ')
+    
+    "UPDATE #{index} SET #{values} WHERE id = #{id}"
+  end
+end
+
+require 'riddle/query/delete'
+require 'riddle/query/insert'
+require 'riddle/query/select'

data/lib/riddle/query/delete.rb

@@ -0,0 +1,14 @@
+class Riddle::Query::Delete
+  def initialize(index, *ids)
+    @index = index
+    @ids   = ids.flatten
+  end
+  
+  def to_sql
+    if @ids.length > 1
+      "DELETE FROM #{@index} WHERE id IN (#{@ids.join(', ')})"
+    else
+      "DELETE FROM #{@index} WHERE id = #{@ids.first}"
+    end
+  end
+end

data/lib/riddle/query/insert.rb

@@ -0,0 +1,48 @@
+class Riddle::Query::Insert
+  attr_reader :columns, :values
+  
+  def initialize(index, columns = [], values = [])
+    @index   = index
+    @columns = columns
+    @values  = values.first.is_a?(Array) ? values : [values]
+    @replace = false
+  end
+  
+  def replace!
+    @replace = true
+    self
+  end
+  
+  def to_sql
+    "#{command} INTO #{@index} (#{columns_to_s}) VALUES (#{values_to_s})"
+  end
+  
+  private
+  
+  def command
+    @replace ? 'REPLACE' : 'INSERT'
+  end
+  
+  def columns_to_s
+    columns.join(', ')
+  end
+        
+  def values_to_s
+    values.collect { |value_set|
+      value_set.collect { |value|
+        translated_value(value)
+      }.join(', ')
+    }.join('), (')
+  end
+  
+  def translated_value(value)
+    case value
+    when String
+      "'#{value}'"
+    when TrueClass, FalseClass
+      value ? 1 : 0
+    else
+      value
+    end
+  end
+end

data/lib/riddle/query/select.rb

@@ -0,0 +1,108 @@
+class Riddle::Query::Select
+  def initialize
+    @indices               = []
+    @matching              = nil
+    @wheres                = {}
+    @group_by              = nil
+    @order_by              = nil
+    @order_within_group_by = nil
+    @offset                = nil
+    @limit                 = nil
+    @options               = {}
+  end
+
+  def from(*indices)
+    @indices += indices
+    self
+  end
+
+  def matching(match)
+    @matching = match
+    self
+  end
+
+  def where(filters = {})
+    @wheres.merge!(filters)
+    self
+  end
+
+  def group_by(attribute)
+    @group_by = attribute
+    self
+  end
+
+  def order_by(order)
+    @order_by = order
+    self
+  end
+
+  def order_within_group_by(order)
+    @order_within_group_by = order
+    self
+  end
+
+  def limit(limit)
+    @limit = limit
+    self
+  end
+
+  def offset(offset)
+    @offset = offset
+    self
+  end
+
+  def with_options(options = {})
+    @options.merge! options
+    self
+  end
+
+  def to_sql
+    sql = "SELECT * FROM #{ @indices.join(', ') }"
+    sql << " WHERE #{ combined_wheres }" if wheres?
+    sql << " GROUP BY #{@group_by}"      if !@group_by.nil?
+    sql << " ORDER BY #{@order_by}"      if !@order_by.nil?
+    unless @order_within_group_by.nil?
+      sql << " WITHIN GROUP ORDER BY #{@order_within_group_by}"
+    end
+    sql << " #{limit_clause}"   unless @limit.nil? && @offset.nil?
+    sql << " #{options_clause}" unless @options.empty?
+  
+    sql
+  end
+
+  private
+
+  def wheres?
+    !(@wheres.empty? && @matching.nil?)
+  end
+
+  def combined_wheres
+    if @matching.nil?
+      wheres_to_s
+    elsif @wheres.empty?
+      "MATCH('#{@matching}')"
+    else
+      "MATCH('#{@matching}') AND #{wheres_to_s}"
+    end
+  end
+
+  def wheres_to_s
+    @wheres.keys.collect { |key|
+      "#{key} = #{@wheres[key]}"
+    }.join(' AND ')
+  end
+
+  def limit_clause
+    if @offset.nil?
+      "LIMIT #{@limit}"
+    else
+      "LIMIT #{@offset}, #{@limit || 20}"
+    end
+  end
+
+  def options_clause
+    'OPTION ' + @options.keys.collect { |key|
+      "#{key}=#{@options[key]}"
+    }.join(', ')
+  end
+end

data/spec/functional/excerpt_spec.rb

@@ -60,6 +60,8 @@ not. It's just my name: <em>Pat</em>.
       ]
     when '1.10'
       excerpts.should == [" &#8230;  really long sentence written by <em>Pat</em>. It has to be over &#8230; . This keyword, however, is\nnot. It's just my name: <em>Pat</em> &#8230; "]
+    when '2.0.1'
+      excerpts.should == [" &#8230;  really long sentence written by <em>Pat</em>. It has to be over &#8230; . It's just my name: <em>Pat</em>.\n"]
     else
       excerpts.should == [
         <<-SENTENCE
@@ -105,6 +107,8 @@ not. It's just my name: <em>Pat</em>.
       ]
     when '1.10'
       excerpts.should == [" ---  really long sentence written by <em>Pat</em>. It has to be over --- . This keyword, however, is\nnot. It's just my name: <em>Pat</em> --- "]
+    when '2.0.1'
+      excerpts.should == [" ---  really long sentence written by <em>Pat</em>. It has to be over --- . It's just my name: <em>Pat</em>.\n"]
     else
       excerpts.should == [
         <<-SENTENCE

data/spec/functional/search_spec.rb

@@ -1,42 +1,40 @@
 require 'spec_helper'
 
 describe "Sphinx Searches" do
-  before :each do
-    @client = Riddle::Client.new("localhost", 9313)
-  end
+  let(:client) { Riddle::Client.new 'localhost', 9313 }
   
   it "should return a single hash if a single query" do
-    @client.query("smith").should be_kind_of(Hash)
+    client.query("smith").should be_kind_of(Hash)
   end
   
   it "should return an array of hashs if multiple queries are run" do
-    @client.append_query "smith"
-    @client.append_query "jones"
-    results = @client.run
+    client.append_query "smith"
+    client.append_query "jones"
+    results = client.run
     results.should be_kind_of(Array)
     results.each { |result| result.should be_kind_of(Hash) }
   end
   
   it "should return an array of matches" do
-    matches = @client.query("smith")[:matches]
+    matches = client.query("smith")[:matches]
     matches.should be_kind_of(Array)
     matches.each { |match| match.should be_kind_of(Hash) }
   end
   
   it "should return an array of string fields" do
-    fields = @client.query("smith")[:fields]
+    fields = client.query("smith")[:fields]
     fields.should be_kind_of(Array)
     fields.each { |field| field.should be_kind_of(String) }
   end
   
   it "should return an array of attribute names" do
-    attributes = @client.query("smith")[:attribute_names]
+    attributes = client.query("smith")[:attribute_names]
     attributes.should be_kind_of(Array)
     attributes.each { |a| a.should be_kind_of(String) }
   end
   
   it "should return a hash of attributes" do
-    attributes = @client.query("smith")[:attributes]
+    attributes = client.query("smith")[:attributes]
     attributes.should be_kind_of(Hash)
     attributes.each do |key,value|
       key.should be_kind_of(String)
@@ -45,19 +43,19 @@ describe "Sphinx Searches" do
   end
   
   it "should return the total number of results returned" do
-    @client.query("smith")[:total].should be_kind_of(Integer)
+    client.query("smith")[:total].should be_kind_of(Integer)
   end
   
   it "should return the total number of results available" do
-    @client.query("smith")[:total_found].should be_kind_of(Integer)
+    client.query("smith")[:total_found].should be_kind_of(Integer)
   end
   
   it "should return the time taken for the query as a float" do
-    @client.query("smith")[:time].should be_kind_of(Float)
+    client.query("smith")[:time].should be_kind_of(Float)
   end
   
   it "should return a hash of the words from the query, with the number of documents and the number of hits" do
-    words = @client.query("smith victoria")[:words]
+    words = client.query("smith victoria")[:words]
     words.should be_kind_of(Hash)
     words.each do |word,hash|
       word.should be_kind_of(String)

data/spec/riddle/query/delete_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Riddle::Query::Delete do
+  it 'handles a single id' do
+    query = Riddle::Query::Delete.new 'foo_core', 5
+    query.to_sql.should == 'DELETE FROM foo_core WHERE id = 5'
+  end
+  
+  it 'handles multiple ids' do
+    query = Riddle::Query::Delete.new 'foo_core', 5, 6, 7
+    query.to_sql.should == 'DELETE FROM foo_core WHERE id IN (5, 6, 7)'
+  end
+  
+  it 'handles multiple ids in an explicit array' do
+    query = Riddle::Query::Delete.new 'foo_core', [5, 6, 7]
+    query.to_sql.should == 'DELETE FROM foo_core WHERE id IN (5, 6, 7)'
+  end
+end

data/spec/riddle/query/insert_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Riddle::Query::Insert do
+  it 'handles inserts' do
+    query = Riddle::Query::Insert.new('foo_core', [:id, :deleted], [4, false])
+    query.to_sql.should == 'INSERT INTO foo_core (id, deleted) VALUES (4, 0)'
+  end
+  
+  it 'handles replaces' do
+    query = Riddle::Query::Insert.new('foo_core', [:id, :deleted], [4, false])
+    query.replace!
+    query.to_sql.should == 'REPLACE INTO foo_core (id, deleted) VALUES (4, 0)'
+  end
+  
+  it 'encloses strings in single quotes' do
+    query = Riddle::Query::Insert.new('foo_core', [:id, :name], [4, 'bar'])
+    query.to_sql.should == "INSERT INTO foo_core (id, name) VALUES (4, 'bar')"
+  end
+  
+  it 'handles inserts with more than one set of values' do
+    query = Riddle::Query::Insert.new 'foo_core', [:id, :name], [[4, 'bar'], [5, 'baz']]
+    query.to_sql.
+      should == "INSERT INTO foo_core (id, name) VALUES (4, 'bar'), (5, 'baz')"
+  end
+end

data/spec/riddle/query/select_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Riddle::Query::Select do
+  let(:query) { Riddle::Query::Select.new }
+  
+  it 'handles basic queries on a specific index' do
+    query.from('foo_core').to_sql.should == 'SELECT * FROM foo_core'
+  end
+  
+  it 'handles queries on multiple indices' do
+    query.from('foo_core').from('foo_delta').to_sql.
+      should == 'SELECT * FROM foo_core, foo_delta'
+  end
+  
+  it 'accepts multiple arguments for indices' do
+    query.from('foo_core', 'foo_delta').to_sql.
+      should == 'SELECT * FROM foo_core, foo_delta'
+  end
+  
+  it 'handles basic queries with a search term' do
+    query.from('foo_core').matching('foo').to_sql.
+      should == "SELECT * FROM foo_core WHERE MATCH('foo')"
+  end
+  
+  it 'handles filters with integers' do
+    query.from('foo_core').matching('foo').where(:bar_id => 10).to_sql.
+      should == "SELECT * FROM foo_core WHERE MATCH('foo') AND bar_id = 10"
+  end
+  
+  it 'handles grouping' do
+    query.from('foo_core').group_by('bar_id').to_sql.
+      should == "SELECT * FROM foo_core GROUP BY bar_id"
+  end
+  
+  it 'handles ordering' do
+    query.from('foo_core').order_by('bar_id ASC').to_sql.
+      should == 'SELECT * FROM foo_core ORDER BY bar_id ASC'
+  end
+  
+  it 'handles group ordering' do
+    query.from('foo_core').order_within_group_by('bar_id ASC').to_sql.
+      should == 'SELECT * FROM foo_core WITHIN GROUP ORDER BY bar_id ASC'
+  end
+  
+  it 'handles a limit' do
+    query.from('foo_core').limit(10).to_sql.
+      should == 'SELECT * FROM foo_core LIMIT 10'
+  end
+  
+  it 'handles an offset' do
+    query.from('foo_core').offset(20).to_sql.
+      should == 'SELECT * FROM foo_core LIMIT 20, 20'
+  end
+  
+  it 'handles an option' do
+    query.from('foo_core').with_options(:bar => :baz).to_sql.
+      should == 'SELECT * FROM foo_core OPTION bar=baz'
+  end
+  
+  it 'handles multiple options' do
+    query.from('foo_core').with_options(:bar => :baz, :qux => :quux).to_sql.
+      should == 'SELECT * FROM foo_core OPTION bar=baz, qux=quux'
+  end
+end

data/spec/riddle/query_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Riddle::Query do
+  describe '.connection' do
+    let(:connection) { Riddle::Query.connection 'localhost', 9306 }
+    
+    it "returns a MySQL Client" do
+      connection.should be_a(Mysql2::Client)
+    end
+    
+    it "should handle search requests" do
+      connection.query(Riddle::Query.tables).first.should == {
+        'Index' => 'people', 'Type' => 'local'
+      }
+    end
+  end
+  
+  describe '.set' do
+    it 'handles a single value' do
+      Riddle::Query.set('foo', 'bar').should == 'SET GLOBAL foo = bar'
+    end
+    
+    it 'handles multiple values' do
+      Riddle::Query.set('foo', [1, 2, 3]).should == 'SET GLOBAL foo = (1, 2, 3)'
+    end
+    
+    it 'handles non-global settings' do
+      Riddle::Query.set('foo', 'bar', false).should == 'SET foo = bar'
+    end
+  end
+  
+  describe '.snippets' do
+    it 'handles a basic request' do
+      Riddle::Query.snippets('foo bar baz', 'foo_core', 'foo').
+        should == "CALL SNIPPETS('foo bar baz', 'foo_core', 'foo')"
+    end
+    
+    it 'handles a request with options' do
+      Riddle::Query.snippets('foo bar baz', 'foo_core', 'foo', :around => 5).
+        should == "CALL SNIPPETS('foo bar baz', 'foo_core', 'foo', 5 AS around)"
+    end
+  end
+  
+  describe '.create_function' do
+    it 'handles a basic create request' do
+      Riddle::Query.create_function('foo', :bigint, 'foo.sh').
+        should == "CREATE FUNCTION foo RETURNS BIGINT SONAME 'foo.sh'"
+    end
+  end
+  
+  describe '.update' do
+    it 'handles a basic update request' do
+      Riddle::Query.update('foo_core', 5, :deleted => 1).
+        should == 'UPDATE foo_core SET deleted = 1 WHERE id = 5'
+    end
+  end
+end

data/spec/unit/configuration/searchd_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Riddle::Configuration::Searchd do
-  if Riddle.loaded_version == '0.9.9' || Riddle.loaded_version == '1.10'
+  if Riddle.loaded_version.to_f >= 0.9
     it "should be invalid without a listen or pid_file" do
       searchd = Riddle::Configuration::Searchd.new
       searchd.should_not be_valid
@@ -60,7 +60,7 @@ describe Riddle::Configuration::Searchd do
     searchd.port      = 3312
     searchd.pid_file  = "file.pid"
     
-    if Riddle.loaded_version == '0.9.9' || Riddle.loaded_version == '1.10'
+    if Riddle.loaded_version.to_f >= 0.9
       searchd.render.should == <<-SEARCHD
 searchd
 {
@@ -85,7 +85,7 @@ searchd
     searchd.pid_file   = 'file.pid'
     searchd.client_key = 'secret'
     
-    if Riddle.loaded_version == '0.9.9' || Riddle.loaded_version == '1.10'
+    if Riddle.loaded_version.to_f >= 0.9
       searchd.render.should == <<-SEARCHD
 searchd
 {

metadata

@@ -2,7 +2,7 @@
 name: riddle
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.3.2
+  version: 1.3.3
 platform: ruby
 authors: 
 - Pat Allan
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-12 00:00:00 +10:00
+date: 2011-05-25 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -94,6 +94,10 @@ files:
 - lib/riddle/configuration/sql_source.rb
 - lib/riddle/configuration/xml_source.rb
 - lib/riddle/controller.rb
+- lib/riddle/query.rb
+- lib/riddle/query/delete.rb
+- lib/riddle/query/insert.rb
+- lib/riddle/query/select.rb
 - spec/functional/connection_spec.rb
 - spec/functional/excerpt_spec.rb
 - spec/functional/keywords_spec.rb
@@ -105,6 +109,10 @@ files:
 - spec/riddle/client_spec.rb
 - spec/riddle/configuration_spec.rb
 - spec/riddle/controller_spec.rb
+- spec/riddle/query/delete_spec.rb
+- spec/riddle/query/insert_spec.rb
+- spec/riddle/query/select_spec.rb
+- spec/riddle/query_spec.rb
 - spec/riddle_spec.rb
 - spec/spec_helper.rb
 - spec/sphinx_helper.rb
@@ -136,7 +144,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -2415930395284714044
+      hash: -3668127680877211237
       segments: 
       - 0
       version: "0"
@@ -165,6 +173,10 @@ test_files:
 - spec/riddle/client_spec.rb
 - spec/riddle/configuration_spec.rb
 - spec/riddle/controller_spec.rb
+- spec/riddle/query/delete_spec.rb
+- spec/riddle/query/insert_spec.rb
+- spec/riddle/query/select_spec.rb
+- spec/riddle/query_spec.rb
 - spec/riddle_spec.rb
 - spec/spec_helper.rb
 - spec/sphinx_helper.rb