datastax_rails 2.0.18 → 2.1.23

data/lib/datastax_rails/instrumentation/controller_runtime.rb

@@ -0,0 +1,52 @@
+require 'active_support/core_ext/module/attr_internal'
+
+module DatastaxRails
+  module Instrumentation
+    # Hooks into ActionController to display Solr and CQL runtime
+    #
+    # @see https://github.com/rails/rails/blob/master/activerecord/lib/active_record/railties/controller_runtime.rb
+    #
+    module ControllerRuntime
+      extend ActiveSupport::Concern
+
+      protected
+
+      attr_internal :solr_runtime
+      attr_internal :cql_runtime
+
+      def process_action(action, *args)
+        DatastaxRails::Instrumentation::LogSubscriber.reset_solr_runtime
+        DatastaxRails::Instrumentation::LogSubscriber.reset_cql_runtime
+        super
+      end
+
+      def cleanup_view_runtime
+        solr_rt_before_render = DatastaxRails::Instrumentation::LogSubscriber.reset_solr_runtime
+        cql_rt_before_render = DatastaxRails::Instrumentation::LogSubscriber.reset_cql_runtime
+        self.solr_runtime = (solr_runtime || 0) + solr_rt_before_render
+        self.cql_runtime = (cql_runtime || 0) + cql_rt_before_render
+        runtime = super
+        solr_rt_after_render = DatastaxRails::Instrumentation::LogSubscriber.reset_solr_runtime
+        cql_rt_after_render = DatastaxRails::Instrumentation::LogSubscriber.reset_cql_runtime
+        self.solr_runtime += solr_rt_after_render
+        self.cql_runtime += cql_rt_after_render
+        runtime - solr_rt_after_render - cql_rt_after_render
+      end
+
+      def append_info_to_payload(payload)
+        super
+        payload[:solr_runtime] = (solr_runtime || 0) + DatastaxRails::Instrumentation::LogSubscriber.reset_solr_runtime
+        payload[:cql_runtime] = (cql_runtime || 0) + DatastaxRails::Instrumentation::LogSubscriber.reset_cql_runtime
+      end
+
+      module ClassMethods
+        def log_process_action(payload)
+          messages, solr_runtime, cql_runtime = super, payload[:solr_runtime], payload[:cql_runtime]
+          messages << ('Solr: %.1fms' % solr_runtime.to_f) if solr_runtime
+          messages << ('CQL: %.1fms' % cql_runtime.to_f) if cql_runtime
+          messages
+        end
+      end
+    end
+  end
+end

data/lib/datastax_rails/instrumentation/log_subscriber.rb

@@ -0,0 +1,92 @@
+module DatastaxRails
+  module Instrumentation
+    # A log subscriber to attach to Datastax related events
+    #
+    # @see https://github.com/rails/rails/blob/master/activerecord/lib/active_record/log_subscriber.rb
+    #
+    class LogSubscriber < ActiveSupport::LogSubscriber
+      def initialize(*args)
+        super
+        @odd = false
+      end
+
+      def self.solr_runtime=(value)
+        Thread.current['datastax_solr_runtime'] = value
+      end
+
+      def self.solr_runtime
+        Thread.current['datastax_solr_runtime'] ||= 0
+      end
+
+      def self.cql_runtime=(value)
+        Thread.current['datastax_cql_runtime'] = value
+      end
+
+      def self.cql_runtime
+        Thread.current['datastax_cql_runtime'] ||= 0
+      end
+
+      def self.reset_solr_runtime
+        rt, self.solr_runtime = solr_runtime, 0
+        rt
+      end
+
+      def self.reset_cql_runtime
+        rt, self.cql_runtime = cql_runtime, 0
+        rt
+      end
+
+      # Intercept `solr.datastax_rails` events, and display them in the Rails log
+      def solr(event)
+        self.class.solr_runtime += event.duration
+        return unless logger.debug? && DatastaxRails::Base.log_solr_queries
+
+        payload = event.payload
+
+        name    = "#{payload[:klass]} #{payload[:name]} (#{event.duration.round(1)}ms)"
+        search  = payload[:search].inspect.gsub(/:(\w+)=>/, '\1: ')
+
+        if odd?
+          name = color(name, CYAN, true)
+          search = color(search, nil, true)
+        else
+          name = color(name, MAGENTA, true)
+        end
+
+        debug "  #{name} #{search}"
+      end
+
+      # Intercept `cql.datastax_rails` events, and display them in the Rails log
+      def cql(event)
+        self.class.cql_runtime += event.duration
+        return unless logger.debug? && DatastaxRails::Base.log_cql_queries
+
+        payload = event.payload
+
+        name    = "#{payload[:klass]} #{payload[:name]} (#{event.duration.round(1)}ms)"
+        cql     = payload[:cql]
+        binds   = nil
+        results = payload[:result_count]
+
+        unless (payload[:binds] || []).empty?
+          binds = ' ' + payload[:binds].inspect
+        end
+
+        if odd?
+          name = color(name, CYAN, true)
+          cql = color(cql, nil, true)
+        else
+          name = color(name, MAGENTA, true)
+        end
+
+        debug "  #{name} #{cql}#{binds} - #{results} results"
+      end
+
+      def odd?
+        @odd = !@odd
+      end
+    end
+  end
+end
+
+DatastaxRails::Instrumentation::LogSubscriber.attach_to :datastax_rails

data/lib/datastax_rails/instrumentation.rb

@@ -0,0 +1,4 @@
+module DatastaxRails
+  module Instrumentation
+  end
+end

data/lib/datastax_rails/persistence.rb

@@ -29,7 +29,7 @@ module DatastaxRails
         # keys = keys.flat_map { |k| attribute_definitions[primary_key].type_cast(k) }
         keys.each do |key|
           typecast_key = {}
-          key.each { |k, v| typecast_key[k] = attribute_definitions[k].type_cast(v) }
+          key.each { |k, v| typecast_key[k] = attribute_definitions[k].type_cast_for_cql3(v) }
 
           ActiveSupport::Notifications.instrument('remove.datastax_rails', column_family: column_family, key: key) do
             c = cql.delete(typecast_key)
@@ -60,11 +60,12 @@ module DatastaxRails
         end
       end
 
-      # Write a record to cassandra.  Can be either an insert or an update (they are exactly the same to cassandra)
+      # Write a full record to cassandra.
       #
       # @param [DatastaxRails::Base] record the record that we are writing
       # @param [Hash] options a hash containing various options
       # @option options [Symbol] :consistency the consistency to set for the Cassandra operation (e.g., ALL)
+      # @option options [Symbol] :new_record whether or not this is a new record (i.e., INSERT vs UPDATE)
       def write(record, options = {})
         level = (options[:consistency] || default_consistency).to_s.upcase
         if valid_consistency?(level)
@@ -77,9 +78,37 @@ module DatastaxRails
                                                                            key:           key.to_s,
                                                                            attributes:    record.attributes) do
             if (storage_method == :solr)
-              write_with_solr(record, options)
+              write_with_solr(record.id_for_update, encode_attributes(record, false), options)
             else
-              write_with_cql(record, options)
+              write_with_cql(record.id_for_update, encode_attributes(record, true), options)
+            end
+          end
+        end
+      end
+
+      # Write one or more attributes directly to cassandra. Bypasses all normal validation and callbacks.
+      # Record must be already persisted.
+      #
+      # @param [DatastaxRails::Base] record the record that we are writing
+      # @param [Hash] options a hash containing various options
+      # @option options [Symbol] :consistency the consistency to set for the Cassandra operation (e.g., ALL)
+      # @raise [NotPersistedError] if the record isn't persisted
+      def write_attribute(record, attributes, options = {})
+        fail NotPersistedError if record.new_record?
+        level = (options[:consistency] || default_consistency).to_s.upcase
+        if valid_consistency?(level)
+          options[:consistency] = level
+        else
+          fail ArgumentError, "'#{level}' is not a valid Cassandra consistency level"
+        end
+        record.id.tap do |key|
+          ActiveSupport::Notifications.instrument('update.datastax_rails', column_family: column_family,
+                                                                           key:           key.to_s,
+                                                                           attributes:    record.attributes) do
+            if (storage_method == :solr)
+              write_with_solr(record.id_for_update, encode_attributes(record, false, attributes), options)
+            else
+              write_with_cql(record.id_for_update, encode_attributes(record, true, attributes), options)
             end
           end
         end
@@ -102,13 +131,17 @@ module DatastaxRails
       # @param [DatastaxRails::Base] record the record whose attributes we're encoding
       # @param [Boolean] cql True if we're formatting for CQL, otherwise False
       # @return [Hash] a new hash with attributes encoded for storage
-      def encode_attributes(record, cql)
+      def encode_attributes(record, cql, attributes = {})
         encoded = {}
         Types::DirtyCollection.ignore_modifications do
-          record.changed.each do |column_name|
-            value = record.read_attribute(column_name)
-            encoded[column_name.to_s] = cql ? attribute_definitions[column_name].type_cast_for_cql3(value) :
-                                              attribute_definitions[column_name].type_cast_for_solr(value)
+          if attributes.empty?
+            record.send(cql ? 'changed' : 'column_names').each do |column_name|
+              attributes[column_name] = record.read_attribute(column_name)
+            end
+          end
+          attributes.each do |k, v|
+            encoded[k.to_s] = cql ? attribute_definitions[k].type_cast_for_cql3(v) :
+                                    attribute_definitions[k].type_cast_for_solr(v)
           end
         end
         encoded
@@ -116,19 +149,17 @@ module DatastaxRails
 
       private
 
-      def write_with_cql(record, options)
-        encoded = encode_attributes(record, true)
+      def write_with_cql(id, encoded, options)
         if options[:new_record]
           cql.insert.columns(encoded).using(options[:consistency]).execute
         else
-          cql.update(record.id_for_update).columns(encoded).using(options[:consistency]).execute
+          cql.update(id).columns(encoded).using(options[:consistency]).execute
         end
       end
 
-      def write_with_solr(record, options)
-        encoded = encode_attributes(record, false)
-        xml_doc = RSolr::Xml::Generator.new.add(encoded.merge(primary_key => record.id.to_s))
-        solr_connection.update(data: xml_doc, params: { replacefields: false, cl: options[:consistency] })
+      def write_with_solr(id, encoded, options)
+        xml_doc = RSolr::Xml::Generator.new.add(encoded)
+        solr_connection.update(data: xml_doc, params: { cl: options[:consistency] })
       end
     end
 
@@ -151,6 +182,7 @@ module DatastaxRails
       @destroyed = true
       freeze
     end
+    alias_method :destroy_without_callbacks, :destroy
 
     # TODO: Make this work
     # def touch(name = nil)
@@ -190,7 +222,7 @@ module DatastaxRails
     end
 
     # Updates the attributes of the model from the passed-in hash and saves the
-    # record If the object is invalid, the saving will fail and false will be returned.
+    # record. If the object is invalid, the saving will fail and false will be returned.
     def update_attributes(attributes, _options = {})
       assign_attributes(attributes)
       save

data/lib/datastax_rails/railtie.rb

@@ -27,6 +27,13 @@ module DatastaxRails
           end
         end
       end
+
+      # Instrumentation
+      require 'datastax_rails/instrumentation/log_subscriber'
+      require 'datastax_rails/instrumentation/controller_runtime'
+      ActiveSupport.on_load(:action_controller) do
+        include DatastaxRails::Instrumentation::ControllerRuntime
+      end
     end
 
     rake_tasks do

data/lib/datastax_rails/reflection.rb

@@ -185,18 +185,22 @@ module DatastaxRails
         @type ||= options[:as] && "#{options[:as]}_type"
       end
 
+      def primary_key_column
+        @primary_key_column ||= klass.columns.find { |c| c.name == klass.primary_key }
+      end
+
       def association_foreign_key
         @association_foreign_key ||= options[:association_foreign_key] || class_name.foreign_key
       end
 
       # klass option is necessary to support loading polymorphic associations
-      # def association_primary_key(klass = nil)
-      # options[:primary_key] || primary_key(klass || self.klass)
-      # end
-      #
-      # def datastax_rails_primary_key
-      # @datastax_rails_primary_key ||= options[:primary_key] || primary_key(solandra_object)
-      # end
+      def association_primary_key(klass = nil)
+        options[:primary_key] || primary_key(klass || self.klass)
+      end
+      
+      def datastax_rails_primary_key
+        @datastax_rails_primary_key ||= options[:primary_key] || primary_key(datastax_rails)
+      end
 
       def check_validity!
         check_validity_of_inverse!
@@ -303,9 +307,9 @@ module DatastaxRails
         end
       end
 
-      # def primary_key(klass)
-      # klass.key || raise(UnknownPrimaryKey.new(klass))
-      # end
+      def primary_key(klass)
+        klass.primary_key || raise(UnknownPrimaryKey.new(klass))
+      end
     end
 
     # Holds all the meta-data about a :through association as it was specified
@@ -385,7 +389,7 @@ module DatastaxRails
       # of relevant reflections, plus any :source_type or polymorphic :as constraints.
       def conditions
         @conditions ||= begin
-          conditions = source_reflection.conditions.map { |c| c.dup }
+          conditions = source_reflection.conditions.map(&:dup)
 
           # Add to it the conditions from this reflection if necessary.
           conditions.first << options[:conditions] if options[:conditions]
@@ -434,7 +438,7 @@ module DatastaxRails
       #
       def source_reflection_names
         @source_reflection_names ||=
-          (options[:source] ? [options[:source]] : [name.to_s.singularize, name]).map { |n| n.to_sym }
+          (options[:source] ? [options[:source]] : [name.to_s.singularize, name]).map(&:to_sym)
       end
 
       def source_options

data/lib/datastax_rails/relation/batches.rb

@@ -85,7 +85,7 @@ module DatastaxRails
       records = start ? relation.where(@klass.primary_key).greater_than(start).to_a : relation.to_a
       while records.size > 0
         records_size = records.size
-        offset = records.last.id
+        offset = records.last.__id
         yield records
 
         break if records_size < batch_size

data/lib/datastax_rails/relation/finder_methods.rb

@@ -81,14 +81,14 @@ module DatastaxRails
     # Post.find_by "published_at < ?", 2.weeks.ago
     def find_by(*args)
       where_values << escape_attributes(args.first)
-      first
+      dont_escape.first
     end
 
     # Like <tt>find_by</tt>, except that if no record is found, raises
     # an <tt>DatastaxRails::RecordNotFound</tt> error.
     def find_by!(*args)
       where_values << escape_attributes(args.first)
-      first!
+      dont_escape.first!
     end
 
     # A convenience wrapper for <tt>find(:first, *args)</tt>. You can pass in all the
@@ -155,7 +155,7 @@ module DatastaxRails
       escaped = {}
       conditions.each do |k, v|
         if v.is_a?(String)
-          escaped[k] = v.gsub(/(\W)/, '\\\\\1')
+          escaped[k] = v.gsub(/([^\w\- ])/, '\\\\\1')
         else
           escaped[k] = v
         end
@@ -183,7 +183,7 @@ module DatastaxRails
     end
 
     def find_one(id)
-      key = @klass.attribute_definitions[@klass.primary_key].type_cast(id)
+      key = @klass.attribute_definitions[@klass.primary_key].type_cast_for_cql3(id)
       key || fail(RecordNotFound, "Couldn't find #{@klass.name} with an invalid ID=#{id}")
 
       with_cassandra.where(@klass.primary_key => key).first ||
@@ -192,7 +192,7 @@ module DatastaxRails
 
     def find_some(ids)
       keys = ids.map do |id|
-        @klass.attribute_definitions[@klass.primary_key].type_cast(id) ||
+        @klass.attribute_definitions[@klass.primary_key].type_cast_for_cql3(id) ||
           fail(RecordNotFound, "Couldn't find #{@klass.name} with an invalid ID=#{id}")
       end
       result = with_cassandra.where(@klass.primary_key => keys).all

data/lib/datastax_rails/relation/modification_methods.rb

@@ -1,6 +1,6 @@
 module DatastaxRails
   module ModificationMethods
-    # Destroys the records matching +conditions+ by instantiating each
+    # Destroys the records matching this relation by instantiating each
     # record and calling its +destroy+ method. Each object's callbacks are
     # executed (including <tt>:dependent</tt> association options and
     # +before_destroy+/+after_destroy+ Observer methods). Returns the
@@ -10,35 +10,20 @@ module DatastaxRails
     #
     # Note: Instantiation, callback execution, and deletion of each
     # record can be time consuming when you're removing many records at
-    # once. However, it is necessary to perform it this way to ensure
-    # that the SOLR index stays in sync with the Cassandra data store.
+    # once. However, it is necessary to perform it this way since we have
+    # to get the results from SOLR (most likely) in order to know what to delete.
     #
-    # +delete_all+ is aliased to this because you can't delete without running
-    # the requisite callbacks. (at least not yet)
-    #
-    # ==== Parameters
-    #
-    # * +conditions+ - A string, array, or hash that specifies which records
-    # to destroy. If omitted, all records matching the current relation are
-    # destroyed. See the Conditions section in the introduction to
-    # DatastaxRails::Base for more information.
-    #
-    # ==== Examples
-    #
-    # Person.destroy_all(:status => "inactive")
+    # Person.destroy_all
     # Person.where(:age => 0..18).destroy_all
     # Person.where_not(:status => "active").destroy_all
-    def destroy_all(conditions = nil)
-      if conditions
-        ret = where(conditions).destroy_all
-      else
-        ret = to_a.each { |object| object.destroy }
-      end
-      reset
-      ret
+    def destroy_all
+      to_a.each(&:destroy).tap { |_| reset }
+    end
+
+    # Like +destroy_all+ but will not run callbacks. It will still have to instantiate the objects.
+    def delete_all
+      select(klass.primary_key).to_a.each(&:destroy_without_callbacks).tap { |_| reset }
     end
-    # TODO: Find a way to delete from both without instantiating
-    alias_method :delete_all, :destroy_all
 
     # Destroy an object (or multiple objects) that has the given id, the object is instantiated first,
     # therefore all callbacks and filters are fired off before the object is deleted. This method is

data/lib/datastax_rails/relation/search_methods.rb

@@ -397,8 +397,6 @@ module DatastaxRails
                 r.where_values << { k => value }
               end
               attributes.delete(k)
-            else
-              attributes[k] = solr_format(k, v)
             end
           end
           r.where_values << attributes unless attributes.empty?
@@ -441,8 +439,6 @@ module DatastaxRails
                 r.where_not_values << { k => value }
               end
               attributes.delete(k)
-            else
-              attributes[k] = solr_format(k, v)
             end
           end
           r.where_not_values << attributes unless attributes.empty?
@@ -545,7 +541,8 @@ module DatastaxRails
       when value.is_a?(Time) || value.is_a?(DateTime) || value.is_a?(Date)
         column.type_cast_for_solr(value)
       when value.is_a?(Array) || value.is_a?(Set)
-        column.type_cast_for_solr(value).map { |v| v.to_s.gsub(/ /, '\\ ') }.join(' OR ')
+        value = value.to_a.compact if column.primary
+        value.map { |v| column.type_cast_for_solr(v, column.options[:holds]).to_s.gsub(/ /, '\\ ') }.join(' OR ')
       when value.is_a?(Fixnum)
         value < 0 ? "\\#{value}" : value
       when value.is_a?(Range)
@@ -554,6 +551,8 @@ module DatastaxRails
         solr_escape(downcase_query(value.gsub(/ /, '\\ ')))
       when value.is_a?(FalseClass), value.is_a?(TrueClass)
         value.to_s
+        # when value.is_a?(::Cql::Uuid)
+        # value.to_s
       else
         value
       end
@@ -570,9 +569,9 @@ module DatastaxRails
       def equal_to(value) #:nodoc:
         @relation.clone.tap do |r|
           if @invert
-            r.where_not_values << { @attribute => r.solr_format(@attribute, value) }
+            r.where_not_values << { @attribute => value }
           else
-            r.where_values << { @attribute => r.solr_format(@attribute, value) }
+            r.where_values << { @attribute => value }
           end
         end
       end
@@ -580,9 +579,9 @@ module DatastaxRails
       def greater_than(value) #:nodoc:
         @relation.clone.tap do |r|
           if @invert
-            r.less_than_values << { @attribute => r.solr_format(@attribute, value) }
+            r.less_than_values << { @attribute => value }
           else
-            r.greater_than_values << { @attribute => r.solr_format(@attribute, value) }
+            r.greater_than_values << { @attribute => value }
           end
         end
       end
@@ -590,9 +589,9 @@ module DatastaxRails
       def less_than(value) #:nodoc:
         @relation.clone.tap do |r|
           if @invert
-            r.greater_than_values << { @attribute => r.solr_format(@attribute, value) }
+            r.greater_than_values << { @attribute => value }
           else
-            r.less_than_values << { @attribute => r.solr_format(@attribute, value) }
+            r.less_than_values << { @attribute => value }
           end
         end
       end