module DatastaxRails::Persistence::ClassMethods

Public Instance Methods

create(attributes = {}, options = {}, &block) click to toggle source
# File lib/datastax_rails/persistence.rb, line 57
def create(attributes = {}, options = {}, &block)
  new(attributes, &block).tap do |object|
    object.save(options)
  end
end
delete_all()
Alias for: truncate
encode_attributes(record, cql, attributes = {}) click to toggle source

Encodes the attributes in preparation for storing in cassandra. Calls the coders on the various type classes to do the heavy lifting.

@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

# File lib/datastax_rails/persistence.rb, line 136
def encode_attributes(record, cql, attributes = {})
  encoded = {}
  Types::DirtyCollection.ignore_modifications do
    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
end
instantiate(_key, attributes, _selected_attributes = []) click to toggle source

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

# File lib/datastax_rails/persistence.rb, line 126
def instantiate(_key, attributes, _selected_attributes = [])
  allocate.init_with('attributes' => attributes)
end
remove(*keys) click to toggle source

Removes one or more records with corresponding keys. Last parameter can be a hash specifying the consistency level. The keys should be in the form returned by #id_for_update

Model.remove({id: '12345'},{id: '67890'}, :consistency => 'LOCAL_QUORUM)

@overload remove(*keys, options)

Removes one or more keys with the given options
@param [String] keys one or more keys to delete
@param [Hash] options generally the consistency level to set

@overload remove(*keys)

Removes one or more keys with the default options
@param [String] keys one or more keys to delete

TODO: Submit multiple deletes as a batch

# File lib/datastax_rails/persistence.rb, line 27
def remove(*keys)
  options = keys.last.is_a?(Hash) ? keys.pop : {}
  # 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_for_cql3(v) }

    ActiveSupport::Notifications.instrument('remove.datastax_rails', column_family: column_family, key: key) do
      c = cql.delete(typecast_key)
      if options[:consistency]
        level = options[:consistency]
        if valid_consistency?(level)
          c.using(level)
        else
          fail ArgumentError, "'#{level}' is not a valid Cassandra consistency level"
        end
      end
      c.execute
    end
  end
end
truncate() click to toggle source

Truncates the column_family associated with this class

# File lib/datastax_rails/persistence.rb, line 50
def truncate
  ActiveSupport::Notifications.instrument('truncate.datastax_rails', column_family: column_family) do
    cql.truncate.execute
  end
end
Also aliased as: delete_all
write(record, options = {}) click to toggle source

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) @option options [Symbol] :ttl the time-to-live for inserted/updated values to live (CQL only) @option options [Symbol] :timestamp the timestamp to write on the column(s) in microseconds

# File lib/datastax_rails/persistence.rb, line 71
def write(record, options = {})
  level = (options[:consistency] || default_consistency)
  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('insert.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), options)
      else
        write_with_cql(record.id_for_update, encode_attributes(record, true), options)
      end
    end
  end
end
write_attribute(record, attributes, options = {}) click to toggle source

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

# File lib/datastax_rails/persistence.rb, line 98
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
end

Private Instance Methods

write_with_cql(id, encoded, options) click to toggle source
# File lib/datastax_rails/persistence.rb, line 154
def write_with_cql(id, encoded, options)
  if options[:new_record]
    c = cql.insert.columns(encoded).using(options[:consistency])
    c.ttl(options[:ttl]) if options[:ttl]
    c.timestamp(options[:timestamp]) if options[:timestamp]
    c.execute
  else
    c = cql.update(id).columns(encoded).using(options[:consistency])
    c.ttl(options[:ttl]) if options[:ttl]
    c.timestamp(options[:timestamp]) if options[:timestamp]
    c.execute
  end
end
write_with_solr(_id, encoded, options) click to toggle source
# File lib/datastax_rails/persistence.rb, line 168
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