datastax_rails 1.0.19.0 → 1.1.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 315f2c0bed2d3ebd73b696212d09be65be6071f1
+  data.tar.gz: 3c7f2f05d532f73ec40128bf748f032cb7825ec4
+SHA512:
+  metadata.gz: 956823938bdc95ac435bd57a7ec19cd6d1f565790847d10117fb86f30a2db78cbbe3ca0466db66632c9cd6a826bc1564146b687ac15027e15e8de54639698754
+  data.tar.gz: 0c082e39d39012a3c79dbed78180433dee4cd9bd0138aa3c9116aa03a267a5dff3f009973a9f86fb323e3a9a40254efd4d1afa8762f39ec72e56ca3909aed5aa

data/README.rdoc

@@ -70,10 +70,21 @@ Once you've created some models, the following will upload the solr schemas and
 It is safe to run ds:schema over and over.  In fact, it is necessary to re-run it any time you change the
 attributes on any model.  DSR will only upload schema files if they have changed.
 
+Create a sample Model.  See Base documentation for more details:
+
+class Person < DatastaxRails::Base
+  key     :uuid
+  string  :first_name
+  string  :user_name
+  text    :bio
+  date    :birthdate
+  boolean :active
+  timestamps
+end
+
 === Known issues
 
-Setting an integer field to something other than an integer results in nothing being set and no validation error
-(if you were using one).
+Trying to set a value to nil via the solr API results in the field value not changing at all.  Updating it via CQL doesn't have this issue.
 
 === More information
 

data/config/solrconfig.xml

@@ -48,6 +48,9 @@
        affect both how text is indexed and queried.
     -->
   <luceneMatchVersion>LUCENE_40</luceneMatchVersion>
+  
+  <!-- Enable DSE Search new type mappings -->
+  <dseTypeMappingVersion>0</dseTypeMappingVersion>
 
   <!-- lib directives can be used to instruct Solr to load an Jars
        identified and use them to resolve any "plugins" specified in

data/lib/datastax_rails/associations/collection_association.rb

@@ -154,6 +154,37 @@ module DatastaxRails
         record
       end
       
+      # Replace this collection with +other_array+
+      # This will perform a diff and delete/add only records that have changed.
+      def replace(other_array)
+        other_array.each { |val| raise_on_type_mismatch(val) }
+        original_target = load_target.dup
+
+        delete(target - other_array)
+
+        unless concat(other_array - target)
+          @target = original_target
+          raise RecordNotSaved, "Failed to replace #{reflection.name} because one or more of the " \
+                                "new records could not be saved."
+        end
+      end
+      
+      # Add +records+ to this association. Returns +self+ so method calls may be chained.
+      # Since << flattens its argument list and inserts each record, +push+ and +concat+ behave identically.
+      def concat(*records)
+        result = true
+        load_target if owner.new_record?
+
+        records.flatten.each do |record|
+          raise_on_type_mismatch(record)
+          add_to_target(record) do |r|
+            result &&= insert_record(record) unless owner.new_record?
+          end
+        end
+
+        result && records
+      end
+      
       private
       
         # We have some records loaded from the database (persisted) and some that are

data/lib/datastax_rails/attribute_methods/definition.rb

@@ -9,8 +9,8 @@ module DatastaxRails
       end
 
       def instantiate(record, value)
-        value ||= coder.default
-        return unless value
+        value = coder.default if value.nil?
+        return if value.nil?
       
         value = coder.decode(value)
         coder.wrap(record, name, value)

data/lib/datastax_rails/base.rb

@@ -324,7 +324,7 @@ module DatastaxRails #:nodoc:
     self.default_consistency = :quorum
 
     class_attribute :storage_method
-    self.storage_method = :solr
+    self.storage_method = :cql
     
     class_attribute :models
     self.models = []
@@ -479,7 +479,7 @@ module DatastaxRails #:nodoc:
       delegate :count, :first, :first!, :last, :last!, :compute_stats, :to => :scoped
       delegate :sum, :average, :minimum, :maximum, :stddev, :to => :scoped
       delegate :cql, :with_cassandra, :with_solr, :commit_solr, :to => :scoped
-      delegate :find_each, :find_in_batches, :to => :scoped
+      delegate :find_each, :find_in_batches, :consistency, :to => :scoped
 
       # Sets the column family name
       #
@@ -493,7 +493,7 @@ module DatastaxRails #:nodoc:
       #
       # Returns [String] the name of the column family
       def column_family
-        @column_family || name.pluralize
+        @column_family || name.underscore.pluralize
       end
       
       def payload_model?
@@ -508,10 +508,6 @@ module DatastaxRails #:nodoc:
         klass
       end
       
-      # def find(*keys)
-        # scoped.with_cassandra.find(keys)
-      # end
-      
       def find_by_id(id)
         scoped.with_cassandra.find(id)
       rescue RecordNotFound

data/lib/datastax_rails/connection.rb

@@ -1,6 +1,7 @@
 # require 'datastax_rails/rsolr_client_wrapper'
 require 'rsolr/client_cert'
 require 'rest_client'
+require "cassandra-cql/1.2"
 module DatastaxRails
   # The connection module holds all the code for establishing and maintaining a connection to
   # Datastax Exterprise.  This includes both the Cassandra and Solr connections.

data/lib/datastax_rails/cql/alter_column_family.rb

@@ -4,6 +4,7 @@ module DatastaxRails#:nodoc:
       def initialize(cf_name)
         @cf_name = cf_name
         @action = nil
+        @consistency = 'QUORUM'
       end
       
       def add(column)
@@ -23,6 +24,12 @@ module DatastaxRails#:nodoc:
         @action = 'ALTER'
         self 
       end
+      
+      def rename(col1,col2)
+        set_column([col1,col2])
+        @action = 'RENAME'
+        self
+      end
 
       def set_column(column)  
         if(@action)
@@ -39,6 +46,8 @@ module DatastaxRails#:nodoc:
           stmt << "ADD #{@column.keys.first} #{@column.values.first}"
         elsif(@action == 'DROP')
           stmt << "DROP #{@column}"
+        elsif(@action == 'RENAME')
+          stmt << "RENAME \"#{@column[0]}\" TO \"#{@column[1]}\""
         end
         
         stmt

data/lib/datastax_rails/cql/base.rb

@@ -4,6 +4,7 @@ module DatastaxRails
       # Base initialize that sets the default consistency.
       def initialize(klass, *args)
         @consistency = klass.default_consistency.to_s.upcase
+        @keyspace = DatastaxRails::Base.config[:keyspace]
       end
 
       # Abstract.  Should be overridden by subclasses
@@ -17,7 +18,7 @@ module DatastaxRails
       def execute
         cql = self.to_cql
         puts cql if ENV['DEBUG_CQL'] == 'true'
-        DatastaxRails::Base.connection.execute_cql_query(cql)
+        DatastaxRails::Base.connection.execute_cql_query(cql, :consistency => CassandraCQL::Thrift::ConsistencyLevel.const_get(@consistency || 'QUORUM'))
       end
     end
   end

data/lib/datastax_rails/cql/create_column_family.rb

@@ -6,7 +6,7 @@ module DatastaxRails#:nodoc:
         @columns = {}
         @storage_parameters = []
         @key_type = 'uuid'
-        @key_columns = @key_name = "KEY"
+        @key_columns = @key_name = "key"
       end
       
       def key_type(key_type)
@@ -48,11 +48,11 @@ module DatastaxRails#:nodoc:
       end
       
       def to_cql
-        stmt = "CREATE COLUMNFAMILY #{@cf_name} (\"#{@key_name}\" #{@key_type}, "
+        stmt = "CREATE COLUMNFAMILY #{@cf_name} (#{@key_name} #{@key_type}, "
         @columns.each do |name,type|
           stmt << "#{name} #{type}, "
         end
-        stmt << "PRIMARY KEY (\"#{@key_columns}\"))"
+        stmt << "PRIMARY KEY (#{@key_columns}))"
         unless @storage_parameters.empty?
           stmt << " WITH "
           stmt << @storage_parameters.join(" AND ")

data/lib/datastax_rails/cql/create_index.rb

@@ -0,0 +1,25 @@
+module DatastaxRails#:nodoc:
+  module Cql #:nodoc:
+    class CreateIndex < Base #:nodoc:
+      def initialize(index_name = nil)
+        @cf_name = nil
+        @column = nil
+        @index_name = index_name
+      end
+      
+      def on(cf_name)
+        @cf_name = cf_name
+        self
+      end
+      
+      def column(column)
+        @column = column
+        self
+      end
+      
+      def to_cql
+        "CREATE INDEX #{@index_name} ON #{@cf_name} (#{@column})"
+      end
+    end
+  end
+end

data/lib/datastax_rails/cql/create_keyspace.rb

@@ -17,12 +17,12 @@ module DatastaxRails#:nodoc:
       end
       
       def to_cql
-        stmt = "CREATE KEYSPACE #{@ks_name} WITH strategy_class = '#{@strategy_class}'"
+        stmt = "CREATE KEYSPACE #{@ks_name} WITH REPLICATION = {'class' : '#{@strategy_class}'"
         
         @strategy_options.each do |key, value|
-          stmt << " AND strategy_options:#{key.to_s} = '#{value.to_s}'"
+          stmt << ", '#{key.to_s}' : '#{value.to_s}'"
         end
-        
+        stmt << '}'
         stmt
       end
     end

data/lib/datastax_rails/cql/delete.rb

@@ -7,7 +7,7 @@ module DatastaxRails
         @timestamp = nil
         @columns = []
         @conditions = {}
-        @key_name = "KEY"
+        @key_name = "key"
         super
       end
       
@@ -37,8 +37,8 @@ module DatastaxRails
       end
       
       def to_cql
-        values = [@keys]
-        stmt = "DELETE #{@columns.join(',')} FROM #{@klass.column_family} USING CONSISTENCY #{@consistency} "
+        values = [@keys.collect{|k|k.to_s}]
+        stmt = "DELETE #{@columns.join(',')} FROM #{@klass.column_family} "
         
         if(@timestamp)
           stmt << "AND TIMESTAMP #{@timestamp} "

data/lib/datastax_rails/cql/drop_index.rb

@@ -0,0 +1,13 @@
+module DatastaxRails
+  module Cql
+    class DropIndex < Base
+      def initialize(index_name)
+        @index_name = index_name
+      end
+      
+      def to_cql
+        "DROP INDEX #{@index_name}"
+      end
+    end
+  end
+end

data/lib/datastax_rails/cql/insert.rb

@@ -36,7 +36,7 @@ module DatastaxRails
           keys << k.to_s
           values << v
         end
-        stmt = "INSERT INTO #{@klass.column_family} (#{keys.join(',')}) VALUES (#{('?'*keys.size).split(//).join(',')}) USING CONSISTENCY #{@consistency} "
+        stmt = "INSERT INTO #{@klass.column_family} (#{keys.join(',')}) VALUES (#{('?'*keys.size).split(//).join(',')}) "
         
         if(@ttl)
           stmt << "AND TTL #{@ttl} "
@@ -46,7 +46,7 @@ module DatastaxRails
           stmt << "AND TIMESTAMP #{@timestamp}"
         end
         
-        CassandraCQL::Statement.sanitize(stmt, values)
+        CassandraCQL::Statement.sanitize(stmt, values).force_encoding('UTF-8')
       end
     end
   end

data/lib/datastax_rails/cql/select.rb

@@ -39,10 +39,10 @@ module DatastaxRails#:nodoc:
       def to_cql
         conditions = []
         values = []
-        stmt = "SELECT #{@select} FROM #{@klass.column_family} USING CONSISTENCY #{@consistency} "
+        stmt = "SELECT #{@select} FROM #{@klass.column_family} "
         
         if @paginate
-          conditions << "token(\"KEY\") > token('#{@paginate}')"
+          conditions << "token(key) > token('#{@paginate}')"
         end
         
         @conditions.each do |k,v|

data/lib/datastax_rails/cql/update.rb

@@ -37,29 +37,29 @@ module DatastaxRails
         column_names = @columns.keys
         
         
-          stmt = "update #{@klass.column_family} using consistency #{@consistency} "
-          
-          if(@ttl)
-            stmt << "AND TTL #{@ttl} "
-          end
+        stmt = "update #{@klass.column_family} "
+        
+        if(@ttl)
+          stmt << "AND TTL #{@ttl} "
+        end
+        
+        if(@timestamp)
+          stmt << "AND TIMESTAMP #{@timestamp}"
+        end
+        
+        unless @columns.empty?
+          stmt << "SET "
           
-          if(@timestamp)
-            stmt << "AND TIMESTAMP #{@timestamp}"
-          end
+          first_entry = column_names.first
           
-          unless @columns.empty?
-            stmt << "SET "
-            
-            first_entry = column_names.first
-            
-            stmt << CassandraCQL::Statement.sanitize("\"#{first_entry.to_s}\" = ?", [@columns[first_entry]])
-            column_names[1..-1].each do |col|
-              stmt << CassandraCQL::Statement.sanitize(", \"#{col.to_s}\" = ?", [@columns[col]])
-            end
+          stmt << CassandraCQL::Statement.sanitize("\"#{first_entry.to_s}\" = ?", [@columns[first_entry]])
+          column_names[1..-1].each do |col|
+            stmt << CassandraCQL::Statement.sanitize(", \"#{col.to_s}\" = ?", [@columns[col]])
           end
-          
-          stmt << CassandraCQL::Statement.sanitize(" WHERE \"KEY\" IN (?)", [@key])
-        stmt
+        end
+        
+        stmt << CassandraCQL::Statement.sanitize(" WHERE key IN (?)", [@key])
+        stmt.force_encoding('UTF-8')
       end
       
       # def execute

data/lib/datastax_rails/cql.rb

@@ -13,9 +13,11 @@ module DatastaxRails
     autoload :ColumnFamily
     autoload :Consistency
     autoload :CreateColumnFamily
+    autoload :CreateIndex
     autoload :CreateKeyspace
     autoload :Delete
     autoload :DropColumnFamily
+    autoload :DropIndex
     autoload :DropKeyspace
     autoload :Insert
     autoload :Select

data/lib/datastax_rails/persistence.rb

@@ -112,7 +112,7 @@ module DatastaxRails
         end
         
         attribute_definitions.each do |k,definition|
-          casted[k.to_s] = definition.instantiate(object, attributes[k])
+          casted[k.to_s] = definition.instantiate(object, attributes[k]).to_s
         end
         casted
       end
@@ -123,17 +123,8 @@ module DatastaxRails
         end
         
         def write_with_solr(key, attributes, options)
-          # We need to collect removed fields since we can't currently delete the column via
-          # the solr interface
-          removed_fields = []
-          attributes.each do |k,v|
-            removed_fields << k.to_s if v.blank?
-          end
           xml_doc = RSolr::Xml::Generator.new.add(attributes.merge(:id => key))
           self.solr_connection.update(:data => xml_doc, :params => {:replacefields => false, :cl => options[:consistency]})
-          unless removed_fields.empty?
-            cql.delete(key.to_s).columns(removed_fields).using(options[:consistency]).execute
-          end
         end
     end
 
@@ -205,6 +196,7 @@ module DatastaxRails
       end
       
       def write(options) #:nodoc:
+        options[:new_record] = new_record?
         changed_attributes = changed.inject({}) { |h, n| h[n] = read_attribute(n); h }
         return true if changed_attributes.empty?
         self.class.write(key, changed_attributes, options)

data/lib/datastax_rails/railtie.rb

@@ -1,8 +1,15 @@
 require 'rubygems'
 require 'datastax_rails'
 require 'rails'
+require 'action_controller/railtie'
+
 module DatastaxRails
   class Railtie < Rails::Railtie
+    config.action_dispatch.rescue_responses.merge!(
+      'DatastaxRails::RecordNotFound' => :not_found,
+      'DatastaxRails::RecordInvalid'  => :unprocessable_entity,
+      'DatastaxRails::RecordNotSaved' => :unprocessable_entity)
+    
     initializer 'datastax_rails.init' do
       ActiveSupport.on_load(:datastax_rails) do
       end

data/lib/datastax_rails/relation/batches.rb

@@ -22,6 +22,16 @@ module DatastaxRails
         records.each { |record| yield record }
       end
     end
+    
+    def find_each_with_index(options = {})
+      idx = 0
+      find_in_batches(options) do |records|
+        records.each do |record| 
+          yield record, idx
+          idx += 1
+        end
+      end
+    end
 
     # Yields each batch of records that was found by the find +options+ as
     # an array. The size of each batch is set by the <tt>:batch_size</tt>
@@ -50,14 +60,14 @@ module DatastaxRails
     # @param options [Hash] finder options
     # @yeild [records] a batch of DatastaxRails records
     def find_in_batches(options = {})
-      relation = self.with_cassandra
+      relation = self
 
-      unless @order_values.empty? && @per_page_value.blank?
+      unless (@order_values.empty? || @order_values == [{:created_at => :asc}])
         DatastaxRails::Base.logger.warn("Scoped order and limit are ignored, it's forced to be batch order and batch size")
       end
 
       if (finder_options = options.except(:start, :batch_size)).present?
-        raise "You can't specify an order, it's forced to be #{batch_order}" if options[:order].present?
+        raise "You can't specify an order, it's forced to be #{relation.use_solr_value ? "created_at" : "key"}" if options[:order].present?
         raise "You can't specify a limit, it's forced to be the batch_size" if options[:limit].present?
 
         relation = apply_finder_options(finder_options)
@@ -66,20 +76,23 @@ module DatastaxRails
       start = options.delete(:start)
       batch_size = options.delete(:batch_size) || 1000
 
+      batch_order = relation.use_solr_value ? :created_at : :key
       relation = relation.limit(batch_size)
-      records = start ? relation.where(:KEY).greater_than(start).to_a : relation.to_a
-
+      relation = relation.order(batch_order) if relation.use_solr_value
+      records = start ? relation.where(batch_order).greater_than(start).to_a : relation.to_a
       while records.size > 0
         records_size = records.size
-        primary_key_offset = records.last.id
+        offset = relation.use_solr_value ? records.last.created_at.to_time : records.last.id
         yield records
 
         break if records_size < batch_size
-
-        if primary_key_offset
-          records = relation.where(:KEY).greater_than(primary_key_offset).to_a
+        if offset
+          if relation.use_solr_value
+            offset += 1
+          end
+          records = relation.where(batch_order).greater_than(offset).to_a
         else
-          raise "Primary key not included in the custom select clause"
+          raise "Batch order not included in the custom select clause"
         end
       end
     end

data/lib/datastax_rails/relation/facet_methods.rb

@@ -0,0 +1,17 @@
+module DatastaxRails
+  module FacetMethods
+    # Instructs SOLR to get facet counts on the passed in field.
+    #
+    #   Model.facet(:category)
+    #
+    # This may be specified multiple times to get facet counts on multiple fields.
+    #
+    # @param field [String, Symbol] the field to get facet counts for
+    # @return [DatastaxRails::Relation] a new Relation object
+    def facet(field)
+      clone.tap do |r|
+        r.facet_field_values << field
+      end
+    end
+  end
+end

data/lib/datastax_rails/relation/finder_methods.rb

@@ -137,11 +137,11 @@ module DatastaxRails
       end
       
       def find_one(id)
-        with_cassandra.where(:KEY => id).first || raise(RecordNotFound, "Couldn't find #{@klass.name} with ID=#{id}")
+        with_cassandra.where(:key => id).first || raise(RecordNotFound, "Couldn't find #{@klass.name} with ID=#{id}")
       end
   
       def find_some(ids)
-        result = with_cassandra.where(:KEY => ids).all
+        result = with_cassandra.where(:key => ids).all
   
         expected_size =
           if @limit_value && ids.size > @limit_value

data/lib/datastax_rails/relation/search_methods.rb

@@ -163,7 +163,7 @@ module DatastaxRails
       return self if attribute.blank?
 
       clone.tap do |r|
-        order_by = attribute.is_a?(Hash) ? attribute.dup : {attribute => :asc}
+        order_by = attribute.is_a?(Hash) ? attribute.dup : {attribute.to_sym => :asc}
         
         r.order_values << order_by 
       end

data/lib/datastax_rails/relation.rb

@@ -240,7 +240,13 @@ module DatastaxRails
     # works if you run against a secondary index. So this currently just
     # delegates to the count_via_solr method.
     def count_via_cql
-      with_solr.count_via_solr
+      select_columns = ['count(*)']
+      cql = @cql.select(select_columns)
+      cql.using(@consistency_value) if @consistency_value
+      @where_values.each do |wv|
+        cql.conditions(wv)
+      end
+      CassandraCQL::Result.new(cql.execute).fetch['count']
     end
     
     # Constructs a CQL query and runs it against Cassandra directly.  For this to
@@ -248,7 +254,7 @@ module DatastaxRails
     # For ad-hoc queries, you will have to use Solr.
     def query_via_cql
       select_columns = select_values.empty? ? (@klass.attribute_definitions.keys - @klass.lazy_attributes) : select_values.flatten
-      cql = @cql.select(select_columns)
+      cql = @cql.select(select_columns + ['key'])
       cql.using(@consistency_value) if @consistency_value
       @where_values.each do |wv|
         cql.conditions(wv)
@@ -256,7 +262,7 @@ module DatastaxRails
       @greater_than_values.each do |gtv|
         gtv.each do |k,v|
           # Special case if inequality is equal to the primary key (we're paginating)
-          if(k == :KEY)
+          if(k == :key)
             cql.paginate(v)
           end
         end
@@ -266,7 +272,7 @@ module DatastaxRails
       end
       results = []
       CassandraCQL::Result.new(cql.execute).fetch do |row|
-        results << @klass.instantiate(row.row.key, row.to_hash, select_columns)
+        results << @klass.instantiate(row['key'], row.to_hash, select_columns)
       end
       results
     end
@@ -362,7 +368,8 @@ module DatastaxRails
       end
       
       select_columns = select_values.empty? ? (@klass.attribute_definitions.keys - @klass.lazy_attributes) : select_values.flatten
-      
+      select_columns << "id"
+      params[:fl] = select_columns.collect(&:to_s).join(",")
       unless(@stats_values.empty?)
         params[:stats] = 'true'
         @stats_values.flatten.each do |sv|
@@ -398,6 +405,7 @@ module DatastaxRails
       if solr_response["stats"]
         @stats = solr_response["stats"]["stats_fields"].with_indifferent_access
       end
+      pp params if ENV['DEBUG_SOLR'] == 'true'
       results
     end
     
@@ -487,7 +495,7 @@ module DatastaxRails
       def method_missing(method, *args, &block) #:nodoc:
         if Array.method_defined?(method)
           to_a.send(method, *args, &block)
-        elsif @klass.respond_to?(method)
+        elsif @klass.respond_to?(method, true)
           scoping { @klass.send(method, *args, &block) }
         else
           super