datastax_rails 1.2.3 → 2.0.3

data/lib/datastax_rails/cql/alter_column_family.rb

@@ -4,7 +4,6 @@ module DatastaxRails#:nodoc:
       def initialize(cf_name)
         @cf_name = cf_name
         @action = nil
-        @consistency = 'QUORUM'
       end
       
       def add(column)

data/lib/datastax_rails/cql/base.rb

@@ -3,15 +3,21 @@ module DatastaxRails
     class Base
       # Base initialize that sets the default consistency.
       def initialize(klass, *args)
-        @consistency = klass.default_consistency.to_s.upcase
+        @consistency = klass.default_consistency.to_s.downcase.to_sym
         @keyspace = DatastaxRails::Base.config[:keyspace]
+        @values = []
+      end
+      
+      def using(consistency)
+        @consistency = consistency.to_s.downcase.to_sym
+        self
       end
       
       def key_name
         @klass.key_factory.key_columns
       end
 
-      # Abstract.  Should be overridden by subclasses
+      # Abstract. Should be overridden by subclasses
       def to_cql
         raise NotImplementedError
       end
@@ -22,7 +28,13 @@ module DatastaxRails
       def execute
         cql = self.to_cql
         puts cql if ENV['DEBUG_CQL'] == 'true'
-        DatastaxRails::Base.connection.execute_cql_query(cql, :consistency => CassandraCQL::Thrift::ConsistencyLevel.const_get(@consistency || 'QUORUM'))
+        pp @values if ENV['DEBUG_CQL'] == 'true'
+        if(@values.present?)
+          stmt = DatastaxRails::Base.connection.prepare(cql)
+          stmt.execute(*@values, :consistency => @consistency)
+        else
+          DatastaxRails::Base.connection.execute(cql, :consistency => @consistency)
+        end
       end
     end
   end

data/lib/datastax_rails/cql/column_family.rb

@@ -30,8 +30,8 @@ module DatastaxRails
         DatastaxRails::Cql::Truncate.new(@klass)
       end
       
-      def update(*keys)
-        DatastaxRails::Cql::Update.new(@klass, keys.flatten)
+      def update(key)
+        DatastaxRails::Cql::Update.new(@klass, key)
       end
     end
   end

data/lib/datastax_rails/cql/create_column_family.rb

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

data/lib/datastax_rails/cql/delete.rb

@@ -7,15 +7,10 @@ module DatastaxRails
         @timestamp = nil
         @columns = []
         @conditions = {}
-        @key_name = "key"
+        @key_name = @klass.primary_key
         super
       end
       
-      def using(consistency)
-        @consistency = consistency
-        self
-      end
-      
       def columns(columns)
         @columns = columns
         self
@@ -37,7 +32,7 @@ module DatastaxRails
       end
       
       def to_cql
-        values = [@keys.collect{|k|k.to_s}]
+        @values = @keys
         stmt = "DELETE #{@columns.join(',')} FROM #{@klass.column_family} "
         
         if(@timestamp)
@@ -48,10 +43,10 @@ module DatastaxRails
         
         @conditions.each do |col,val|
           stmt << " AND #{col} = ?"
-          values << val
+          @values << val
         end
         
-        CassandraCQL::Statement.sanitize(stmt, values)
+        stmt
       end
     end
   end

data/lib/datastax_rails/cql/insert.rb

@@ -9,11 +9,6 @@ module DatastaxRails
         super
       end
       
-      def using(consistency)
-        @consistency = consistency
-        self
-      end
-      
       def columns(columns)
         @columns.merge!(columns)
         self
@@ -30,11 +25,10 @@ module DatastaxRails
       end
       
       def to_cql
-        values = []
         keys = []
         @columns.each do |k,v|
           keys << k.to_s
-          values << v
+          @values << v
         end
         stmt = "INSERT INTO #{@klass.column_family} (#{keys.join(',')}) VALUES (#{('?'*keys.size).split(//).join(',')}) "
         
@@ -46,7 +40,7 @@ module DatastaxRails
           stmt << "AND TIMESTAMP #{@timestamp}"
         end
         
-        CassandraCQL::Statement.sanitize(stmt, values).force_encoding('UTF-8')
+        stmt.force_encoding('UTF-8')
       end
     end
   end

data/lib/datastax_rails/cql/select.rb

@@ -44,15 +44,15 @@ module DatastaxRails#:nodoc:
       
       def to_cql
         conditions = []
-        values = []
         stmt = "SELECT #{@select} FROM #{@klass.column_family} "
         
         if @paginate
-          conditions << "token(key) > token('#{@paginate}')"
+          conditions << "token(#{@klass.primary_key}) > token(?)"
+          @values << @paginate
         end
         
         @conditions.each do |k,v|
-          values << v
+          @values << v
           if v.kind_of?(Array)
             conditions << "\"#{k.to_s}\" IN (?)"
           else
@@ -76,7 +76,7 @@ module DatastaxRails#:nodoc:
           stmt << "ALLOW FILTERING "
         end
         
-        CassandraCQL::Statement.sanitize(stmt, values)
+        stmt
       end
     end
   end

data/lib/datastax_rails/cql/update.rb

@@ -8,11 +8,6 @@ module DatastaxRails
         super
       end
       
-      def using(consistency)
-        @consistency = consistency
-        self
-      end
-      
       def columns(columns)
         @columns.merge!(columns)
         self
@@ -36,7 +31,6 @@ module DatastaxRails
       def to_cql
         column_names = @columns.keys
         
-        
         stmt = "update #{@klass.column_family} "
         
         if(@ttl)
@@ -49,22 +43,19 @@ module DatastaxRails
         
         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]])
+          updates = []
+          @columns.each do |k,v|
+            @values << v
+            updates << "\"#{k}\" = ?"
           end
+          
+          stmt << updates.join(", ")
         end
         
-        stmt << CassandraCQL::Statement.sanitize(" WHERE key IN (?)", [@key])
+        stmt << " WHERE #{@klass.primary_key} IN (?)"
+        @values << @key
         stmt.force_encoding('UTF-8')
       end
-      
-      # def execute
-        # puts to_cql.truncate(50)
-      # end
     end
   end
 end

data/lib/datastax_rails/dynamic_model.rb

@@ -0,0 +1,98 @@
+module DatastaxRails
+  # An extension to Wide Storage Models that let you index any arbitrary
+  # field that you want (given certain naming conventions).
+  #
+  # Try to keep the group_by as sort as possible since it will get stored
+  # with every attribute.  Static attributes are only supported if they
+  # are included on every dynamic model that uses the same column family.
+  #
+  # Dynamic models have the following attributes:
+  # * strings
+  # * texts
+  # * booleans
+  # * dates
+  # * timestamps
+  # * integers
+  # * floats
+  # * uuids
+  #
+  # Each of these is a map that let's you store key/value pairs where the
+  # key is always a String and the value is a type that matches what would
+  # be stored in a static attribute of the same time.  Everything will get
+  # typecasted, so you can safely store strings in it in all the same cases
+  # that you store strings in normal attributes.
+  #
+  # The advantage here is that you don't have to pre-define your schema
+  # ahead of time. The keys of any attributes added to this collection become
+  # fields in your Solr document.
+  #
+  # NOTE: due to the way fields dynamically map between Solr and Cassandra,
+  # the field name in Solr will have a prefix prepended to it. With the
+  # exception of timestamps, it is simply the first letter of the type
+  # followed by an underscore (_). So s_ for strings. Timestamp has a
+  # ts_ prefix to differentiate it from texts.
+  #   
+  #   class Item < DatastaxRails::DynamicModel
+  #     self.group_by = 'item'
+  #     timestamps
+  #   end
+  #
+  #   class CoreMetadata < DatastaxRails::DynamicModel
+  #     self.group_by = 'core'
+  #     timestamps
+  #   end
+  #
+  #   class TeamMetadata < DatastaxRails::DynamicModel
+  #     self.group_by = 'team'
+  #     timestamps
+  #   end
+  #
+  #   item = Item.create(strings: {title: "Title"})
+  #   CoreMetadata.create(id: item.id, strings: {author: 'John'}, dates: {published_on: Date.today})
+  #   TeamMetadata.create(id: item.id, booleans: {reviewed: true})
+  #
+  #   CoreMetadata.where(s_author: 'John') #=> Finds the CoreMetadata record
+  #   Item.fulltext("Title") #=> Finds the Item record
+  #   Item.fulltext("John") #=> Doesn't find a record, but...
+  #   Item.fulltext("{!join from=id to=id}John") #=> Does find the record by doing a Solr join across the entire row
+  #
+  # NOTE that the mapping of key names is happening automatically when you insert something into
+  # the collection so:
+  #
+  #   Item.first.strings #=> {s_title: "Title"}
+  class DynamicModel < WideStorageModel
+    self.abstract_class = true
+    
+    class_attribute :group_by_attribute
+    
+    def self.group_by=(group)
+      self.group_by_attribute = group
+      self.attribute_definitions['group'].default = group
+      default_scope -> {where('group' => group)}
+    end
+    
+    
+    def self.inherited(child)
+      super
+      child.column_family = 'dynamic_model'
+      child.primary_key = 'id'
+      child.cluster_by = 'group'
+      child.uuid :id
+      child.string :group
+      child.map :s_,  :holds => :string
+      child.map :t_,  :holds => :text
+      child.map :b_,  :holds => :boolean
+      child.map :d_,  :holds => :date
+      child.map :ts_, :holds => :timestamp
+      child.map :i_,  :holds => :integer
+      child.map :f_,  :holds => :float
+      child.map :u_,  :holds => :uuid
+      
+      child.map_columns.each do |col|
+        child.instance_eval do
+          alias_attribute col.options[:holds].to_s.pluralize, col.name
+        end
+      end
+    end
+  end
+end

data/lib/datastax_rails/payload_model.rb

@@ -5,7 +5,7 @@ module DatastaxRails
   # other metadata, you will need another model that points at this
   # one.
   #
-  #   class AttachmentPayload < DatastaxRails::Payload
+  #   class AttachmentPayload < DatastaxRails::PayloadModel
   #     self.column_family = 'attachment_payloads'
   #
   #     validate do
@@ -14,14 +14,18 @@ module DatastaxRails
   #       end
   #     end
   #   end
-  class PayloadModel < CassandraOnlyModel
+  class PayloadModel < WideStorageModel
+    include CassandraOnlyModel
     self.abstract_class = true
     
     def self.inherited(child)
       super
-      child.key :natural, :attributes => :digest
+      child.primary_key = 'digest'
+      child.cluster_by = 'chunk'
+      child.create_options = 'COMPACT STORAGE'
       child.string :digest
       child.binary :payload
+      child.integer :chunk
       child.validates :digest, :presence => true
     end
     
@@ -31,24 +35,26 @@ module DatastaxRails
       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'])
+      chunk = 0
+      c.execute.each do |row|
+        io << Base64.decode64(row['payload'])
+        chunk = row['chunk']
         found = true
       end
       raise DatastaxRails::RecordNotFound unless found
       io.rewind
-      self.instantiate(digest, {:digest => digest, :payload => io.read}, [:digest, :payload])
+      self.instantiate(digest, {:digest => digest, :payload => io.read, :chunk => chunk}, [:digest, :payload])
     end
     
-    def self.write(key, attributes, options = {})
+    def self.write(record, 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"]
+      c = self.cql.select("count(*)").conditions(:digest => record.id)
+      count = c.execute.first["count"]
       
       i = 0
-      io = StringIO.new(attributes['payload'])
+      io = StringIO.new(record.attributes['payload'])
       while chunk = io.read(1.megabyte)
-        c = cql.insert.columns(:digest => key, :chunk => i, :payload => Base64.encode64(chunk))
+        c = cql.insert.columns(:digest => record.id, :chunk => i, :payload => Base64.encode64(chunk))
         c.using(options[:consistency]) if options[:consistency]
         c.execute
         i += 1
@@ -56,31 +62,13 @@ module DatastaxRails
       
       if count and count > i
         i.upto(count) do |j|
-          c = cql.delete(key.to_s).key_name('digest').conditions(:chunk => j)
+          c = cql.delete(record.id).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
+      record.id
     end
   end
 end