datastax_rails 1.0.14.10 → 1.0.15

data/lib/datastax_rails/grouped_collection.rb

@@ -0,0 +1,9 @@
+module DatastaxRails
+  class GroupedCollection < Hash
+    attr_accessor :total_entries, :total_groups, :total_for_all
+    
+    def inspect
+      "<DatastaxRails::GroupedCollection##{object_id} contents: #{super} matching_records #{total_for_all}>"
+    end
+  end
+end

data/lib/datastax_rails/relation/search_methods.rb

@@ -96,15 +96,30 @@ module DatastaxRails
       end
     end
     
-    # Group results by one or more attributes only returning the top result
-    # for each group.
+    # Group results by a given attribute only returning the top results
+    # for each group. In Lucene, this is often referred to as Field Collapsing.
+    #
+    # This modifies the behavior of pagination. When using a group, +per_page+ will
+    # specify the number of results returned *for each group*. In addition, +page+
+    # will move all groups forward by one page possibly resulting in some groups
+    # getting dropped off if they have fewer matching entires than others.
+    #
+    # When grouping is being used, the sort values will be used to sort results within
+    # a given group. Any sorting of the groups themselves will need to be handled
+    # after-the-fact as the groups are returned as hash of Collection objects.
+    #
+    # Because SOLR is doing the grouping work, we can only group on single-valued
+    # fields (i.e., not +text+ or +array+ attributes). In the future, SOLR may
+    # support grouping on multi-valued fields.
+    #
+    # NOTE: Group names will be lower-cased
     #
     #   Model.group(:program_id)
-    def group(*attrs)
-      return self if attrs.blank?
+    def group(attribute)
+      return self if attribute.blank?
       
       clone.tap do |r|
-        r.group_values += attrs.flatten
+        r.group_value = attribute
       end
     end
     

data/lib/datastax_rails/relation.rb

@@ -2,8 +2,8 @@ require 'rsolr'
 
 module DatastaxRails
   class Relation
-    MULTI_VALUE_METHODS = [:group, :order, :where, :where_not, :fulltext, :greater_than, :less_than, :select]
-    SINGLE_VALUE_METHODS = [:page, :per_page, :reverse_order, :query_parser, :consistency, :ttl, :use_solr, :escape]
+    MULTI_VALUE_METHODS = [:order, :where, :where_not, :fulltext, :greater_than, :less_than, :select]
+    SINGLE_VALUE_METHODS = [:page, :per_page, :reverse_order, :query_parser, :consistency, :ttl, :use_solr, :escape, :group]
     
     SOLR_CHAR_RX = /([\+\!\(\)\[\]\^\"\~\:\'\=]+)/
     
@@ -74,6 +74,9 @@ module DatastaxRails
     # If the relation has not been populated yet, a limit of 1 will be
     # placed on the query before it is executed.
     #
+    # For a grouped query, this still returns the total number of 
+    # matching documents
+    #
     # Compare with #size.
     #
     # XXX: Count via CQL is useless unless criteria has been applied.
@@ -164,9 +167,12 @@ module DatastaxRails
     # the number of results in the current page.  DatastaxRails models
     # can have a +default_page_size+ set which will cause them to be
     # paginated all the time.
+    #
+    # For a grouped query, this returns the size of the largest group.
+    #
     # Compare with #count
     def size
-      return @results.size if loaded?
+      return @results.size if loaded? && !@group_value
       total_entries = count
       (per_page_value && total_entries > per_page_value) ? per_page_value : total_entries
     end
@@ -184,7 +190,7 @@ module DatastaxRails
       return @results if loaded?
       if use_solr_value
         @results = query_via_solr
-        @count = @results.total_entries
+        @count = @group_value ? @results.total_for_all : @results.total_entries
       else
         @results = query_via_cql
       end
@@ -245,7 +251,8 @@ module DatastaxRails
     # Runs the query with a limit of 1 just to grab the total results attribute off
     # the result set. 
     def count_via_solr
-      limit(1).select(:id).to_a.total_entries
+      results = limit(1).select(:id).to_a
+      @group_value ? results.total_for_all : results.total_entries
     end
     
     # Escapes values that might otherwise mess up the URL or confuse SOLR.
@@ -325,24 +332,44 @@ module DatastaxRails
       
       select_columns = select_values.empty? ? (@klass.attribute_definitions.keys - @klass.lazy_attributes) : select_values.flatten
       
-      #TODO Need to escape URL stuff (I think)
-      response = rsolr.paginate(@page_value, @per_page_value, 'select', :params => params)["response"]
+      if(@group_value)
+        results = DatastaxRails::GroupedCollection.new
+        params[:group] = 'true'
+        params['group.field'] = @group_value
+        params['group.limit'] = @per_page_value
+        params['group.offset'] = (@page_value - 1) * @per_page_value
+        params['group.ngroups'] = 'true'
+        response = rsolr.post('select', :params => params)["grouped"][@group_value.to_s]
+        results.total_groups = response['ngroups'].to_i
+        results.total_for_all = response['matches'].to_i
+        results.total_entries = 0
+        response['groups'].each do |group|
+          results[group['groupValue']] = parse_docs(group['doclist'], select_columns)
+          results.total_entries = results[group['groupValue']].total_entries if results[group['groupValue']].total_entries > results.total_entries
+        end
+      else
+        response = rsolr.paginate(@page_value, @per_page_value, 'select', :params => params)["response"]
+        results = parse_docs(response, select_columns)
+      end
+      results
+    end
+    
+    
+    def parse_docs(response, select_columns)
       results = DatastaxRails::Collection.new
       results.total_entries = response['numFound'].to_i
-      if @consistency_value
-        response['docs'].each do |doc|
-          id = doc['id']
+      response['docs'].each do |doc|
+        id = doc['id']
+        if(@consistency_value)
           obj = @klass.with_cassandra.consistency(@consistency_value).find_by_id(id)
           results << obj if obj
-        end
-      else
-        response['docs'].each do |doc|
-          key = doc.delete('id')
-          results << @klass.instantiate(key,doc, select_columns)
+        else
+          results << @klass.instantiate(id, doc, select_columns)
         end
       end
       results
     end
+    protected(:parse_docs)
     
     def inspect(just_me = false)
       just_me ? super() : to_a.inspect

data/lib/datastax_rails/tasks/column_family.rb

@@ -109,6 +109,7 @@ module DatastaxRails
           solr_url = "#{DatastaxRails::Base.solr_base_url}/resource/#{DatastaxRails::Base.config[:keyspace]}.#{model.column_family}"
           uri = URI.parse(solr_url)
           Net::HTTP.start(uri.host, uri.port) do |http|
+            http.read_timeout(300)
             if force || solrconfig_digest != sm_digests['solrconfig'] 
               puts "Posting Solr Config file to '#{solr_url}/solrconfig.xml'"
               http.post(uri.path+"/solrconfig.xml", solrconfig)

data/lib/datastax_rails/version.rb

@@ -1,4 +1,4 @@
 module DatastaxRails
   # The current version of the gem
-  VERSION = "1.0.14.10"
+  VERSION = "1.0.15"
 end

data/lib/datastax_rails.rb

@@ -15,6 +15,7 @@ module DatastaxRails
   autoload :Collection
   autoload :Connection
   autoload :Cql
+  autoload :GroupedCollection
   autoload :Identity
   autoload :Migrations
   autoload :Persistence

data/spec/datastax_rails/cql/update_spec.rb

@@ -8,7 +8,7 @@ describe DatastaxRails::Cql::Update do
   it "should generate valid CQL" do
     cql = DatastaxRails::Cql::Update.new(@model_class, "12345")
     cql.using(DatastaxRails::Cql::Consistency::QUORUM).columns(:name => 'John', :age => '23')
-    cql.to_cql.should == "update users using consistency QUORUM SET name = 'John', age = '23' WHERE KEY IN ('12345')"
+    cql.to_cql.should match(/update users using consistency QUORUM SET (name = 'John', age = '23'|age = '23', name = 'John') WHERE KEY IN \('12345'\)/)
   end
   
   it_has_behavior "default_consistency"

data/spec/datastax_rails/relation_spec.rb

@@ -127,4 +127,32 @@ describe DatastaxRails::Relation do
       relation.total_pages.should == 4
     end
   end
+  
+  describe "grouped queries" do
+    before(:each) do
+      Person.create(:name => 'John', :nickname => 'J')
+      Person.create(:name => 'Jason', :nickname => 'J')
+      Person.create(:name => 'James', :nickname => 'J')
+      Person.create(:name => 'Kathrine', :nickname => 'Kat')
+      Person.create(:name => 'Kathy', :nickname => 'Kat')
+      Person.create(:name => 'Steven', :nickname => 'Steve')
+      Person.commit_solr
+    end
+    
+    it "should return matching documents grouped by an attribute" do
+      results = Person.group(:nickname).all
+      results['j'].should have(3).items
+      results['kat'].should have(2).items
+      results['steve'].should have(1).item
+    end
+    
+    it "should return total_entires as the highest value of any group" do
+      results = Person.group(:nickname).all
+      results.total_entries.should eq(3)
+    end
+    
+    it "should still return a total count when using the count method" do
+      results = Person.group(:nickname).count.should eq(6)
+    end
+  end
 end