pg_search 0.2 → 0.2.1

data/CHANGELOG

@@ -1,3 +1,7 @@
+### 0.2.1
+
+ * Backport support for searching against tsvector columns (Kris Hicks)
+
 ### 0.2
 
  * Set dictionary to :simple by default for :tsearch. Before it was unset,

data/README.rdoc

@@ -302,6 +302,32 @@ Ignoring accents uses the {unaccent contrib package}[http://www.postgresql.org/d
   SpanishQuestion.gringo_search("Que") # => [what]
   SpanishQuestion.gringo_search("Cüåñtô") # => [how_many]
 
+=== Using tsvector columns
+
+PostgreSQL allows you the ability to search against a column with type tsvector instead of using an expression; this speeds up searching dramatically as it offloads creation of the tsvector that the tsquery is evaluated against.
+
+To use this functionality you'll need to do a few things:
+
+* Create a column of type tsvector that you'd like to search against. If you want to search using multiple search methods, for example tsearch and dmetaphone, you'll need a column for each.
+* Create a trigger function that will update the column(s) using the expression appropriate for that type of search. See: http://www.postgresql.org/docs/current/static/textsearch-features.html#TEXTSEARCH-UPDATE-TRIGGERS
+* Should you have any pre-existing data in the table, update the newly-created tsvector columns with the expression that your trigger function uses.
+* Add the option to pg_search_scope, e.g:
+
+  pg_search_scope :fast_content_search,
+                  :against => :content,
+                  :using => {
+                    dmetaphone: {
+                      tsvector_column: 'tsvector_content_dmetaphone'
+                    },
+                    tsearch: {
+                      dictionary: 'english',
+                      tsvector_column: 'tsvector_content_tsearch'
+                    }
+                    trigram: {} # trigram does not use tsvectors
+                  }
+
+Please note that the :against column is only used when the tsvector_column is not present for the search type.
+
 == REQUIREMENTS
 
 * ActiveRecord 2 or 3

data/lib/pg_search/features/tsearch.rb

@@ -50,10 +50,14 @@ module PgSearch
       end
 
       def tsdocument
-        @columns.map do |search_column|
-          tsvector = "to_tsvector(:dictionary, #{@normalizer.add_normalization(search_column.to_sql)})"
-          search_column.weight.nil? ? tsvector : "setweight(#{tsvector}, #{connection.quote(search_column.weight)})"
-        end.join(" || ")
+        if @options[:tsvector_column]
+          @options[:tsvector_column].to_s
+        else
+          @columns.map do |search_column|
+            tsvector = "to_tsvector(:dictionary, #{@normalizer.add_normalization(search_column.to_sql)})"
+            search_column.weight.nil? ? tsvector : "setweight(#{tsvector}, #{connection.quote(search_column.weight)})"
+          end.join(" || ")
+        end
       end
 
       def tsearch_rank

data/lib/pg_search/version.rb

@@ -1,3 +1,3 @@
 module PgSearch
-  VERSION = "0.2"
+  VERSION = "0.2.1"
 end

data/spec/associations_spec.rb

@@ -5,13 +5,13 @@ describe PgSearch do
     if defined?(ActiveRecord::Relation)
       context "with Arel support" do
         context "without an :against" do
-          with_model :associated_model do
+          with_model :AssociatedModel do
             table do |t|
               t.string "title"
             end
           end
 
-          with_model :model_without_against do
+          with_model :ModelWithoutAgainst do
             table do |t|
               t.string "title"
               t.belongs_to :another_model
@@ -26,29 +26,29 @@ describe PgSearch do
           end
 
           it "returns rows that match the query in the columns of the associated model only" do
-            associated = associated_model.create!(:title => 'abcdef')
+            associated = AssociatedModel.create!(:title => 'abcdef')
             included = [
-              model_without_against.create!(:title => 'abcdef', :another_model => associated),
-              model_without_against.create!(:title => 'ghijkl', :another_model => associated)
+              ModelWithoutAgainst.create!(:title => 'abcdef', :another_model => associated),
+              ModelWithoutAgainst.create!(:title => 'ghijkl', :another_model => associated)
             ]
             excluded = [
-              model_without_against.create!(:title => 'abcdef')
+              ModelWithoutAgainst.create!(:title => 'abcdef')
             ]
 
-            results = model_without_against.with_another('abcdef')
+            results = ModelWithoutAgainst.with_another('abcdef')
             results.map(&:title).should =~ included.map(&:title)
             results.should_not include(excluded)
           end
         end
 
         context "through a belongs_to association" do
-          with_model :associated_model do
+          with_model :AssociatedModel do
             table do |t|
               t.string 'title'
             end
           end
 
-          with_model :model_with_belongs_to do
+          with_model :ModelWithBelongsTo do
             table do |t|
               t.string 'title'
               t.belongs_to 'another_model'
@@ -63,36 +63,36 @@ describe PgSearch do
           end
 
           it "returns rows that match the query in either its own columns or the columns of the associated model" do
-            associated = associated_model.create!(:title => 'abcdef')
+            associated = AssociatedModel.create!(:title => 'abcdef')
             included = [
-              model_with_belongs_to.create!(:title => 'ghijkl', :another_model => associated),
-              model_with_belongs_to.create!(:title => 'abcdef')
+              ModelWithBelongsTo.create!(:title => 'ghijkl', :another_model => associated),
+              ModelWithBelongsTo.create!(:title => 'abcdef')
             ]
-            excluded = model_with_belongs_to.create!(:title => 'mnopqr',
-                                                     :another_model => associated_model.create!(:title => 'stuvwx'))
+            excluded = ModelWithBelongsTo.create!(:title => 'mnopqr',
+                                                     :another_model => AssociatedModel.create!(:title => 'stuvwx'))
 
-            results = model_with_belongs_to.with_associated('abcdef')
+            results = ModelWithBelongsTo.with_associated('abcdef')
             results.map(&:title).should =~ included.map(&:title)
             results.should_not include(excluded)
           end
         end
 
         context "through a has_many association" do
-          with_model :associated_model_with_has_many do
+          with_model :AssociatedModelWithHasMany do
             table do |t|
               t.string 'title'
-              t.belongs_to 'model_with_has_many'
+              t.belongs_to 'ModelWithHasMany'
             end
           end
 
-          with_model :model_with_has_many do
+          with_model :ModelWithHasMany do
             table do |t|
               t.string 'title'
             end
 
             model do
               include PgSearch
-              has_many :other_models, :class_name => 'AssociatedModelWithHasMany', :foreign_key => 'model_with_has_many_id'
+              has_many :other_models, :class_name => 'AssociatedModelWithHasMany', :foreign_key => 'ModelWithHasMany_id'
 
               pg_search_scope :with_associated, :against => [:title], :associated_against => {:other_models => :title}
             end
@@ -100,21 +100,21 @@ describe PgSearch do
 
           it "returns rows that match the query in either its own columns or the columns of the associated model" do
             included = [
-              model_with_has_many.create!(:title => 'abcdef', :other_models => [
-                                          associated_model_with_has_many.create!(:title => 'foo'),
-                                          associated_model_with_has_many.create!(:title => 'bar')
+              ModelWithHasMany.create!(:title => 'abcdef', :other_models => [
+                                          AssociatedModelWithHasMany.create!(:title => 'foo'),
+                                          AssociatedModelWithHasMany.create!(:title => 'bar')
             ]),
-              model_with_has_many.create!(:title => 'ghijkl', :other_models => [
-                                          associated_model_with_has_many.create!(:title => 'foo bar'),
-                                          associated_model_with_has_many.create!(:title => 'mnopqr')
+              ModelWithHasMany.create!(:title => 'ghijkl', :other_models => [
+                                          AssociatedModelWithHasMany.create!(:title => 'foo bar'),
+                                          AssociatedModelWithHasMany.create!(:title => 'mnopqr')
             ]),
-              model_with_has_many.create!(:title => 'foo bar')
+              ModelWithHasMany.create!(:title => 'foo bar')
             ]
-            excluded = model_with_has_many.create!(:title => 'stuvwx', :other_models => [
-                                                   associated_model_with_has_many.create!(:title => 'abcdef')
+            excluded = ModelWithHasMany.create!(:title => 'stuvwx', :other_models => [
+                                                   AssociatedModelWithHasMany.create!(:title => 'abcdef')
             ])
 
-            results = model_with_has_many.with_associated('foo bar')
+            results = ModelWithHasMany.with_associated('foo bar')
             results.map(&:title).should =~ included.map(&:title)
             results.should_not include(excluded)
           end
@@ -122,7 +122,7 @@ describe PgSearch do
 
         context "across multiple associations" do
           context "on different tables" do
-            with_model :first_associated_model do
+            with_model :FirstAssociatedModel do
               table do |t|
                 t.string 'title'
                 t.belongs_to 'model_with_many_associations'
@@ -130,14 +130,14 @@ describe PgSearch do
               model {}
             end
 
-            with_model :second_associated_model do
+            with_model :SecondAssociatedModel do
               table do |t|
                 t.string 'title'
               end
               model {}
             end
 
-            with_model :model_with_many_associations do
+            with_model :ModelWithManyAssociations do
               table do |t|
                 t.string 'title'
                 t.belongs_to 'model_of_second_type'
@@ -154,24 +154,24 @@ describe PgSearch do
             end
 
             it "returns rows that match the query in either its own columns or the columns of the associated model" do
-              matching_second = second_associated_model.create!(:title => "foo bar")
-              unmatching_second = second_associated_model.create!(:title => "uiop")
+              matching_second = SecondAssociatedModel.create!(:title => "foo bar")
+              unmatching_second = SecondAssociatedModel.create!(:title => "uiop")
 
               included = [
                 ModelWithManyAssociations.create!(:title => 'abcdef', :models_of_first_type => [
-                                                  first_associated_model.create!(:title => 'foo'),
-                                                  first_associated_model.create!(:title => 'bar')
+                                                  FirstAssociatedModel.create!(:title => 'foo'),
+                                                  FirstAssociatedModel.create!(:title => 'bar')
               ]),
                 ModelWithManyAssociations.create!(:title => 'ghijkl', :models_of_first_type => [
-                                                  first_associated_model.create!(:title => 'foo bar'),
-                                                  first_associated_model.create!(:title => 'mnopqr')
+                                                  FirstAssociatedModel.create!(:title => 'foo bar'),
+                                                  FirstAssociatedModel.create!(:title => 'mnopqr')
               ]),
                 ModelWithManyAssociations.create!(:title => 'foo bar'),
                 ModelWithManyAssociations.create!(:title => 'qwerty', :model_of_second_type => matching_second)
               ]
               excluded = [
                 ModelWithManyAssociations.create!(:title => 'stuvwx', :models_of_first_type => [
-                                                  first_associated_model.create!(:title => 'abcdef')
+                                                  FirstAssociatedModel.create!(:title => 'abcdef')
               ]),
                 ModelWithManyAssociations.create!(:title => 'qwerty', :model_of_second_type => unmatching_second)
               ]
@@ -183,7 +183,7 @@ describe PgSearch do
           end
 
           context "on the same table" do
-            with_model :doubly_associated_model do
+            with_model :DoublyAssociatedModel do
               table do |t|
                 t.string 'title'
                 t.belongs_to 'model_with_double_association'
@@ -237,16 +237,16 @@ describe PgSearch do
             end
           end
         end
-        
+
         context "against multiple attributes on one association" do
-          with_model :associated_model do
+          with_model :AssociatedModel do
             table do |t|
               t.string 'title'
               t.text 'author'
             end
           end
 
-          with_model :model_with_association do
+          with_model :ModelWithAssociation do
             table do |t|
               t.belongs_to 'another_model'
             end
@@ -258,7 +258,7 @@ describe PgSearch do
               pg_search_scope :with_associated, :associated_against => {:another_model => [:title, :author]}
             end
           end
-          
+
           it "should only do one join" do
             included = [
               ModelWithAssociation.create!(
@@ -289,12 +289,12 @@ describe PgSearch do
             included.each { |object| results.should include(object) }
             excluded.each { |object| results.should_not include(object) }
           end
-          
+
         end
       end
     else
       context "without Arel support" do
-        with_model :model do
+        with_model :Model do
           table do |t|
             t.string 'title'
           end

data/spec/pg_search_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "an ActiveRecord model which includes PgSearch" do
 
-  with_model :model_with_pg_search do
+  with_model :ModelWithPgSearch do
     table do |t|
       t.string 'title'
       t.text 'content'
@@ -16,18 +16,18 @@ describe "an ActiveRecord model which includes PgSearch" do
 
   describe ".pg_search_scope" do
     it "builds a scope" do
-      model_with_pg_search.class_eval do
+      ModelWithPgSearch.class_eval do
         pg_search_scope "matching_query", :against => []
       end
 
       lambda {
-        model_with_pg_search.scoped({}).matching_query("foo").scoped({})
+        ModelWithPgSearch.scoped({}).matching_query("foo").scoped({})
       }.should_not raise_error
     end
 
     context "when passed a lambda" do
       it "builds a dynamic scope" do
-        model_with_pg_search.class_eval do
+        ModelWithPgSearch.class_eval do
           pg_search_scope :search_title_or_content, lambda { |query, pick_content|
             {
               :query => query.gsub("-remove-", ""),
@@ -36,31 +36,31 @@ describe "an ActiveRecord model which includes PgSearch" do
           }
         end
 
-        included = model_with_pg_search.create!(:title => 'foo', :content => 'bar')
-        excluded = model_with_pg_search.create!(:title => 'bar', :content => 'foo')
+        included = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
+        excluded = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
 
-        model_with_pg_search.search_title_or_content('fo-remove-o', false).should == [included]
-        model_with_pg_search.search_title_or_content('b-remove-ar', true).should == [included]
+        ModelWithPgSearch.search_title_or_content('fo-remove-o', false).should == [included]
+        ModelWithPgSearch.search_title_or_content('b-remove-ar', true).should == [included]
       end
     end
 
     context "when an unknown option is passed in" do
       it "raises an exception when invoked" do
         lambda {
-          model_with_pg_search.class_eval do
+          ModelWithPgSearch.class_eval do
             pg_search_scope :with_unknown_option, :against => :content, :foo => :bar
           end
-          model_with_pg_search.with_unknown_option("foo")
+          ModelWithPgSearch.with_unknown_option("foo")
         }.should raise_error(ArgumentError, /foo/)
       end
 
       context "dynamically" do
         it "raises an exception when invoked" do
           lambda {
-            model_with_pg_search.class_eval do
+            ModelWithPgSearch.class_eval do
               pg_search_scope :with_unknown_option, lambda { |*| {:against => :content, :foo => :bar} }
             end
-            model_with_pg_search.with_unknown_option("foo")
+            ModelWithPgSearch.with_unknown_option("foo")
           }.should raise_error(ArgumentError, /foo/)
         end
       end
@@ -69,20 +69,20 @@ describe "an ActiveRecord model which includes PgSearch" do
     context "when an unknown :using is passed" do
       it "raises an exception when invoked" do
         lambda {
-          model_with_pg_search.class_eval do
+          ModelWithPgSearch.class_eval do
             pg_search_scope :with_unknown_using, :against => :content, :using => :foo
           end
-          model_with_pg_search.with_unknown_using("foo")
+          ModelWithPgSearch.with_unknown_using("foo")
         }.should raise_error(ArgumentError, /foo/)
       end
 
       context "dynamically" do
         it "raises an exception when invoked" do
           lambda {
-            model_with_pg_search.class_eval do
+            ModelWithPgSearch.class_eval do
               pg_search_scope :with_unknown_using, lambda { |*| {:against => :content, :using => :foo} }
             end
-            model_with_pg_search.with_unknown_using("foo")
+            ModelWithPgSearch.with_unknown_using("foo")
           }.should raise_error(ArgumentError, /foo/)
         end
       end
@@ -91,20 +91,20 @@ describe "an ActiveRecord model which includes PgSearch" do
     context "when an unknown :ignoring is passed" do
       it "raises an exception when invoked" do
         lambda {
-          model_with_pg_search.class_eval do
+          ModelWithPgSearch.class_eval do
             pg_search_scope :with_unknown_ignoring, :against => :content, :ignoring => :foo
           end
-          model_with_pg_search.with_unknown_ignoring("foo")
+          ModelWithPgSearch.with_unknown_ignoring("foo")
         }.should raise_error(ArgumentError, /ignoring.*foo/)
       end
 
       context "dynamically" do
         it "raises an exception when invoked" do
           lambda {
-            model_with_pg_search.class_eval do
+            ModelWithPgSearch.class_eval do
               pg_search_scope :with_unknown_ignoring, lambda { |*| {:against => :content, :ignoring => :foo} }
             end
-            model_with_pg_search.with_unknown_ignoring("foo")
+            ModelWithPgSearch.with_unknown_ignoring("foo")
           }.should raise_error(ArgumentError, /ignoring.*foo/)
         end
       end
@@ -112,19 +112,19 @@ describe "an ActiveRecord model which includes PgSearch" do
       context "when :against is not passed in" do
         it "raises an exception when invoked" do
           lambda {
-            model_with_pg_search.class_eval do
+            ModelWithPgSearch.class_eval do
               pg_search_scope :with_unknown_ignoring, {}
             end
-            model_with_pg_search.with_unknown_ignoring("foo")
+            ModelWithPgSearch.with_unknown_ignoring("foo")
           }.should raise_error(ArgumentError, /against/)
         end
         context "dynamically" do
           it "raises an exception when invoked" do
             lambda {
-              model_with_pg_search.class_eval do
+              ModelWithPgSearch.class_eval do
                 pg_search_scope :with_unknown_ignoring, lambda { |*| {} }
               end
-              model_with_pg_search.with_unknown_ignoring("foo")
+              ModelWithPgSearch.with_unknown_ignoring("foo")
             }.should raise_error(ArgumentError, /against/)
           end
         end
@@ -135,33 +135,33 @@ describe "an ActiveRecord model which includes PgSearch" do
   describe "a search scope" do
     context "against a single column" do
       before do
-        model_with_pg_search.class_eval do
+        ModelWithPgSearch.class_eval do
           pg_search_scope :search_content, :against => :content
         end
       end
 
       it "returns an empty array when a blank query is passed in" do
-        model_with_pg_search.create!(:content => 'foo')
+        ModelWithPgSearch.create!(:content => 'foo')
 
-        results = model_with_pg_search.search_content('')
+        results = ModelWithPgSearch.search_content('')
         results.should == []
       end
 
       it "returns rows where the column contains the term in the query" do
-        included = model_with_pg_search.create!(:content => 'foo')
-        excluded = model_with_pg_search.create!(:content => 'bar')
+        included = ModelWithPgSearch.create!(:content => 'foo')
+        excluded = ModelWithPgSearch.create!(:content => 'bar')
 
-        results = model_with_pg_search.search_content('foo')
+        results = ModelWithPgSearch.search_content('foo')
         results.should include(included)
         results.should_not include(excluded)
       end
 
       it "returns rows where the column contains all the terms in the query in any order" do
-        included = [model_with_pg_search.create!(:content => 'foo bar'),
-                    model_with_pg_search.create!(:content => 'bar foo')]
-        excluded = model_with_pg_search.create!(:content => 'foo')
+        included = [ModelWithPgSearch.create!(:content => 'foo bar'),
+                    ModelWithPgSearch.create!(:content => 'bar foo')]
+        excluded = ModelWithPgSearch.create!(:content => 'foo')
 
-        results = model_with_pg_search.search_content('foo bar')
+        results = ModelWithPgSearch.search_content('foo bar')
         results.should =~ included
         results.should_not include(excluded)
       end
@@ -170,10 +170,10 @@ describe "an ActiveRecord model which includes PgSearch" do
         # \303\241 is a with acute accent
         # \303\251 is e with acute accent
 
-        included = [model_with_pg_search.create!(:content => "foo"),
-                    model_with_pg_search.create!(:content => "FOO")]
+        included = [ModelWithPgSearch.create!(:content => "foo"),
+                    ModelWithPgSearch.create!(:content => "FOO")]
 
-        results = model_with_pg_search.search_content("Foo")
+        results = ModelWithPgSearch.search_content("Foo")
         results.should =~ included
       end
 
@@ -181,97 +181,97 @@ describe "an ActiveRecord model which includes PgSearch" do
         # \303\241 is a with acute accent
         # \303\251 is e with acute accent
 
-        included = model_with_pg_search.create!(:content => "abcd\303\251f")
-        excluded = model_with_pg_search.create!(:content => "\303\241bcdef")
+        included = ModelWithPgSearch.create!(:content => "abcd\303\251f")
+        excluded = ModelWithPgSearch.create!(:content => "\303\241bcdef")
 
-        results = model_with_pg_search.search_content("abcd\303\251f")
+        results = ModelWithPgSearch.search_content("abcd\303\251f")
         results.should == [included]
         results.should_not include(excluded)
       end
 
       it "returns rows that match the query but not rows that are prefixed by the query" do
-        included = model_with_pg_search.create!(:content => 'pre')
-        excluded = model_with_pg_search.create!(:content => 'prefix')
+        included = ModelWithPgSearch.create!(:content => 'pre')
+        excluded = ModelWithPgSearch.create!(:content => 'prefix')
 
-        results = model_with_pg_search.search_content("pre")
+        results = ModelWithPgSearch.search_content("pre")
         results.should == [included]
         results.should_not include(excluded)
       end
 
       it "returns rows that match the query exactly and not those that match the query when stemmed by the default english dictionary" do
-        included = model_with_pg_search.create!(:content => "jumped")
-        excluded = [model_with_pg_search.create!(:content => "jump"),
-                    model_with_pg_search.create!(:content => "jumping")]
+        included = ModelWithPgSearch.create!(:content => "jumped")
+        excluded = [ModelWithPgSearch.create!(:content => "jump"),
+                    ModelWithPgSearch.create!(:content => "jumping")]
 
-        results = model_with_pg_search.search_content("jumped")
+        results = ModelWithPgSearch.search_content("jumped")
         results.should == [included]
       end
 
       it "returns rows that match sorted by rank" do
-        loser = model_with_pg_search.create!(:content => 'foo')
-        winner = model_with_pg_search.create!(:content => 'foo foo')
+        loser = ModelWithPgSearch.create!(:content => 'foo')
+        winner = ModelWithPgSearch.create!(:content => 'foo foo')
 
-        results = model_with_pg_search.search_content("foo")
+        results = ModelWithPgSearch.search_content("foo")
         results[0].rank.should > results[1].rank
         results.should == [winner, loser]
       end
 
       it "returns results that match sorted by primary key for records that rank the same" do
-        sorted_results = [model_with_pg_search.create!(:content => 'foo'),
-                          model_with_pg_search.create!(:content => 'foo')].sort_by(&:id)
+        sorted_results = [ModelWithPgSearch.create!(:content => 'foo'),
+                          ModelWithPgSearch.create!(:content => 'foo')].sort_by(&:id)
 
-        results = model_with_pg_search.search_content("foo")
+        results = ModelWithPgSearch.search_content("foo")
         results.should == sorted_results
       end
 
       it "returns results that match a query with multiple space-separated search terms" do
         included = [
-          model_with_pg_search.create!(:content => 'foo bar'),
-          model_with_pg_search.create!(:content => 'bar foo'),
-          model_with_pg_search.create!(:content => 'bar foo baz'),
+          ModelWithPgSearch.create!(:content => 'foo bar'),
+          ModelWithPgSearch.create!(:content => 'bar foo'),
+          ModelWithPgSearch.create!(:content => 'bar foo baz'),
         ]
         excluded = [
-          model_with_pg_search.create!(:content => 'foo'),
-          model_with_pg_search.create!(:content => 'foo baz')
+          ModelWithPgSearch.create!(:content => 'foo'),
+          ModelWithPgSearch.create!(:content => 'foo baz')
         ]
 
-        results = model_with_pg_search.search_content('foo bar')
+        results = ModelWithPgSearch.search_content('foo bar')
         results.should =~ included
         results.should_not include(excluded)
       end
 
       it "returns rows that match a query with characters that are invalid in a tsquery expression" do
-        included = model_with_pg_search.create!(:content => "(:Foo.) Bar?, \\")
+        included = ModelWithPgSearch.create!(:content => "(:Foo.) Bar?, \\")
 
-        results = model_with_pg_search.search_content("foo :bar .,?() \\")
+        results = ModelWithPgSearch.search_content("foo :bar .,?() \\")
         results.should == [included]
       end
 
       it "accepts non-string queries and calls #to_s on them" do
-        foo = model_with_pg_search.create!(:content => "foo")
+        foo = ModelWithPgSearch.create!(:content => "foo")
         not_a_string = stub(:to_s => "foo")
-        model_with_pg_search.search_content(not_a_string).should == [foo]
+        ModelWithPgSearch.search_content(not_a_string).should == [foo]
       end
     end
 
     context "against multiple columns" do
       before do
-        model_with_pg_search.class_eval do
+        ModelWithPgSearch.class_eval do
           pg_search_scope :search_title_and_content, :against => [:title, :content]
         end
       end
 
       it "returns rows whose columns contain all of the terms in the query across columns" do
         included = [
-          model_with_pg_search.create!(:title => 'foo', :content => 'bar'),
-          model_with_pg_search.create!(:title => 'bar', :content => 'foo')
+          ModelWithPgSearch.create!(:title => 'foo', :content => 'bar'),
+          ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
         ]
         excluded = [
-          model_with_pg_search.create!(:title => 'foo', :content => 'foo'),
-          model_with_pg_search.create!(:title => 'bar', :content => 'bar')
+          ModelWithPgSearch.create!(:title => 'foo', :content => 'foo'),
+          ModelWithPgSearch.create!(:title => 'bar', :content => 'bar')
         ]
 
-        results = model_with_pg_search.search_title_and_content('foo bar')
+        results = ModelWithPgSearch.search_title_and_content('foo bar')
 
         results.should =~ included
         excluded.each do |result|
@@ -280,37 +280,37 @@ describe "an ActiveRecord model which includes PgSearch" do
       end
 
       it "returns rows where at one column contains all of the terms in the query and another does not" do
-        in_title = model_with_pg_search.create!(:title => 'foo', :content => 'bar')
-        in_content = model_with_pg_search.create!(:title => 'bar', :content => 'foo')
+        in_title = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
+        in_content = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
 
-        results  = model_with_pg_search.search_title_and_content('foo')
+        results  = ModelWithPgSearch.search_title_and_content('foo')
         results.should =~ [in_title, in_content]
       end
 
       # Searching with a NULL column will prevent any matches unless we coalesce it.
       it "returns rows where at one column contains all of the terms in the query and another is NULL" do
-        included = model_with_pg_search.create!(:title => 'foo', :content => nil)
-        results  = model_with_pg_search.search_title_and_content('foo')
+        included = ModelWithPgSearch.create!(:title => 'foo', :content => nil)
+        results  = ModelWithPgSearch.search_title_and_content('foo')
         results.should == [included]
       end
     end
 
     context "using trigram" do
       before do
-        model_with_pg_search.class_eval do
+        ModelWithPgSearch.class_eval do
           pg_search_scope :with_trigrams, :against => [:title, :content], :using => :trigram
         end
       end
 
       it "returns rows where one searchable column and the query share enough trigrams" do
-        included = model_with_pg_search.create!(:title => 'abcdefghijkl', :content => nil)
-        results = model_with_pg_search.with_trigrams('cdefhijkl')
+        included = ModelWithPgSearch.create!(:title => 'abcdefghijkl', :content => nil)
+        results = ModelWithPgSearch.with_trigrams('cdefhijkl')
         results.should == [included]
       end
 
       it "returns rows where multiple searchable columns and the query share enough trigrams" do
-        included = model_with_pg_search.create!(:title => 'abcdef', :content => 'ghijkl')
-        results = model_with_pg_search.with_trigrams('cdefhijkl')
+        included = ModelWithPgSearch.create!(:title => 'abcdef', :content => 'ghijkl')
+        results = ModelWithPgSearch.with_trigrams('cdefhijkl')
         results.should == [included]
       end
     end
@@ -318,7 +318,7 @@ describe "an ActiveRecord model which includes PgSearch" do
     context "using tsearch" do
       context "with :prefix => true" do
         before do
-          model_with_pg_search.class_eval do
+          ModelWithPgSearch.class_eval do
             pg_search_scope :search_title_with_prefixes,
                             :against => :title,
                             :using => {
@@ -328,22 +328,22 @@ describe "an ActiveRecord model which includes PgSearch" do
         end
 
         it "returns rows that match the query and that are prefixed by the query" do
-          included = model_with_pg_search.create!(:title => 'prefix')
-          excluded = model_with_pg_search.create!(:title => 'postfix')
+          included = ModelWithPgSearch.create!(:title => 'prefix')
+          excluded = ModelWithPgSearch.create!(:title => 'postfix')
 
-          results = model_with_pg_search.search_title_with_prefixes("pre")
+          results = ModelWithPgSearch.search_title_with_prefixes("pre")
           results.should == [included]
           results.should_not include(excluded)
         end
 
         it "returns rows that match the query when the query has a hyphen" do
           included = [
-            model_with_pg_search.create!(:title => 'foo bar'),
-            model_with_pg_search.create!(:title => 'foo-bar')
+            ModelWithPgSearch.create!(:title => 'foo bar'),
+            ModelWithPgSearch.create!(:title => 'foo-bar')
           ]
-          excluded = model_with_pg_search.create!(:title => 'baz quux')
+          excluded = ModelWithPgSearch.create!(:title => 'baz quux')
 
-          results = model_with_pg_search.search_title_with_prefixes("foo-bar")
+          results = ModelWithPgSearch.search_title_with_prefixes("foo-bar")
           results.should =~ included
           results.should_not include(excluded)
         end
@@ -351,7 +351,7 @@ describe "an ActiveRecord model which includes PgSearch" do
 
       context "with the english dictionary" do
         before do
-          model_with_pg_search.class_eval do
+          ModelWithPgSearch.class_eval do
             pg_search_scope :search_content_with_english,
                             :against => :content,
                             :using => {
@@ -361,27 +361,27 @@ describe "an ActiveRecord model which includes PgSearch" do
         end
 
         it "returns rows that match the query when stemmed by the english dictionary" do
-          included = [model_with_pg_search.create!(:content => "jump"),
-                      model_with_pg_search.create!(:content => "jumped"),
-                      model_with_pg_search.create!(:content => "jumping")]
+          included = [ModelWithPgSearch.create!(:content => "jump"),
+                      ModelWithPgSearch.create!(:content => "jumped"),
+                      ModelWithPgSearch.create!(:content => "jumping")]
 
-          results = model_with_pg_search.search_content_with_english("jump")
+          results = ModelWithPgSearch.search_content_with_english("jump")
           results.should =~ included
         end
       end
 
       context "against columns ranked with arrays" do
         before do
-          model_with_pg_search.class_eval do
+          ModelWithPgSearch.class_eval do
              pg_search_scope :search_weighted_by_array_of_arrays, :against => [[:content, 'B'], [:title, 'A']]
            end
         end
 
         it "returns results sorted by weighted rank" do
-          loser = model_with_pg_search.create!(:title => 'bar', :content => 'foo')
-          winner = model_with_pg_search.create!(:title => 'foo', :content => 'bar')
+          loser = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
+          winner = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
 
-          results = model_with_pg_search.search_weighted_by_array_of_arrays('foo')
+          results = ModelWithPgSearch.search_weighted_by_array_of_arrays('foo')
           results[0].rank.should > results[1].rank
           results.should == [winner, loser]
         end
@@ -389,16 +389,16 @@ describe "an ActiveRecord model which includes PgSearch" do
 
       context "against columns ranked with a hash" do
         before do
-          model_with_pg_search.class_eval do
+          ModelWithPgSearch.class_eval do
             pg_search_scope :search_weighted_by_hash, :against => {:content => 'B', :title => 'A'}
           end
         end
 
         it "returns results sorted by weighted rank" do
-          loser = model_with_pg_search.create!(:title => 'bar', :content => 'foo')
-          winner = model_with_pg_search.create!(:title => 'foo', :content => 'bar')
+          loser = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
+          winner = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
 
-          results = model_with_pg_search.search_weighted_by_hash('foo')
+          results = ModelWithPgSearch.search_weighted_by_hash('foo')
           results[0].rank.should > results[1].rank
           results.should == [winner, loser]
         end
@@ -406,16 +406,16 @@ describe "an ActiveRecord model which includes PgSearch" do
 
       context "against columns of which only some are ranked" do
         before do
-          model_with_pg_search.class_eval do
+          ModelWithPgSearch.class_eval do
             pg_search_scope :search_weighted, :against => [:content, [:title, 'A']]
           end
         end
 
         it "returns results sorted by weighted rank using an implied low rank for unranked columns" do
-          loser = model_with_pg_search.create!(:title => 'bar', :content => 'foo')
-          winner = model_with_pg_search.create!(:title => 'foo', :content => 'bar')
+          loser = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
+          winner = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
 
-          results = model_with_pg_search.search_weighted('foo')
+          results = ModelWithPgSearch.search_weighted('foo')
           results[0].rank.should > results[1].rank
           results.should == [winner, loser]
         end
@@ -424,46 +424,46 @@ describe "an ActiveRecord model which includes PgSearch" do
 
     context "using dmetaphone" do
       before do
-        model_with_pg_search.class_eval do
+        ModelWithPgSearch.class_eval do
           pg_search_scope :with_dmetaphones, :against => [:title, :content], :using => :dmetaphone
         end
       end
 
       it "returns rows where one searchable column and the query share enough dmetaphones" do
-        included = model_with_pg_search.create!(:title => 'Geoff', :content => nil)
-        excluded = model_with_pg_search.create!(:title => 'Bob', :content => nil)
-        results = model_with_pg_search.with_dmetaphones('Jeff')
+        included = ModelWithPgSearch.create!(:title => 'Geoff', :content => nil)
+        excluded = ModelWithPgSearch.create!(:title => 'Bob', :content => nil)
+        results = ModelWithPgSearch.with_dmetaphones('Jeff')
         results.should == [included]
       end
 
       it "returns rows where multiple searchable columns and the query share enough dmetaphones" do
-        included = model_with_pg_search.create!(:title => 'Geoff', :content => 'George')
-        excluded = model_with_pg_search.create!(:title => 'Bob', :content => 'Jones')
-        results = model_with_pg_search.with_dmetaphones('Jeff Jorge')
+        included = ModelWithPgSearch.create!(:title => 'Geoff', :content => 'George')
+        excluded = ModelWithPgSearch.create!(:title => 'Bob', :content => 'Jones')
+        results = ModelWithPgSearch.with_dmetaphones('Jeff Jorge')
         results.should == [included]
       end
 
       it "returns rows that match dmetaphones that are English stopwords" do
-        included = model_with_pg_search.create!(:title => 'White', :content => nil)
-        excluded = model_with_pg_search.create!(:title => 'Black', :content => nil)
-        results = model_with_pg_search.with_dmetaphones('Wight')
+        included = ModelWithPgSearch.create!(:title => 'White', :content => nil)
+        excluded = ModelWithPgSearch.create!(:title => 'Black', :content => nil)
+        results = ModelWithPgSearch.with_dmetaphones('Wight')
         results.should == [included]
       end
 
       it "can handle terms that do not have a dmetaphone equivalent" do
         term_with_blank_metaphone = "w"
 
-        included = model_with_pg_search.create!(:title => 'White', :content => nil)
-        excluded = model_with_pg_search.create!(:title => 'Black', :content => nil)
+        included = ModelWithPgSearch.create!(:title => 'White', :content => nil)
+        excluded = ModelWithPgSearch.create!(:title => 'Black', :content => nil)
 
-        results = model_with_pg_search.with_dmetaphones('Wight W')
+        results = ModelWithPgSearch.with_dmetaphones('Wight W')
         results.should == [included]
       end
     end
 
     context "using multiple features" do
       before do
-        model_with_pg_search.class_eval do
+        ModelWithPgSearch.class_eval do
           pg_search_scope :with_tsearch,
                           :against => :title,
                           :using => [
@@ -483,19 +483,19 @@ describe "an ActiveRecord model which includes PgSearch" do
       end
 
       it "returns rows that match using any of the features" do
-        record = model_with_pg_search.create!(:title => "tiling is grouty")
+        record = ModelWithPgSearch.create!(:title => "tiling is grouty")
 
         # matches trigram only
         trigram_query = "ling is grouty"
-        model_with_pg_search.with_trigram(trigram_query).should include(record)
-        model_with_pg_search.with_tsearch(trigram_query).should_not include(record)
-        model_with_pg_search.with_tsearch_and_trigram_using_array(trigram_query).should == [record]
+        ModelWithPgSearch.with_trigram(trigram_query).should include(record)
+        ModelWithPgSearch.with_tsearch(trigram_query).should_not include(record)
+        ModelWithPgSearch.with_tsearch_and_trigram_using_array(trigram_query).should == [record]
 
         # matches tsearch only
         tsearch_query = "til"
-        model_with_pg_search.with_tsearch(tsearch_query).should include(record)
-        model_with_pg_search.with_trigram(tsearch_query).should_not include(record)
-        model_with_pg_search.with_tsearch_and_trigram_using_array(tsearch_query).should == [record]
+        ModelWithPgSearch.with_tsearch(tsearch_query).should include(record)
+        ModelWithPgSearch.with_trigram(tsearch_query).should_not include(record)
+        ModelWithPgSearch.with_tsearch_and_trigram_using_array(tsearch_query).should == [record]
       end
 
       context "with feature-specific configuration" do
@@ -503,7 +503,7 @@ describe "an ActiveRecord model which includes PgSearch" do
           @tsearch_config = tsearch_config = {:dictionary => 'english'}
           @trigram_config = trigram_config = {:foo => 'bar'}
 
-          model_with_pg_search.class_eval do
+          ModelWithPgSearch.class_eval do
             pg_search_scope :with_tsearch_and_trigram_using_hash,
                             :against => :title,
                             :using => {
@@ -518,14 +518,56 @@ describe "an ActiveRecord model which includes PgSearch" do
           PgSearch::Features::TSearch.should_receive(:new).with(anything, @tsearch_config, anything, anything, anything).at_least(:once).and_return(stub_feature)
           PgSearch::Features::Trigram.should_receive(:new).with(anything, @trigram_config, anything, anything, anything).at_least(:once).and_return(stub_feature)
 
-          model_with_pg_search.with_tsearch_and_trigram_using_hash("foo")
+          ModelWithPgSearch.with_tsearch_and_trigram_using_hash("foo")
         end
       end
     end
 
+    context "using a tsvector column" do
+      with_model :ModelWithPgSearchUsingTsVectorColumn do
+        table do |t|
+          t.text 'content'
+          t.column 'content_tsvector', :tsvector
+        end
+
+        model { include PgSearch }
+      end
+
+      let!(:expected) { ModelWithPgSearchUsingTsVectorColumn.create!(:content => 'tiling is grouty') }
+      let!(:unexpected) { ModelWithPgSearchUsingTsVectorColumn.create!(:content => 'longcat is looooooooong') }
+
+      before do
+        ActiveRecord::Base.connection.execute <<-SQL
+          UPDATE #{ModelWithPgSearchUsingTsVectorColumn.table_name}
+          SET content_tsvector = to_tsvector('english'::regconfig, "#{ModelWithPgSearchUsingTsVectorColumn.table_name}"."content")
+        SQL
+
+        ModelWithPgSearchUsingTsVectorColumn.class_eval do
+          pg_search_scope :search_by_content_with_tsvector,
+            :against => :content,
+            :using => {
+              :tsearch => {
+                :tsvector_column => 'content_tsvector',
+                :dictionary => 'english'
+              }
+            }
+        end
+      end
+
+      if defined?(ActiveRecord::Relation)
+        it "should not use to_tsvector in the query" do
+          ModelWithPgSearchUsingTsVectorColumn.search_by_content_with_tsvector("tiles").to_sql.should_not =~ /to_tsvector/
+        end
+      end
+
+      it "should find the expected result" do
+        ModelWithPgSearchUsingTsVectorColumn.search_by_content_with_tsvector("tiles").map(&:id).should == [expected.id]
+      end
+    end
+
     context "ignoring accents" do
       before do
-        model_with_pg_search.class_eval do
+        ModelWithPgSearch.class_eval do
           pg_search_scope :search_title_without_accents, :against => :title, :ignoring => :accents
         end
       end
@@ -534,16 +576,16 @@ describe "an ActiveRecord model which includes PgSearch" do
         # \303\241 is a with acute accent
         # \303\251 is e with acute accent
 
-        included = model_with_pg_search.create!(:title => "\303\241bcdef")
+        included = ModelWithPgSearch.create!(:title => "\303\241bcdef")
 
-        results = model_with_pg_search.search_title_without_accents("abcd\303\251f")
+        results = ModelWithPgSearch.search_title_without_accents("abcd\303\251f")
         results.should == [included]
       end
     end
 
     context "when passed a :ranked_by expression" do
       before do
-        model_with_pg_search.class_eval do
+        ModelWithPgSearch.class_eval do
           pg_search_scope :search_content_with_default_rank,
                           :against => :content
           pg_search_scope :search_content_with_importance_as_rank,
@@ -556,28 +598,28 @@ describe "an ActiveRecord model which includes PgSearch" do
       end
 
       it "should return records with a rank attribute equal to the :ranked_by expression" do
-        model_with_pg_search.create!(:content => 'foo', :importance => 10)
-        results = model_with_pg_search.search_content_with_importance_as_rank("foo")
+        ModelWithPgSearch.create!(:content => 'foo', :importance => 10)
+        results = ModelWithPgSearch.search_content_with_importance_as_rank("foo")
         results.first.rank.should == 10
       end
 
       it "should substitute :tsearch with the tsearch rank expression in the :ranked_by expression" do
-        model_with_pg_search.create!(:content => 'foo', :importance => 10)
+        ModelWithPgSearch.create!(:content => 'foo', :importance => 10)
 
-        tsearch_rank = model_with_pg_search.search_content_with_default_rank("foo").first.rank
-        multiplied_rank = model_with_pg_search.search_content_with_importance_as_rank_multiplier("foo").first.rank
+        tsearch_rank = ModelWithPgSearch.search_content_with_default_rank("foo").first.rank
+        multiplied_rank = ModelWithPgSearch.search_content_with_importance_as_rank_multiplier("foo").first.rank
 
         multiplied_rank.should be_within(0.001).of(tsearch_rank * 10)
       end
 
       it "should return results in descending order of the value of the rank expression" do
         records = [
-          model_with_pg_search.create!(:content => 'foo', :importance => 1),
-          model_with_pg_search.create!(:content => 'foo', :importance => 3),
-          model_with_pg_search.create!(:content => 'foo', :importance => 2)
+          ModelWithPgSearch.create!(:content => 'foo', :importance => 1),
+          ModelWithPgSearch.create!(:content => 'foo', :importance => 3),
+          ModelWithPgSearch.create!(:content => 'foo', :importance => 2)
         ]
 
-        results = model_with_pg_search.search_content_with_importance_as_rank("foo")
+        results = ModelWithPgSearch.search_content_with_importance_as_rank("foo")
         results.should == records.sort_by(&:importance).reverse
       end
 
@@ -586,7 +628,7 @@ describe "an ActiveRecord model which includes PgSearch" do
         context "using the #{feature} ranking algorithm" do
           before do
             @scope_name = scope_name = :"search_content_ranked_by_#{feature}"
-            model_with_pg_search.class_eval do
+            ModelWithPgSearch.class_eval do
               pg_search_scope scope_name,
                               :against => :content,
                               :ranked_by => ":#{feature}"
@@ -594,9 +636,9 @@ describe "an ActiveRecord model which includes PgSearch" do
           end
 
           it "should return results with a rank" do
-            model_with_pg_search.create!(:content => 'foo')
+            ModelWithPgSearch.create!(:content => 'foo')
 
-            results = model_with_pg_search.send(@scope_name, 'foo')
+            results = ModelWithPgSearch.send(@scope_name, 'foo')
             results.first.rank.should_not be_nil
           end
         end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: pg_search
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 21
   prerelease: 
   segments: 
   - 0
   - 2
-  version: "0.2"
+  - 1
+  version: 0.2.1
 platform: ruby
 authors: 
 - Case Commons, LLC
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-11 00:00:00 Z
+date: 2011-12-15 00:00:00 Z
 dependencies: []
 
 description: PgSearch builds ActiveRecord named scopes that take advantage of PostgreSQL's full text search
@@ -89,7 +90,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.1
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: PgSearch builds ActiveRecord named scopes that take advantage of PostgreSQL's full text search