datastax_rails 1.2.3 → 2.0.3

data/lib/datastax_rails/schema/solr.rb

@@ -10,46 +10,29 @@ module DatastaxRails
         @fields = []
         @copy_fields = []
         @fulltext_fields = []
-        @custom_fields = ""
-        model.attribute_definitions.values.each do |attr|
-          coder = attr.coder
-          if coder.options[:solr_type]
-            @fields.push({ :name => attr.name,
-                           :type => coder.options[:solr_type].to_s,
-                           :indexed => (coder.options[:indexed] == :solr || coder.options[:indexed] == :both).to_s,
-                           :stored => coder.options[:stored].to_s,
-                           :multi_valued => coder.options[:multi_valued].to_s })
-          end
-          if coder.options[:sortable] && coder.options[:tokenized]
-            @fields.push({ :name => "sort_" + attr.name,
-                           :type => "string",
-                           :indexed => true,
-                           :stored => false,
-                           :multi_valued => false })
-            @copy_fields.push({ :source => attr.name, :dest => "sort_" + attr.name }) if (coder.options[:indexed] || coder.options[:stored])
-          end
-          if coder.options[:fulltext]
-            @fulltext_fields << attr.name if (coder.options[:indexed] || coder.options[:stored])
-          end
+        if model <= WideStorageModel
+          @primary_key = "(#{model.primary_key},#{model.cluster_by})"
+        else
+          @primary_key = model.primary_key
         end
-        # Sort the fields so that no matter what order the attributes are arranged into the
-        # same schema file gets generated
+        @custom_fields = ""
+        @columns = model.attribute_definitions.values
         @fields.sort! {|a,b| a[:name] <=> b[:name]}
         @copy_fields.sort! {|a,b| a[:source] <=> b[:source]}
         @fulltext_fields.sort!
         
         if Rails.root.join('config','solr',"#{model.column_family}-schema.xml.erb").exist?
           say "Using custom schema for #{model.name}", :subitem
-          ERB.new(Rails.root.join('config','solr',"#{model.column_family}-schema.xml.erb").read).result(binding)
+          ERB.new(Rails.root.join('config','solr',"#{model.column_family}-schema.xml.erb").read, 0, '>').result(binding)
         else
-          ERB.new(File.read(File.join(File.dirname(__FILE__),"..","..","..","config","schema.xml.erb"))).result(binding)
+          ERB.new(File.read(File.join(File.dirname(__FILE__),"..","..","..","config","schema.xml.erb")), 0, '>').result(binding)
         end
       end
       
       # Sends a command to Solr instructing it to reindex the data.  The data is reindexed in the background,
       # and the new index is swapped in once it is finished.
-      def reindex_solr(model)
-        url = "#{DatastaxRails::Base.solr_base_url}/admin/cores?action=RELOAD&name=#{DatastaxRails::Base.config[:keyspace]}.#{model.column_family}&reindex=true&deleteAll=false"
+      def reindex_solr(model, destructive=false)
+        url = "#{DatastaxRails::Base.solr_base_url}/admin/cores?action=RELOAD&name=#{DatastaxRails::Base.config[:keyspace]}.#{model.column_family}&reindex=true&deleteAll=#{destructive.to_s}"
         say "Posting reindex command to '#{url}'", :subitem
         `curl -s -X POST '#{url}'`
         say "Reindexing will run in the background", :subitem
@@ -89,11 +72,11 @@ module DatastaxRails
         stopwords_digest = Digest::SHA1.hexdigest(stopwords)
         schema_digest = Digest::SHA1.hexdigest(schema)
         
-        newcf = !column_family_exists?(model.column_family.to_s)
+        newcf = !column_exists?(model.column_family, 'solr_query')
         force ||= newcf
         
-        results = DatastaxRails::Cql::Select.new(SchemaMigration, ['*']).conditions(:key => model.column_family).execute
-        sm_digests = CassandraCQL::Result.new(results).fetch.try(:to_hash) || {}
+        results = DatastaxRails::Cql::Select.new(SchemaMigration, ['*']).conditions(:cf => model.column_family).execute
+        sm_digests = results.first || {}
         
         solr_url = "#{DatastaxRails::Base.solr_base_url}/resource/#{@keyspace}.#{model.column_family}"
         

data/lib/datastax_rails/schema_cache.rb

@@ -0,0 +1,67 @@
+module DatastaxRails
+  class SchemaCache
+    attr_reader :primary_keys, :tables
+    attr_reader :connection
+
+    def initialize(conn)
+      @connection = conn
+      @tables     = {}
+
+      @columns = Hash.new do |h, table_name|
+        h[table_name] = connection.columns(table_name, "#{table_name} Columns")
+      end
+
+      @columns_hash = Hash.new do |h, table_name|
+        h[table_name] = Hash[columns[table_name].map { |col|
+          [col.name, col]
+        }]
+      end
+
+      @primary_keys = Hash.new do |h, table_name|
+        h[table_name] = table_exists?(table_name) ? connection.primary_key(table_name) : nil
+      end
+    end
+
+    # A cached lookup for table existence.
+    def table_exists?(name)
+      return @tables[name] if @tables.key? name
+
+      @tables[name] = connection.table_exists?(name)
+    end
+
+    # Get the columns for a table
+    def columns(table = nil)
+      if table
+        @columns[table]
+      else
+        @columns
+      end
+    end
+
+    # Get the columns for a table as a hash, key is the column name
+    # value is the column object.
+    def columns_hash(table = nil)
+      if table
+        @columns_hash[table]
+      else
+        @columns_hash
+      end
+    end
+
+    # Clears out internal caches
+    def clear!
+      @columns.clear
+      @columns_hash.clear
+      @primary_keys.clear
+      @tables.clear
+    end
+
+    # Clear out internal caches for table with +table_name+.
+    def clear_table_cache!(table_name)
+      @columns.delete table_name
+      @columns_hash.delete table_name
+      @primary_keys.delete table_name
+      @tables.delete table_name
+    end
+  end
+end

data/lib/datastax_rails/timestamps.rb

@@ -1,25 +1,98 @@
 module DatastaxRails
+  # = DatastaxRails Timestamps
+  #
+  # DatastaxRails automatically timestamps create and update operations if the
+  # table has fields named <tt>created_at</tt> or <tt>updated_at</tt>.
+  #
+  # Timestamping can be turned off by setting:
+  #
+  #   DatastaxRails::Base.record_timestamps = false
   module Timestamps
     extend ActiveSupport::Concern
 
     included do
-      # attribute :created_at, :type => :time#_with_zone
-      # attribute :updated_at, :type => :time#_with_zone
+      class_attribute :record_timestamps
+      self.record_timestamps = true
+    end
 
-      before_create do #|r|
-        if self.respond_to?(:created_at=)
-          self.created_at ||= Time.current
-        end
-        if self.respond_to?(:updated_at=)
-          self.updated_at ||= Time.current
+    def initialize_dup(other) # :nodoc:
+      clear_timestamp_attributes
+      super
+    end
+
+  private
+
+    def _create_record(*args)
+      if self.record_timestamps
+        current_time = current_time_from_proper_timezone
+
+        all_timestamp_attributes.each do |column|
+          if respond_to?(column) && respond_to?("#{column}=") && self.send(column).nil?
+            write_attribute(column.to_s, current_time)
+          end
         end
       end
 
-      before_update :if => :changed? do #|r|
-        if self.respond_to?(:updated_at=)
-          self.updated_at = Time.current
+      super
+    end
+
+    def _update_record(*args)
+      if should_record_timestamps?
+        current_time = current_time_from_proper_timezone
+
+        timestamp_attributes_for_update_in_model.each do |column|
+          column = column.to_s
+          next if attribute_changed?(column)
+          write_attribute(column, current_time)
         end
       end
+      super
+    end
+
+    def should_record_timestamps?
+      self.record_timestamps && (changed? || (attributes.keys & self.class.serialized_attributes.keys).present?)
+    end
+
+    def timestamp_attributes_for_create_in_model
+      timestamp_attributes_for_create.select { |c| self.class.column_names.include?(c.to_s) }
+    end
+
+    def timestamp_attributes_for_update_in_model
+      timestamp_attributes_for_update.select { |c| self.class.column_names.include?(c.to_s) }
+    end
+
+    def all_timestamp_attributes_in_model
+      timestamp_attributes_for_create_in_model + timestamp_attributes_for_update_in_model
+    end
+
+    def timestamp_attributes_for_update
+      [:updated_at]
+    end
+
+    def timestamp_attributes_for_create
+      [:created_at]
+    end
+
+    def all_timestamp_attributes
+      timestamp_attributes_for_create + timestamp_attributes_for_update
+    end
+
+    def max_updated_column_timestamp
+      if (timestamps = timestamp_attributes_for_update.map { |attr| self[attr] }.compact).present?
+        timestamps.map { |ts| ts.to_time }.max
+      end
+    end
+
+    def current_time_from_proper_timezone
+      self.class.default_timezone == :utc ? Time.now.utc : Time.now
+    end
+
+    # Clear attributes and changed_attributes
+    def clear_timestamp_attributes
+      all_timestamp_attributes_in_model.each do |attribute_name|
+        self[attribute_name] = nil
+        changed_attributes.delete(attribute_name)
+      end
     end
   end
 end

data/lib/datastax_rails/types/dirty_collection.rb

@@ -0,0 +1,88 @@
+# An extension to normal arrays and hashes that allow for tracking of dirty values.  This is
+# used by ActiveModel's change tracking framework.
+module DatastaxRails
+  module Types
+    module DirtyCollection
+      extend ActiveSupport::Concern
+      
+      included do
+        attr_accessor :record, :name
+        
+        methods = [:<<, :delete, :[]=, :add, :subtract, :store, :push, :pop, :unshift, :shift, :insert, :clear] +
+                   ActiveSupport::HashWithIndifferentAccess.instance_methods(true).select{|m| m.to_s.ends_with?('!')} +
+                   Array.instance_methods(true).select{|m| m.to_s.ends_with?('!')} +
+                   Set.instance_methods(true).select{|m| m.to_s.ends_with?('!')}
+                
+        methods.each do |m|
+          if self.instance_methods.include?(m)
+            alias_method "___#{m}", m
+            original_method = self.instance_method(m)
+            define_method(m) do |*args, &block|
+              modifying do
+                original_method.bind(self).call(*args, &block)
+              end
+            end
+          end
+        end
+      end
+      
+      def initialize(record, name, collection)
+        @record   = record
+        @name     = name.to_s
+        
+        super(collection)
+        organize_collection
+      end
+      
+      def delete(obj)
+        modifying do
+          super
+        end
+      end
+      
+      def self.ignore_modifications
+        original = $dsr_ignore_modifications
+        $dsr_ignore_modifications = true
+        result = yield
+        $dsr_ignore_modifications = original
+        result
+      end
+      
+      private
+        def modifying
+          # So there's a problem with overriding the map! method on Array.
+          # When we do the update to record.attributes, HashWithIndifferentAccess
+          # calls .map! on our Array.  This causes infinite recursion which
+          # I find is generally not a desired behavior.  We use a variable
+          # to tell if we've already hijacked the call.
+          if $dsr_ignore_modifications
+            yield
+          else
+            DirtyCollection.ignore_modifications do
+              unless record.changed_attributes.key?(name)
+                original = dup
+              end
+    
+              result = yield
+              
+              organize_collection
+    
+              if !record.changed_attributes.key?(name) && original != self
+                record.changed_attributes[name] = original
+              end
+              
+              record.attributes[name] = self
+              
+              result
+            end
+          end
+        end
+        
+        # A hook to allow implementing classes to muck with the collection
+        # before we check it for equality.
+        def organize_collection
+          # No-op
+        end
+    end
+  end
+end

data/lib/datastax_rails/types/dynamic_list.rb

@@ -0,0 +1,14 @@
+module DatastaxRails
+  module Types
+    # A collection type that allows you to store ordered arrays in Cassandra.
+    # Changes are tracked by hooking into ActiveModel's built-in change
+    # tracking.
+    class DynamicList < Array
+      include DirtyCollection
+
+      def initialize(record, name, collection)
+        super(record, name, collection || [])
+      end
+    end
+  end
+end

data/lib/datastax_rails/types/dynamic_map.rb

@@ -0,0 +1,32 @@
+module DatastaxRails
+  module Types
+    # A collection type that allows you to store key/value pairs in Cassandra.
+    # Changes are tracked by hooking into ActiveModel's built-in change
+    # tracking.
+    #
+    # Keys are converted to have the name of the collection prefixed
+    # to them as this is how the Solr/Cassandra integration converts
+    # between them and dynamic fields.
+    class DynamicMap < ActiveSupport::HashWithIndifferentAccess
+      include DirtyCollection
+            
+      def dup
+        self.class.new(record, name, self).tap do |new_hash|
+          new_hash.default = default
+        end
+      end
+      
+      def [](key)
+        super(convert_key(key))
+      end
+      
+      protected
+        def convert_key(key)
+          unless key.to_s.starts_with?(name)
+            key = name + key.to_s
+          end
+          super(key)
+        end
+    end
+  end
+end

data/lib/datastax_rails/types/dynamic_set.rb

@@ -0,0 +1,10 @@
+module DatastaxRails
+  module Types
+    # A collection type that allows you to store an un-ordered, unique
+    # set of entries. Changes are tracked by hooking into ActiveModel's 
+    # built-in change tracking.
+    class DynamicSet < Set
+      include DirtyCollection
+    end
+  end
+end

data/lib/datastax_rails/util/solr_repair.rb

@@ -1,12 +1,11 @@
 module DatastaxRails
   module SolrRepair
     def repair_solr
-      my_attrs = self.attributes.symbolize_keys.reject do |k,v|
-        v.nil? ||
-        !(self.class.attribute_definitions[k].coder.options[:stored] ||
-          self.class.attribute_definitions[k].coder.options[:indexed])
+      encoded = {}
+      self.attributes.keys.each do |column_name|
+        value = self.read_attribute(column_name)
+        encoded[column_name.to_s] = self.class.column_for_attribute(column_name).type_cast_for_solr(value)
       end
-      encoded = self.class.encode_attributes(my_attrs).merge(:id => self.id)
       xml_doc = RSolr::Xml::Generator.new.add(encoded)
       self.class.solr_connection.update(:data => xml_doc, :params => {:replacefields => false})
     end

data/lib/datastax_rails/validations.rb

@@ -1,5 +1,5 @@
 module DatastaxRails
-  class RecordInvalid < StandardError
+  class RecordInvalid < DatastaxRailsError
     attr_reader :record
     def initialize(record)
       @record = record
@@ -11,14 +11,10 @@ module DatastaxRails
     extend ActiveSupport::Concern
     include ActiveModel::Validations
     
-    included do
-      define_model_callbacks :validation
-      define_callbacks :validate, :scope => :name
-    end
-    
     module ClassMethods
       def create!(attributes = {})
         new(attributes).tap do |object|
+          yield(object) if block_given?
           object.save!
         end
       end
@@ -34,11 +30,9 @@ module DatastaxRails
     # Validations with no <tt>:on</tt> option will run no matter the context. Validations with
     # some <tt>:on</tt> option will only run in the specified context.
     def valid?(context = nil)
-      run_callbacks :validation do
-        context ||= (new_record? ? :create : :update)
-        output = super(context)
-        errors.empty? && output
-      end
+      context ||= (new_record? ? :create : :update)
+      output = super(context)
+      errors.empty? && output
     end
 
     def save(options={})
@@ -51,7 +45,7 @@ module DatastaxRails
 
     protected
       def perform_validations(options={})
-        (options[:validate] != false) ? valid? : true
+        options[:validate] == false || valid?(options[:context])
       end
   end
 end