thinking-sphinx 3.0.0.pre → 3.0.0.rc

data/spec/acceptance/index_options_spec.rb

@@ -0,0 +1,87 @@
+require 'acceptance/spec_helper'
+
+describe 'Index options' do
+  let(:index) { ThinkingSphinx::ActiveRecord::Index.new(:article) }
+
+  %w( infix prefix ).each do |type|
+    context "all fields are #{type}ed" do
+      before :each do
+        index.definition_block = Proc.new {
+          indexes title
+          set_property "min_#{type}_len".to_sym => 3
+        }
+        index.render
+      end
+
+      it "keeps #{type}_fields blank" do
+        index.send("#{type}_fields").should be_nil
+      end
+
+      it "sets min_#{type}_len" do
+        index.send("min_#{type}_len").should == 3
+      end
+    end
+
+    context "some fields are #{type}ed" do
+      before :each do
+        index.definition_block = Proc.new {
+          indexes title, "#{type}es".to_sym => true
+          indexes content
+          set_property "min_#{type}_len".to_sym => 3
+        }
+        index.render
+      end
+
+      it "#{type}_fields should contain the field" do
+        index.send("#{type}_fields").should == 'title'
+      end
+
+      it "sets min_#{type}_len" do
+        index.send("min_#{type}_len").should == 3
+      end
+    end
+  end
+
+  context "multiple source definitions" do
+    before :each do
+      index.definition_block = Proc.new {
+        define_source do
+          indexes title
+        end
+
+        define_source do
+          indexes title, content
+        end
+      }
+      index.render
+    end
+
+    it "stores each source definition" do
+      index.sources.length.should == 2
+    end
+
+    it "treats each source as separate" do
+      index.sources.first.fields.length.should == 2
+      index.sources.last.fields.length.should  == 3
+    end
+  end
+
+  context 'wordcount fields and attributes' do
+    before :each do
+      index.definition_block = Proc.new {
+        indexes title, :wordcount => true
+
+        has content, :type => :wordcount
+      }
+      index.render
+    end
+
+    it "declares wordcount fields" do
+      index.sources.first.sql_field_str2wordcount.should == ['title']
+    end
+
+    it "declares wordcount attributes" do
+      index.sources.first.sql_attr_str2wordcount.should == ['content']
+    end
+  end
+end

data/spec/acceptance/searching_within_a_model_spec.rb

@@ -40,6 +40,13 @@ describe 'Searching within a model', :live => true do
     articles = Article.search('pancake', :indices => ['stemmed_article_core'])
     articles.to_a.should == [article]
   end
+
+  it "can search on namespaced models" do
+    person = Admin::Person.create :name => 'James Bond'
+    index
+
+    Admin::Person.search('Bond').to_a.should == [person]
+  end
 end
 
 describe 'Searching within a model with a realtime index', :live => true do

data/spec/acceptance/specifying_sql_spec.rb

@@ -24,6 +24,18 @@ describe 'specifying SQL for index definitions' do
     query.should match(/LEFT OUTER JOIN .articles./)
   end
 
+  it "handles has-many :through joins" do
+    index = ThinkingSphinx::ActiveRecord::Index.new(:article)
+    index.definition_block = Proc.new {
+      indexes tags.name
+    }
+    index.render
+
+    query = index.sources.first.sql_query
+    query.should match(/LEFT OUTER JOIN .taggings./)
+    query.should match(/LEFT OUTER JOIN .tags./)
+  end
+
   it "handles GROUP BY clauses" do
     index = ThinkingSphinx::ActiveRecord::Index.new(:article)
     index.definition_block = Proc.new {
@@ -59,4 +71,269 @@ describe 'specifying SQL for index definitions' do
 
     index.sources.first.sql_attr_multi.should == ['uint tag_ids from field']
   end
+
+  it "provides the sanitize_sql helper within the index definition block" do
+    index = ThinkingSphinx::ActiveRecord::Index.new(:article)
+    index.definition_block = Proc.new {
+      indexes title
+      where sanitize_sql(["title != ?", 'secret'])
+    }
+    index.render
+
+    query = index.sources.first.sql_query
+    query.should match(/WHERE .+title != 'secret'.+ GROUP BY/)
+  end
+end
+
+describe 'separate queries for MVAs' do
+  let(:index)  { ThinkingSphinx::ActiveRecord::Index.new(:article) }
+  let(:count)  { ThinkingSphinx::Configuration.instance.indices.count }
+  let(:source) { index.sources.first }
+
+  it "generates an appropriate SQL query for an MVA" do
+    index.definition_block = Proc.new {
+      indexes title
+      has taggings.tag_id, :as => :tag_ids, :source => :query
+    }
+    index.render
+
+    attribute = source.sql_attr_multi.detect { |attribute|
+      attribute[/tag_ids/]
+    }
+    declaration, query = attribute.split(/;\s+/)
+
+    declaration.should == 'uint tag_ids from query'
+    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .taggings.\..tag_id. AS .tag_ids. FROM .taggings.\s?$/)
+  end
+
+  it "generates a SQL query with joins when appropriate for MVAs" do
+    index.definition_block = Proc.new {
+      indexes title
+      has taggings.tag.id, :as => :tag_ids, :source => :query
+    }
+    index.render
+
+    attribute = source.sql_attr_multi.detect { |attribute|
+      attribute[/tag_ids/]
+    }
+    declaration, query = attribute.split(/;\s+/)
+
+    declaration.should == 'uint tag_ids from query'
+    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s?$/)
+  end
+
+  it "respects has_many :through joins for MVA queries" do
+    index.definition_block = Proc.new {
+      indexes title
+      has tags.id, :as => :tag_ids, :source => :query
+    }
+    index.render
+
+    attribute = source.sql_attr_multi.detect { |attribute|
+      attribute[/tag_ids/]
+    }
+    declaration, query = attribute.split(/;\s+/)
+
+    declaration.should == 'uint tag_ids from query'
+    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s?$/)
+  end
+
+  it "can handle multiple joins for MVA queries" do
+    index = ThinkingSphinx::ActiveRecord::Index.new(:user)
+    index.definition_block = Proc.new {
+      indexes name
+      has articles.tags.id, :as => :tag_ids, :source => :query
+    }
+    index.render
+    source = index.sources.first
+
+    attribute = source.sql_attr_multi.detect { |attribute|
+      attribute[/tag_ids/]
+    }
+    declaration, query = attribute.split(/;\s+/)
+
+    declaration.should == 'uint tag_ids from query'
+    query.should match(/^SELECT .articles.\..user_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .articles. INNER JOIN .taggings. ON .taggings.\..article_id. = .articles.\..id. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s?$/)
+  end
+
+  it "can handle HABTM joins for MVA queries" do
+    pending "Efficient HABTM queries are tricky."
+    # We don't really have any need for other tables, but that doesn't lend
+    # itself nicely to Thinking Sphinx's DSL, nor ARel SQL generation. This is
+    # a low priority - manual SQL queries for this situation may work better.
+
+    index = ThinkingSphinx::ActiveRecord::Index.new(:book)
+    index.definition_block = Proc.new {
+      indexes title
+      has genres.id, :as => :genre_ids, :source => :query
+    }
+    index.render
+    source = index.sources.first
+
+    attribute = source.sql_attr_multi.detect { |attribute|
+      attribute[/genre_ids/]
+    }
+    declaration, query = attribute.split(/;\s+/)
+
+    declaration.should == 'uint genre_ids from query'
+    query.should match(/^SELECT .books_genres.\..book_id. \* #{count} \+ #{source.offset} AS .id., .genres.\..id. AS .genre_ids. FROM .books_genres. INNER JOIN .genres. ON .genres.\..id. = .books_genres.\..genre_id.\s?$/)
+  end
+
+  it "generates an appropriate range SQL queries for an MVA" do
+    index.definition_block = Proc.new {
+      indexes title
+      has taggings.tag_id, :as => :tag_ids, :source => :ranged_query
+    }
+    index.render
+
+    attribute = source.sql_attr_multi.detect { |attribute|
+      attribute[/tag_ids/]
+    }
+    declaration, query, range = attribute.split(/;\s+/)
+
+    declaration.should == 'uint tag_ids from ranged-query'
+    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .taggings.\..tag_id. AS .tag_ids. FROM .taggings. \s?WHERE \(.taggings.\..article_id. >= \$start\) AND \(.taggings.\..article_id. <= \$end\)$/)
+    range.should match(/^SELECT MIN\(.taggings.\..article_id.\), MAX\(.taggings.\..article_id.\) FROM .taggings.\s?$/)
+  end
+
+  it "generates a SQL query with joins when appropriate for MVAs" do
+    index.definition_block = Proc.new {
+      indexes title
+      has taggings.tag.id, :as => :tag_ids, :source => :ranged_query
+    }
+    index.render
+
+    attribute = source.sql_attr_multi.detect { |attribute|
+      attribute[/tag_ids/]
+    }
+    declaration, query, range = attribute.split(/;\s+/)
+
+    declaration.should == 'uint tag_ids from ranged-query'
+    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. \s?WHERE \(.taggings.\..article_id. >= \$start\) AND \(.taggings.\..article_id. <= \$end\)$/)
+    range.should match(/^SELECT MIN\(.taggings.\..article_id.\), MAX\(.taggings.\..article_id.\) FROM .taggings.\s?$/)
+  end
+
+  it "respects custom SQL snippets as the query value" do
+    index.definition_block = Proc.new {
+      indexes title
+      has 'My Custom SQL Query', :as => :tag_ids, :source => :query,
+        :type => :integer, :multi => true
+    }
+    index.render
+
+    attribute = source.sql_attr_multi.detect { |attribute|
+      attribute[/tag_ids/]
+    }
+    declaration, query = attribute.split(/;\s+/)
+
+    declaration.should == 'uint tag_ids from query'
+    query.should == 'My Custom SQL Query'
+  end
+
+  it "respects custom SQL snippets as the ranged query value" do
+    index.definition_block = Proc.new {
+      indexes title
+      has 'My Custom SQL Query; And a Range', :as => :tag_ids,
+        :source => :ranged_query, :type => :integer, :multi => true
+    }
+    index.render
+
+    attribute = source.sql_attr_multi.detect { |attribute|
+      attribute[/tag_ids/]
+    }
+    declaration, query, range = attribute.split(/;\s+/)
+
+    declaration.should == 'uint tag_ids from ranged-query'
+    query.should == 'My Custom SQL Query'
+    range.should == 'And a Range'
+  end
+end
+
+describe 'separate queries for field' do
+  let(:index)  { ThinkingSphinx::ActiveRecord::Index.new(:article) }
+  let(:count)  { ThinkingSphinx::Configuration.instance.indices.count }
+  let(:source) { index.sources.first }
+
+  it "generates a SQL query with joins when appropriate for MVF" do
+    index.definition_block = Proc.new {
+      indexes taggings.tag.name, :as => :tags, :source => :query
+    }
+    index.render
+
+    field = source.sql_joined_field.detect { |field| field[/tags/] }
+    declaration, query = field.split(/;\s+/)
+
+    declaration.should == 'tags from query'
+    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. ORDER BY .taggings.\..article_id. ASC\s?$/)
+  end
+
+  it "respects has_many :through joins for MVF queries" do
+    index.definition_block = Proc.new {
+      indexes tags.name, :as => :tags, :source => :query
+    }
+    index.render
+
+    field = source.sql_joined_field.detect { |field| field[/tags/] }
+    declaration, query = field.split(/;\s+/)
+
+    declaration.should == 'tags from query'
+    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. ORDER BY .taggings.\..article_id. ASC\s?$/)
+  end
+
+  it "can handle multiple joins for MVF queries" do
+    index = ThinkingSphinx::ActiveRecord::Index.new(:user)
+    index.definition_block = Proc.new {
+      indexes articles.tags.name, :as => :tags, :source => :query
+    }
+    index.render
+    source = index.sources.first
+
+    field = source.sql_joined_field.detect { |field| field[/tags/] }
+    declaration, query = field.split(/;\s+/)
+
+    declaration.should == 'tags from query'
+    query.should match(/^SELECT .articles.\..user_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .articles. INNER JOIN .taggings. ON .taggings.\..article_id. = .articles.\..id. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. ORDER BY .articles.\..user_id. ASC\s?$/)
+  end
+
+  it "generates a SQL query with joins when appropriate for MVFs" do
+    index.definition_block = Proc.new {
+      indexes taggings.tag.name, :as => :tags, :source => :ranged_query
+    }
+    index.render
+
+    field = source.sql_joined_field.detect { |field| field[/tags/] }
+    declaration, query, range = field.split(/;\s+/)
+
+    declaration.should == 'tags from ranged-query'
+    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. \s?WHERE \(.taggings.\..article_id. >= \$start\) AND \(.taggings.\..article_id. <= \$end\) ORDER BY .taggings.\..article_id. ASC$/)
+    range.should match(/^SELECT MIN\(.taggings.\..article_id.\), MAX\(.taggings.\..article_id.\) FROM .taggings.\s?$/)
+  end
+
+  it "respects custom SQL snippets as the query value" do
+    index.definition_block = Proc.new {
+      indexes 'My Custom SQL Query', :as => :tags, :source => :query
+    }
+    index.render
+
+    field = source.sql_joined_field.detect { |field| field[/tags/] }
+    declaration, query = field.split(/;\s+/)
+
+    declaration.should == 'tags from query'
+    query.should == 'My Custom SQL Query'
+  end
+
+  it "respects custom SQL snippets as the ranged query value" do
+    index.definition_block = Proc.new {
+      indexes 'My Custom SQL Query; And a Range', :as => :tags,
+        :source => :ranged_query
+    }
+    index.render
+
+    field = source.sql_joined_field.detect { |field| field[/tags/] }
+    declaration, query, range = field.split(/;\s+/)
+
+    declaration.should == 'tags from ranged-query'
+    query.should == 'My Custom SQL Query'
+    range.should == 'And a Range'
+  end
 end

data/spec/acceptance/support/sphinx_controller.rb

@@ -8,12 +8,13 @@ class SphinxController
     config.render_to_file && index
 
     ThinkingSphinx::Configuration.reset
-    ActiveSupport::Dependencies.clear
 
-    config.index_paths.each do |path|
-      Dir["#{path}/**/*.rb"].each { |file| $LOADED_FEATURES.delete file }
+    ActiveSupport::Dependencies.loaded.each do |path|
+      $LOADED_FEATURES.delete "#{path}.rb"
     end
 
+    ActiveSupport::Dependencies.clear
+
     config.searchd.mysql41 = 9307
     config.settings['quiet_deltas']      = true
     config.settings['attribute_updates'] = true

data/spec/fixtures/database.yml

@@ -0,0 +1,4 @@
+username: root
+password:
+host: localhost
+database: thinking_sphinx

data/spec/internal/app/indices/admin_person_index.rb

@@ -0,0 +1,3 @@
+ThinkingSphinx::Index.define 'admin/person', :with => :active_record do
+  indexes name
+end

data/spec/internal/app/models/admin/person.rb

@@ -0,0 +1,3 @@
+class Admin::Person < ActiveRecord::Base
+  self.table_name = 'admin_people'
+end

data/spec/internal/app/models/book.rb

@@ -1,6 +1,8 @@
 class Book < ActiveRecord::Base
   include ThinkingSphinx::Scopes
 
+  has_and_belongs_to_many :genres
+
   sphinx_scope(:by_query) { |query| query }
   sphinx_scope(:by_year) do |year|
     {:with => {:year => year}}

data/spec/internal/app/models/genre.rb

@@ -0,0 +1,3 @@
+class Genre < ActiveRecord::Base
+  #
+end

data/spec/internal/db/schema.rb

@@ -1,4 +1,9 @@
 ActiveRecord::Schema.define do
+  create_table(:admin_people, :force => true) do |t|
+    t.string :name
+    t.timestamps
+  end
+
   create_table(:animals, :force => true) do |t|
     t.string :name
     t.string :type
@@ -21,6 +26,11 @@ ActiveRecord::Schema.define do
     t.timestamps
   end
 
+  create_table(:books_genres, :force => true, :id => false) do |t|
+    t.integer :book_id
+    t.integer :genre_id
+  end
+
   create_table(:cities, :force => true) do |t|
     t.string :name
     t.float  :lat
@@ -32,6 +42,10 @@ ActiveRecord::Schema.define do
     t.timestamps
   end
 
+  create_table(:genres, :force => true) do |t|
+    t.string :name
+  end
+
   create_table(:products, :force => true) do |t|
     t.string :name
   end