datastax_rails 1.0.16.3 → 1.0.17.1

data/lib/datastax_rails/attribute_methods.rb

@@ -53,7 +53,11 @@ module DatastaxRails
     
     # Casts the attribute and stores it in the attribute hash.
     def write_attribute(name, value)
-      @attributes[name.to_s] = self.class.typecast_attribute(self, name, value)
+      if(attribute_definitions[name.to_sym].coder.is_a?(DatastaxRails::Types::BinaryType))
+        @attributes[name.to_s] = value
+      else
+        @attributes[name.to_s] = self.class.typecast_attribute(self, name, value)
+      end
     end
 
     # Returns the attribute out of the attribute hash.  If the attribute is lazy loaded and hasn't

data/lib/datastax_rails/base.rb

@@ -478,6 +478,10 @@ module DatastaxRails #:nodoc:
         @column_family || name.pluralize
       end
       
+      def payload_model?
+        self.ancestors.include?(DatastaxRails::PayloadModel)
+      end
+      
       def base_class
         klass = self
         while klass.superclass != Base

data/lib/datastax_rails/collection.rb

@@ -4,10 +4,19 @@ module DatastaxRails
     #   @return [Fixnum] the total number of entries that match the search
     # @!attribute [r] last_column_name
     #   @return [Fixnum] the last column that was returned in the search in case you limited the number of columns (not supported)
-    attr_accessor :last_column_name, :total_entries
+    # @!attribute [r] per_page
+    #   @return [Fixnum] the per page value of the search that produced these results (used by will_paginate)
+    # @!attribute [r] current_page
+    #   @return [Fixnum] the current page of the search that produced these results (used by will_paginate)
+    attr_accessor :last_column_name, :total_entries, :per_page, :current_page
     
     def inspect
       "<DatastaxRails::Collection##{object_id} contents: #{super} last_column_name: #{last_column_name.inspect}>"
     end
+    
+    def total_pages
+      return 1 unless per_page
+      (total_entries / per_page.to_f).ceil
+    end
   end
 end

data/lib/datastax_rails/cql/alter_column_family.rb

@@ -0,0 +1,48 @@
+module DatastaxRails#:nodoc:
+  module Cql #:nodoc:
+    class AlterColumnFamily < Base #:nodoc:
+      def initialize(cf_name)
+        @cf_name = cf_name
+        @action = nil
+      end
+      
+      def add(column)
+        set_column(column)
+        @action = 'ADD' 
+        self
+      end
+      
+      def drop(column)
+        set_column(column)
+        @action = 'DROP'
+        self 
+      end
+      
+      def alter(column)
+        set_column(column)
+        @action = 'ALTER'
+        self 
+      end
+
+      def set_column(column)  
+        if(@action)
+          raise ArgumentError, "Only one operation allowed per CQL call"
+        end
+        @column = column
+      end
+      
+      def to_cql
+        stmt = "ALTER COLUMNFAMILY #{@cf_name} "
+        if(@action == 'ALTER')
+          stmt << "ALTER #{@column.keys.first} TYPE #{@column.values.first}"
+        elsif(@action == 'ADD')
+          stmt << "ADD #{@column.keys.first} #{@column.values.first}"
+        elsif(@action == 'DROP')
+          stmt << "DROP #{@column}"
+        end
+        
+        stmt
+      end
+    end
+  end
+end

data/lib/datastax_rails/cql/base.rb

@@ -16,6 +16,7 @@ module DatastaxRails
       # already been set up (Rails does this for you).
       def execute
         cql = self.to_cql
+        # puts cql
         DatastaxRails::Base.connection.execute_cql_query(cql)
       end
     end

data/lib/datastax_rails/cql/create_column_family.rb

@@ -4,8 +4,9 @@ module DatastaxRails#:nodoc:
       def initialize(cf_name)
         @cf_name = cf_name
         @columns = {}
-        @storage_parameters = {}
+        @storage_parameters = []
         @key_type = 'uuid'
+        @key_columns = @key_name = "KEY"
       end
       
       def key_type(key_type)
@@ -13,8 +14,18 @@ module DatastaxRails#:nodoc:
         self
       end
       
+      def key_name(key_name)
+        @key_name = key_name
+        self
+      end
+      
+      def key_columns(key_columns)
+        @key_columns = key_columns
+        self
+      end
+      
       def with(with)
-        @storage_parameters.merge!(with)
+        @storage_parameters << with
         self
       end
       
@@ -36,24 +47,15 @@ module DatastaxRails#:nodoc:
         with("default_validation" => val)
       end
       
-      def column_type=(type)
-        # TODO: Ignored till CQL supports super-columns
-      end
-      
       def to_cql
-        stmt = "CREATE COLUMNFAMILY #{@cf_name} (key #{@key_type} PRIMARY KEY"
+        stmt = "CREATE COLUMNFAMILY #{@cf_name} (\"#{@key_name}\" #{@key_type}, "
         @columns.each do |name,type|
-          stmt << ", #{name} #{type}"
+          stmt << "#{name} #{type}, "
         end
-        stmt << ")"
+        stmt << "PRIMARY KEY (\"#{@key_columns}\"))"
         unless @storage_parameters.empty?
           stmt << " WITH "
-          first_parm = @storage_parameter.shift
-          stmt << "#{first_parm.first.to_s} = '#{first_parm.last.to_s}'"
-          
-          @storage_parameters.each do |key, value|
-            stmt << " AND #{key.to_s} = '#{value.to_s}'"
-          end
+          stmt << @storage_parameters.join(" AND ")
         end
         
         stmt

data/lib/datastax_rails/cql/delete.rb

@@ -6,6 +6,8 @@ module DatastaxRails
         @keys = keys
         @timestamp = nil
         @columns = []
+        @conditions = {}
+        @key_name = "KEY"
         super
       end
       
@@ -19,22 +21,37 @@ module DatastaxRails
         self
       end
       
+      def conditions(conditions)
+        @conditions.merge!(conditions)
+        self
+      end
+      
       def timestamp(timestamp)
         @timestamp = timestamp
         self
       end
       
+      def key_name(key_name)
+        @key_name = key_name
+        self
+      end
+      
       def to_cql
-        values = []
+        values = [@keys]
         stmt = "DELETE #{@columns.join(',')} FROM #{@klass.column_family} USING CONSISTENCY #{@consistency} "
         
         if(@timestamp)
           stmt << "AND TIMESTAMP #{@timestamp} "
         end
         
-        stmt << "WHERE KEY IN (?)"
+        stmt << "WHERE \"#{@key_name}\" IN (?)"
+        
+        @conditions.each do |col,val|
+          stmt << " AND #{col} = ?"
+          values << val
+        end
         
-        CassandraCQL::Statement.sanitize(stmt, @keys)
+        CassandraCQL::Statement.sanitize(stmt, values)
       end
     end
   end

data/lib/datastax_rails/cql/select.rb

@@ -6,6 +6,7 @@ module DatastaxRails#:nodoc:
         @select = select.join(",")
         @limit = nil
         @conditions = {}
+        @order = nil
         super
       end
       
@@ -24,6 +25,11 @@ module DatastaxRails#:nodoc:
         self
       end
       
+      def order(order)
+        @order = order
+        self
+      end
+      
       def to_cql
         conditions = []
         values = []
@@ -31,9 +37,9 @@ module DatastaxRails#:nodoc:
         @conditions.each do |k,v|
           values << v
           if v.kind_of?(Array)
-            conditions << "#{k.to_s} IN (?)"
+            conditions << "\"#{k.to_s}\" IN (?)"
           else
-            conditions << "#{k.to_s} = ?"
+            conditions << "\"#{k.to_s}\" = ?"
           end
         end
         
@@ -42,7 +48,11 @@ module DatastaxRails#:nodoc:
         end
         
         if @limit
-          stmt << "LIMIT #{@limit}"
+          stmt << "LIMIT #{@limit} "
+        end
+        
+        if @order
+          stmt << "ORDER BY #{@order}"
         end
         
         CassandraCQL::Statement.sanitize(stmt, values)

data/lib/datastax_rails/cql/update.rb

@@ -35,9 +35,9 @@ module DatastaxRails
       
       def to_cql
         column_names = @columns.keys
-        cql = ""
-        Tempfile.open('cql', Rails.root.join("tmp")) do |stmt|
-          stmt << "update #{@klass.column_family} using consistency #{@consistency} "
+        
+        
+          stmt = "update #{@klass.column_family} using consistency #{@consistency} "
           
           if(@ttl)
             stmt << "AND TTL #{@ttl} "
@@ -52,17 +52,14 @@ module DatastaxRails
             
             first_entry = column_names.first
             
-            stmt << CassandraCQL::Statement.sanitize("#{first_entry.to_s} = ?", [@columns[first_entry]])
+            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]])
+              stmt << CassandraCQL::Statement.sanitize(", \"#{col.to_s}\" = ?", [@columns[col]])
             end
           end
           
-          stmt << CassandraCQL::Statement.sanitize(" WHERE KEY IN (?)", [@key])
-          stmt.rewind
-          cql = stmt.read
-        end
-        cql
+          stmt << CassandraCQL::Statement.sanitize(" WHERE \"KEY\" IN (?)", [@key])
+        stmt
       end
       
       # def execute

data/lib/datastax_rails/cql.rb

@@ -8,6 +8,7 @@ module DatastaxRails
       end
     end
     
+    autoload :AlterColumnFamily
     autoload :Base
     autoload :ColumnFamily
     autoload :Consistency

data/lib/datastax_rails/identity/natural_key_factory.rb

@@ -4,6 +4,7 @@ module DatastaxRails
       class NaturalKey
         attr_reader :value
 
+        delegate :size, :bytesize, :to => :value
         def initialize(value)
           @value = value
         end

data/lib/datastax_rails/payload_model.rb

@@ -0,0 +1,89 @@
+module DatastaxRails
+  # A special model that is designed to efficiently store binary files.
+  # The major limitation is that the only fields this can store are
+  # the SHA1 digest and the payload itself.  If you need to store
+  # other metadata, you will need another model that points at this
+  # one.
+  #
+  #   class AttachmentPayload < DatastaxRails::Payload
+  #     self.column_family = 'attachment_payloads'
+  #
+  #     validate do
+  #       if self.payload.size > 50.megabytes
+  #         errors.add(:payload, "is larger than the limit of 50MB")
+  #       end
+  #     end
+  #   end
+  class PayloadModel < Base
+    
+    def self.inherited(child)
+      super
+      child.key :natural, :attributes => :digest
+      child.string :digest
+      child.binary :payload
+      child.validates :digest, :presence => true
+    end
+    
+    def self.scoped
+      super.with_cassandra
+    end
+    
+    def self.find(digest, options = {})
+      raise ArgumentError, "'#{options[:consistency]}' is not a valid Cassandra consistency level" unless valid_consistency?(options[:consistency].to_s.upcase) if options[:consistency]
+      c = cql.select.conditions(:digest => digest).order('chunk')
+      c.using(options[:consistency]) if options[:consistency]
+      io = StringIO.new("","w+")
+      found = false
+      CassandraCQL::Result.new(c.execute).fetch do |row|
+        io << Base64.decode64(row.to_hash['payload'])
+        found = true
+      end
+      raise DatastaxRails::RecordNotFound unless found
+      io.rewind
+      self.instantiate(digest, {:digest => digest, :payload => io.read}, [:digest, :payload])
+    end
+    
+    def self.write(key, attributes, options = {})
+      raise ArgumentError, "'#{options[:consistency]}' is not a valid Cassandra consistency level" unless valid_consistency?(options[:consistency].to_s.upcase) if options[:consistency]
+      c = self.cql.select("count(*)").conditions(:digest => key)
+      count = CassandraCQL::Result.new(c.execute).fetch.to_hash["count"]
+      
+      i = 0
+      io = StringIO.new(attributes['payload'])
+      while chunk = io.read(1.megabyte)
+        c = cql.insert.columns(:digest => key, :chunk => i, :payload => Base64.encode64(chunk))
+        c.using(options[:consistency]) if options[:consistency]
+        c.execute
+        i += 1
+      end
+      
+      if count and count > i
+        i.upto(count) do |j|
+          c = cql.delete(key.to_s).key_name('digest').conditions(:chunk => j)
+          c.using(options[:consistency]) if options[:consistency]
+          c.execute
+        end
+      end
+      
+      key
+    end
+    
+    # Instantiates a new object without calling +initialize+.
+    #
+    # @param [String] key the primary key for the record
+    # @param [Hash] attributes a hash containing the columns to set on the record
+    # @param [Array] selected_attributes an array containing the attributes that were originally selected from cassandra
+    #   to build this object.  Used so that we can avoid lazy-loading attributes that don't exist.
+    # @return [DatastaxRails::Base] a model with the given attributes
+    def self.instantiate(key, attributes, selected_attributes = [])
+      allocate.tap do |object|
+        object.instance_variable_set("@loaded_attributes", {}.with_indifferent_access)
+        object.instance_variable_set("@key", parse_key(key)) if key
+        object.instance_variable_set("@new_record", false)
+        object.instance_variable_set("@destroyed", false)
+        object.instance_variable_set("@attributes", attributes.with_indifferent_access)
+        attributes.keys.each {|k| object.instance_variable_get("@loaded_attributes")[k] = true}
+      end
+    end
+  end
+end

data/lib/datastax_rails/persistence.rb

@@ -54,10 +54,9 @@ module DatastaxRails
       # @param [Hash] attributes a hash containing the columns to set on the record
       # @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 [String] :schema_version the version of the schema to set for this record
       def write(key, attributes, options = {})
         key.tap do |key|
-          attributes = encode_attributes(attributes, options[:schema_version])
+          attributes = encode_attributes(attributes)
           ActiveSupport::Notifications.instrument("insert.datastax_rails", :column_family => column_family, :key => key, :attributes => attributes) do
             c = cql.update(key.to_s).columns(attributes)
             if(options[:consistency])
@@ -73,10 +72,6 @@ module DatastaxRails
         end
       end
       
-      def store_file(key, file, options = {})
-       
-      end
-
       # Instantiates a new object without calling +initialize+.
       #
       # @param [String] key the primary key for the record
@@ -87,7 +82,6 @@ module DatastaxRails
       def instantiate(key, attributes, selected_attributes = [])
         allocate.tap do |object|
           object.instance_variable_set("@loaded_attributes", {}.with_indifferent_access)
-          object.instance_variable_set("@schema_version", attributes.delete('schema_version'))
           object.instance_variable_set("@key", parse_key(key)) if key
           object.instance_variable_set("@new_record", false)
           object.instance_variable_set("@destroyed", false)
@@ -99,23 +93,11 @@ module DatastaxRails
       # to do the heavy lifting.
       #
       # @param [Hash] attributes a hash containing the attributes to be encoded for storage
-      # @param [String] schema_version the schema version to set in Cassandra.  Not currently used.
       # @return [Hash] a new hash with attributes encoded for storage
-      def encode_attributes(attributes, schema_version)
-        encoded = {"schema_version" => schema_version.to_s}
+      def encode_attributes(attributes)
+        encoded = {}
         attributes.each do |column_name, value|
-          # if value.nil?
-            # encoded[column_name.to_s] = ""
-          # else
-            encoded_value = attribute_definitions[column_name.to_sym].coder.encode(value)
-            if(encoded_value.is_a?(Array))
-              encoded_value.each_with_index do |chunk,i|
-                encoded[column_name.to_s + "_chunk_#{'%05d' % i}"] = chunk
-              end
-            else
-              encoded[column_name.to_s] = encoded_value
-            end
-          # end
+            encoded[column_name.to_s] = attribute_definitions[column_name.to_sym].coder.encode(value)
         end
         encoded
       end
@@ -129,13 +111,7 @@ module DatastaxRails
         end
         
         attribute_definitions.each do |k,definition|
-          if(definition.coder.is_a?(DatastaxRails::Types::BinaryType))
-            # Need to handle possibly chunked data
-            chunks = attributes.select {|key,value| key.to_s =~ /#{k.to_s}_chunk_\d+/ }.sort {|a,b| a.first.to_s <=> b.first.to_s}.collect {|c| c.last}
-            casted[k.to_s] = definition.instantiate(object, chunks)
-          else
-            casted[k.to_s] = definition.instantiate(object, attributes[k])
-          end
+          casted[k.to_s] = definition.instantiate(object, attributes[k])
         end
         casted
       end
@@ -210,7 +186,8 @@ module DatastaxRails
       
       def write(options) #:nodoc:
         changed_attributes = changed.inject({}) { |h, n| h[n] = read_attribute(n); h }
-        self.class.write(key, changed_attributes, options.merge(:schema_version => schema_version))
+        return true if changed_attributes.empty?
+        self.class.write(key, changed_attributes, options)
       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 #{primary_key}=#{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.rb

@@ -371,6 +371,8 @@ module DatastaxRails
     # @return [DatastaxRails::Collection] the resulting collection
     def parse_docs(response, select_columns)
       results = DatastaxRails::Collection.new
+      results.per_page = @per_page_value
+      results.current_page = @page_value || 1
       results.total_entries = response['numFound'].to_i
       response['docs'].each do |doc|
         id = doc['id']