Parent

RightAws::ActiveSdb::Base

Attributes

next_token[RW]

next_token value returned by last find: is useful to continue finding

attributes[RW]

instance attributes

id[RW]

item name

Public Class Methods

connection() click to toggle source

Returns a RightAws::SdbInterface object

class A < RightAws::ActiveSdb::Base
end

class B < RightAws::ActiveSdb::Base
end

class C < RightAws::ActiveSdb::Base
end

RightAws::ActiveSdb.establish_connection 'key_id_1', 'secret_key_1'

C.establish_connection 'key_id_2', 'secret_key_2'

# A and B uses the default connection, C - uses its own 
puts A.connection  #=> #<RightAws::SdbInterface:0xb76d6d7c>
puts B.connection  #=> #<RightAws::SdbInterface:0xb76d6d7c>
puts C.connection  #=> #<RightAws::SdbInterface:0xb76d6ca0>
# File lib/sdb/active_sdb.rb, line 178
def connection
  @connection || ActiveSdb::connection
end
create(attributes={}) click to toggle source

Create and save new Item instance. Attributes is a hash: { attribute1 => values1, ..., attributeN => valuesN }.

item = Client.create('name' => 'Cat', 'toys' => ['Jons socks', 'mice', 'clew']) 
puts item.inspect   #=> #<Client:0xb77a0a78 @new_record=false, @attributes={"name"=>["Cat"], "id"=>"2937601a-e45d-11dc-a75f-001bfc466dd7", "toys"=>["Jons socks", "mice", "clew"]}>
# File lib/sdb/active_sdb.rb, line 622
def self.create(attributes={})
  item = self.new(attributes)
  item.save
  item
end
create_domain() click to toggle source

Create domain at SDB. Raises no errors if the domain already exists.

class Client < RightAws::ActiveSdb::Base
end
Client.create_domain  #=> {:request_id=>"6fc652a0-0000-41d5-91f4-3ed390a3d3b2", :box_usage=>"0.0055590278"}
# File lib/sdb/active_sdb.rb, line 231
def create_domain
  connection.create_domain(domain)
end
delete_domain() click to toggle source

Remove domain from SDB. Raises no errors if the domain does not exist.

class Client < RightAws::ActiveSdb::Base
end
Client.delete_domain  #=> {:request_id=>"e14d90d3-0000-4898-9995-0de28cdda270", :box_usage=>"0.0055590278"}
# File lib/sdb/active_sdb.rb, line 242
def delete_domain
  connection.delete_domain(domain)
end
domain() click to toggle source

Current domain name.

# if 'ActiveSupport' is not loaded then class name converted to downcase
class Client < RightAws::ActiveSdb::Base
end
puts Client.domain  #=> 'client'

# if 'ActiveSupport' is loaded then class name being tableized
require 'activesupport'
class Client < RightAws::ActiveSdb::Base
end
puts Client.domain  #=> 'clients'

# Explicit domain name definition
class Client < RightAws::ActiveSdb::Base
  set_domain_name :foreign_clients
end
puts Client.domain  #=> 'foreign_clients'
# File lib/sdb/active_sdb.rb, line 203
def domain
  unless @domain
    if defined? ActiveSupport::CoreExtensions::String::Inflections
      @domain = name.tableize
    else
      @domain = name.downcase
    end
  end
  @domain
end
find(*args) click to toggle source

Perform a find request.

Single record:

Client.find(:first)
Client.find(:first, :conditions=> [ "['name'=?] intersection ['wife'=?]", "Jon", "Sandy"])

Bunch of records:

Client.find(:all)
Client.find(:all, :limit => 10)
Client.find(:all, :conditions=> [ "['name'=?] intersection ['girlfriend'=?]", "Jon", "Judy"])
Client.find(:all, :conditions=> [ "['name'=?]", "Sandy"], :limit => 3)

Records by ids:

Client.find('1')
Client.find('1234987b4583475347523948')
Client.find('1','2','3','4', :conditions=> [ "['toys'=?]", "beer"])

Find helpers: RightAws::ActiveSdb::Base.find_by_... and RightAws::ActiveSdb::Base.find_all_by_...

Client.find_by_name('Matias Rust')
Client.find_by_name_and_city('Putin','Moscow')
Client.find_by_name_and_city_and_post('Medvedev','Moscow','president')

Client.find_all_by_author('G.Bush jr')
Client.find_all_by_age_and_gender_and_ethnicity('34','male','russian')
Client.find_all_by_gender_and_country('male', 'Russia', :auto_load => true, :order => 'name desc')

Returned records have to be reloaded to access their attributes.

item = Client.find_by_name('Cat')  #=> #<Client:0xb77d0d40 @attributes={"id"=>"2937601a-e45d-11dc-a75f-001bfc466dd7"}, @new_record=false>
item.reload                        #=> #<Client:0xb77d0d40 @attributes={"id"=>"2937601a-e45d-11dc-a75f-001bfc466dd7", "name"=>["Cat"], "toys"=>["Jons socks", "clew", "mice"]}, @new_record=false>

Continue listing:

# initial listing
Client.find(:all, :limit => 10)
# continue listing
begin
  Client.find(:all, :limit => 10, :next_token => Client.next_token)
end while Client.next_token

Sort oder:
  Client.find(:all, :order => 'gender')
  Client.find(:all, :order => 'name desc')

Attributes auto load (be carefull - this may take lot of time for a huge bunch of records):
  Client.find(:first)                      #=> #<Client:0xb77d0d40 @attributes={"id"=>"2937601a-e45d-11dc-a75f-001bfc466dd7"}, @new_record=false>
  Client.find(:first, :auto_load => true)  #=> #<Client:0xb77d0d40 @attributes={"id"=>"2937601a-e45d-11dc-a75f-001bfc466dd7", "name"=>["Cat"], "toys"=>["Jons socks", "clew", "mice"]}, @new_record=false>

see docs.amazonwebservices.com/AmazonSimpleDB/2007-11-07/DeveloperGuide/index.html?UsingQuery.html

# File lib/sdb/active_sdb.rb, line 299
def find(*args)
  options = args.last.is_a?(Hash) ? args.pop : {}
  case args.first
    when :all   then find_every    options
    when :first then find_initial  options
    else             find_from_ids args, options
  end
end
new(attrs={}) click to toggle source

Create new Item instance. attrs is a hash: { attribute1 => values1, ..., attributeN => valuesN }.

item = Client.new('name' => 'Jon', 'toys' => ['girls', 'beer', 'pub'])
puts item.inspect   #=> #<Client:0xb77a2698 @new_record=true, @attributes={"name"=>["Jon"], "toys"=>["girls", "beer", "pub"]}>
item.save           #=> {"name"=>["Jon"], "id"=>"c03edb7e-e45c-11dc-bede-001bfc466dd7", "toys"=>["girls", "beer", "pub"]}
puts item.inspect   #=> #<Client:0xb77a2698 @new_record=false, @attributes={"name"=>["Jon"], "id"=>"c03edb7e-e45c-11dc-bede-001bfc466dd7", "toys"=>["girls", "beer", "pub"]}>
# File lib/sdb/active_sdb.rb, line 611
def initialize(attrs={})
  @attributes = uniq_values(attrs)
  @new_record = true
end
select(*args) click to toggle source

Perform a SQL-like select request.

Single record:

Client.select(:first)
Client.select(:first, :conditions=> [ "name=? AND wife=?", "Jon", "Sandy"])
Client.select(:first, :conditions=> { :name=>"Jon", :wife=>"Sandy" }, :select => :girfriends)

Bunch of records:

Client.select(:all)
Client.select(:all, :limit => 10)
Client.select(:all, :conditions=> [ "name=? AND 'girlfriend'=?", "Jon", "Judy"])
Client.select(:all, :conditions=> { :name=>"Sandy" }, :limit => 3)

Records by ids:

Client.select('1')
Client.select('1234987b4583475347523948')
Client.select('1','2','3','4', :conditions=> ["toys=?", "beer"])

Find helpers: RightAws::ActiveSdb::Base.select_by_... and RightAws::ActiveSdb::Base.select_all_by_...

Client.select_by_name('Matias Rust')
Client.select_by_name_and_city('Putin','Moscow')
Client.select_by_name_and_city_and_post('Medvedev','Moscow','president')

Client.select_all_by_author('G.Bush jr')
Client.select_all_by_age_and_gender_and_ethnicity('34','male','russian')
Client.select_all_by_gender_and_country('male', 'Russia', :order => 'name')

Continue listing:

# initial listing
Client.select(:all, :limit => 10)
# continue listing
begin
  Client.select(:all, :limit => 10, :next_token => Client.next_token)
end while Client.next_token

Sort oder:
If :order=>'attribute' option is specified then result response (ordered by 'attribute') will contain only items where attribute is defined (is not null).

  Client.select(:all)                         # returns all records
  Client.select(:all, :order => 'gender')     # returns all records ordered by gender where gender attribute exists
  Client.select(:all, :order => 'name desc')  # returns all records ordered by name in desc order where name attribute exists

see docs.amazonwebservices.com/AmazonSimpleDB/2007-11-07/DeveloperGuide/index.html?UsingSelect.html

# File lib/sdb/active_sdb.rb, line 357
def select(*args)
  options = args.last.is_a?(Hash) ? args.pop : {}
  case args.first
    when :all   then sql_select(options)
    when :first then sql_select(options.merge(:limit => 1)).first
    else             select_from_ids args, options
  end
end
set_domain_name(domain) click to toggle source

Change the default domain name to user defined.

class Client < RightAws::ActiveSdb::Base
  set_domain_name :foreign_clients
end
# File lib/sdb/active_sdb.rb, line 220
def set_domain_name(domain)
  @domain = domain.to_s
end

Protected Class Methods

sort_options(sort_string) click to toggle source

Returns an array of [attribute_name, 'asc'|'desc']

# File lib/sdb/active_sdb.rb, line 449
def sort_options(sort_string)
  sort_string[/['"]?(\w+)['"]? *(asc|desc)?/]
  [$1, ($2 || 'asc')]
end

Public Instance Methods

[](attribute) click to toggle source

Returns the values of the attribute identified by attribute.

puts item['Cat'].inspect  #=> ["Jons socks", "clew", "mice"]
# File lib/sdb/active_sdb.rb, line 677
def [](attribute)
  @attributes[attribute.to_s]
end
[]=(attribute, values) click to toggle source

Updates the attribute identified by attribute with the specified values.

puts item['Cat'].inspect  #=> ["Jons socks", "clew", "mice"]
item['Cat'] = ["Whiskas", "chicken"]
puts item['Cat'].inspect  #=> ["Whiskas", "chicken"]
# File lib/sdb/active_sdb.rb, line 687
def []=(attribute, values)
  attribute = attribute.to_s
  @attributes[attribute] = attribute == 'id' ? values.to_s : values.to_a.uniq
end
attributes=(attrs) click to toggle source

Allows one to set all the attributes at once by passing in a hash with keys matching the attribute names. if 'id' attribute is not set in new attributes has then it being derived from old attributes.

puts item.attributes.inspect   #=> {"name"=>["Cat"], "id"=>"2937601a-e45d-11dc-a75f-001bfc466dd7", "toys"=>["Jons socks", "clew", "mice"]}
# set new attributes ('id' is missed)
item.attributes = { 'name'=>'Dog', 'toys'=>['bones','cats'] }
puts item.attributes.inspect   #=> {"name"=>["Dog"], "id"=>"2937601a-e45d-11dc-a75f-001bfc466dd7", "toys"=>["bones", "cats"]}
# set new attributes ('id' is set)
item.attributes = { 'id' => 'blah-blah', 'name'=>'Birds', 'toys'=>['seeds','dogs tail'] }
puts item.attributes.inspect   #=> {"name"=>["Birds"], "id"=>"blah-blah", "toys"=>["seeds", "dogs tail"]}
# File lib/sdb/active_sdb.rb, line 657
def attributes=(attrs)
  old_id = @attributes['id']
  @attributes = uniq_values(attrs)
  @attributes['id'] = old_id if @attributes['id'].blank? && !old_id.blank?
  self.attributes
end
connection() click to toggle source
# File lib/sdb/active_sdb.rb, line 664
def connection 
  self.class.connection
end
delete() click to toggle source

Delete the Item entirely from SDB.

sandy = Client.find_by_name 'Sandy' 
sandy.reload
sandy.inspect       #=> #<Client:0xb7761d28 @new_record=false, @attributes={"name"=>["Sandy"], "id"=>"b2832ce2-e461-11dc-b13c-001bfc466dd7", "toys"=>["boys", "kids", "patchwork"}>
puts sandy.delete
sandy.reload      
puts sandy.inspect  #=> #<Client:0xb7761d28 @attributes={}, @new_record=false>
# File lib/sdb/active_sdb.rb, line 890
def delete
  raise_on_id_absence
  connection.delete_attributes(domain, id)
end
delete_attributes(*attrs_list) click to toggle source

Removes specified attributes from the item. attrs_list is an array or comma separated list of attributes names. Returns the list of deleted attributes.

sandy = Client.find_by_name 'Sandy' 
sandy.reload
puts sandy.inspect                   #=> #<Client:0xb7761d28 @new_record=false, @attributes={"name"=>["Sandy"], "id"=>"b2832ce2-e461-11dc-b13c-001bfc466dd7", "toys"=>["boys", "kids", "patchwork"}>
puts sandy.delete_attributes('toys') #=> ['toys']
puts sandy.inspect                   #=> #<Client:0xb7761d28 @new_record=false, @attributes={"name"=>["Sandy"], "id"=>"b2832ce2-e461-11dc-b13c-001bfc466dd7"}>
# File lib/sdb/active_sdb.rb, line 870
def delete_attributes(*attrs_list)
  raise_on_id_absence
  attrs_list = attrs_list.flatten.map{ |attribute| attribute.to_s }
  attrs_list.delete('id')
  unless attrs_list.blank?
    connection.delete_attributes(domain, id, attrs_list)
    attrs_list.each { |attribute| @attributes.delete(attribute) }
  end
  attrs_list
end
delete_values(attrs) click to toggle source

Remove specified values from corresponding attributes. attrs is a hash: { attribute1 => values1, ..., attributeN => valuesN }.

sandy = Client.find_by_name 'Sandy' 
sandy.reload
puts sandy.inspect                                #=> #<Client:0xb77b48fc @new_record=false, @attributes={"name"=>["Sandy"], "id"=>"b2832ce2-e461-11dc-b13c-001bfc466dd7", "toys"=>["boys", "kids", "patchwork"]}>
puts sandy.delete_values('toys' => 'patchwork')   #=> { 'toys' => ['patchwork'] }
puts sandy.inspect                                #=> #<Client:0xb77b48fc @new_record=false, @attributes={"name"=>["Sandy"], "id"=>"b2832ce2-e461-11dc-b13c-001bfc466dd7", "toys"=>["boys", "kids"]}>
# File lib/sdb/active_sdb.rb, line 841
def delete_values(attrs)
  raise_on_id_absence
  attrs = uniq_values(attrs)
  attrs.delete('id')
  unless attrs.blank?
    connection.delete_attributes(domain, id, attrs)
    attrs.each do |attribute, values|
      # remove the values from the attribute
      if @attributes[attribute]
        @attributes[attribute] -= values
      else
        # if the attribute is unknown remove it from a resulting list of fixed attributes
        attrs.delete(attribute)
      end
    end
  end
  attrs
end
domain() click to toggle source

Item domain name.

# File lib/sdb/active_sdb.rb, line 669
def domain
  self.class.domain
end
id=(id) click to toggle source

Sets an item id.

# File lib/sdb/active_sdb.rb, line 634
def id=(id)
  @attributes['id'] = id.to_s
end
new_record?() click to toggle source

Returns true if this object hasn‘t been saved yet.

# File lib/sdb/active_sdb.rb, line 901
def new_record?
  @new_record
end
put() click to toggle source

Stores in-memory attributes to SDB. Adds the attributes values to already stored at SDB. Returns a hash of stored attributes.

sandy = Client.new(:name => 'Sandy') #=> #<Client:0xb775a7a8 @attributes={"name"=>["Sandy"]}, @new_record=true>
sandy['toys'] = 'boys'
sandy.put
sandy['toys'] = 'patchwork'
sandy.put
sandy['toys'] = 'kids'
sandy.put
puts sandy.attributes.inspect        #=> {"name"=>["Sandy"], "id"=>"b2832ce2-e461-11dc-b13c-001bfc466dd7", "toys"=>["kids"]}
sandy.reload                         #=> {"name"=>["Sandy"], "id"=>"b2832ce2-e461-11dc-b13c-001bfc466dd7", "toys"=>["boys", "kids", "patchwork"]}

compare to save method

# File lib/sdb/active_sdb.rb, line 753
def put
  @attributes = uniq_values(@attributes)
  prepare_for_update
  attrs = @attributes.dup
  attrs.delete('id')
  connection.put_attributes(domain, id, attrs) unless attrs.blank?
  connection.put_attributes(domain, id, { 'id' => id }, :replace)
  mark_as_old
  @attributes
end
put_attributes(attrs) click to toggle source

Stores specified attributes. attrs is a hash: { attribute1 => values1, ..., attributeN => valuesN }. Returns a hash of saved attributes.

see to put method

# File lib/sdb/active_sdb.rb, line 769
def put_attributes(attrs)
  attrs = uniq_values(attrs)
  prepare_for_update
  # if 'id' is present in attrs hash:
  # replace internal 'id' attribute and remove it from the attributes to be sent
  @attributes['id'] = attrs['id'] unless attrs['id'].blank?
  attrs.delete('id')
  # add new values to all attributes from list
  connection.put_attributes(domain, id, attrs) unless attrs.blank?
  connection.put_attributes(domain, id, { 'id' => id }, :replace)
  attrs.each do |attribute, values|
    @attributes[attribute] ||= []
    @attributes[attribute] += values
    @attributes[attribute].uniq!
  end
  mark_as_old
  attributes
end
reload() click to toggle source

Reload attributes from SDB. Replaces in-memory attributes.

item = Client.find_by_name('Cat')  #=> #<Client:0xb77d0d40 @attributes={"id"=>"2937601a-e45d-11dc-a75f-001bfc466dd7"}, @new_record=false>
item.reload                        #=> #<Client:0xb77d0d40 @attributes={"id"=>"2937601a-e45d-11dc-a75f-001bfc466dd7", "name"=>["Cat"], "toys"=>["Jons socks", "clew", "mice"]}, @new_record=false>
# File lib/sdb/active_sdb.rb, line 697
def reload
  raise_on_id_absence
  old_id = id
  attrs = connection.get_attributes(domain, id)[:attributes]
  @attributes = {}
  unless attrs.blank?
    attrs.each { |attribute, values| @attributes[attribute] = values }
    @attributes['id'] = old_id
  end
  mark_as_old
  @attributes
end
reload_attributes(*attrs_list) click to toggle source

Reload a set of attributes from SDB. Adds the loaded list to in-memory data. attrs_list is an array or comma separated list of attributes names. Returns a hash of loaded attributes.

This is not the best method to get a bunch of attributes because a web service call is being performed for every attribute.

item = Client.find_by_name('Cat')
item.reload_attributes('toys', 'name')   #=> {"name"=>["Cat"], "toys"=>["Jons socks", "clew", "mice"]}
# File lib/sdb/active_sdb.rb, line 720
def reload_attributes(*attrs_list)
  raise_on_id_absence
  attrs_list = attrs_list.flatten.map{ |attribute| attribute.to_s }
  attrs_list.delete('id')
  result = {}
  attrs_list.flatten.uniq.each do |attribute|
    attribute = attribute.to_s
    values = connection.get_attributes(domain, id, attribute)[:attributes][attribute]
    unless values.blank?
      @attributes[attribute] = result[attribute] = values
    else
      @attributes.delete(attribute)
    end
  end
  mark_as_old
  result
end
save() click to toggle source

Store in-memory attributes to SDB. Replaces the attributes values already stored at SDB by in-memory data. Returns a hash of stored attributes.

sandy = Client.new(:name => 'Sandy')  #=> #<Client:0xb775a7a8 @attributes={"name"=>["Sandy"]}, @new_record=true>
sandy['toys'] = 'boys'
sandy.put
sandy['toys'] = 'patchwork'
sandy.put
sandy['toys'] = 'kids'
sandy.put
puts sandy.attributes.inspect         #=> {"name"=>["Sandy"], "id"=>"b2832ce2-e461-11dc-b13c-001bfc466dd7", "toys"=>["kids"]}
sandy.reload                          #=> {"name"=>["Sandy"], "id"=>"b2832ce2-e461-11dc-b13c-001bfc466dd7", "toys"=>["kids"]}

compare to put method

# File lib/sdb/active_sdb.rb, line 803
def save
  @attributes = uniq_values(@attributes)
  prepare_for_update
  connection.put_attributes(domain, id, @attributes, :replace)
  mark_as_old
  @attributes
end
save_attributes(attrs) click to toggle source

Replaces the attributes at SDB by the given values. Attrs is a hash: { attribute1 => values1, ..., attributeN => valuesN }. The other in-memory attributes are not being saved. Returns a hash of stored attributes.

see save method

# File lib/sdb/active_sdb.rb, line 817
def save_attributes(attrs)
  prepare_for_update
  attrs = uniq_values(attrs)
  # if 'id' is present in attrs hash then replace internal 'id' attribute
  unless attrs['id'].blank?
    @attributes['id'] = attrs['id']
  else
    attrs['id'] = id
  end
  connection.put_attributes(domain, id, attrs, :replace) unless attrs.blank?
  attrs.each { |attribute, values| attrs[attribute] = values }
  mark_as_old
  attrs
end
to_s() click to toggle source

Item ID

# File lib/sdb/active_sdb.rb, line 896
def to_s
  @id
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.