class Aws::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 Aws::SdbInterface object

class A < Aws::ActiveSdb::Base
end

class B < Aws::ActiveSdb::Base
end

class C < Aws::ActiveSdb::Base
end

Aws::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  #=> #<Aws::SdbInterface:0xb76d6d7c>
puts B.connection  #=> #<Aws::SdbInterface:0xb76d6d7c>
puts C.connection  #=> #<Aws::SdbInterface:0xb76d6ca0>
# File lib/sdb/active_sdb.rb, line 191
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 648
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 < Aws::ActiveSdb::Base
end
Client.create_domain  #=> {:request_id=>"6fc652a0-0000-41d5-91f4-3ed390a3d3b2", :box_usage=>"0.0055590278"}
# File lib/sdb/active_sdb.rb, line 244
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 < Aws::ActiveSdb::Base
end
Client.delete_domain  #=> {:request_id=>"e14d90d3-0000-4898-9995-0de28cdda270", :box_usage=>"0.0055590278"}
# File lib/sdb/active_sdb.rb, line 255
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 < Aws::ActiveSdb::Base
end
puts Client.domain  #=> 'client'

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

# Explicit domain name definition
class Client < Aws::ActiveSdb::Base
  set_domain_name :foreign_clients
end
puts Client.domain  #=> 'foreign_clients'
# File lib/sdb/active_sdb.rb, line 216
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

See select(), original find with QUERY syntax is deprecated so now find and select are synonyms.

# File lib/sdb/active_sdb.rb, line 262
def find(*args)
      options = args.last.is_a?(Hash) ? args.pop : {}
    case args.first
        when nil then
            raise "Invalid parameters passed to find: nil."
        when :all then
            sql_select(options)[:items]
        when :first then
            sql_select(options.merge(:limit => 1))[:items].first
        when :count then
            res = sql_select(options.merge(:count => true))[:count]
            res
        else
            res = select_from_ids(args, options)
            return res[:single] if res[:single]
            return res[:items]
    end
end
find_with_metadata(*args) click to toggle source

Same as find, but will return SimpleDB metadata like :request_id and :box_usage

# File lib/sdb/active_sdb.rb, line 284
def find_with_metadata(*args)
      options = args.last.is_a?(Hash) ? args.pop : {}
    case args.first
        when nil then
            raise "Invalid parameters passed to find: nil."
        when :all   then
            sql_select(options)
        when :first then
            sql_select(options.merge(:limit => 1))
        when :count then
            res = sql_select(options.merge(:count => true))
            res
        else
            select_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 632
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: Aws::ActiveSdb::Base.select_by_… and Aws::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 350
def select(*args)
    find(*args)
end
set_domain_name(domain) click to toggle source

Change the default domain name to user defined.

class Client < Aws::ActiveSdb::Base
  set_domain_name :foreign_clients
end
# File lib/sdb/active_sdb.rb, line 233
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 454
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 705
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 715
def []=(attribute, values)
    attribute = attribute.to_s
    @attributes[attribute] = attribute == 'id' ? values.to_s : values.is_a?(Array) ? values.uniq : [values]

end
apres_save2() click to toggle source
# File lib/sdb/active_sdb.rb, line 861
def apres_save2
    mark_as_old
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 683
def attributes=(attrs)
    old_id = @attributes['id']
    @attributes = uniq_values(attrs)
    if Aws::Utils.blank?(@attributes['id']) && !Aws::Utils.blank?(old_id)
      @attributes['id'] = old_id
    end
    self.attributes
end
connection() click to toggle source
# File lib/sdb/active_sdb.rb, line 692
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 944
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 924
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.empty?
        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 895
def delete_values(attrs)
    raise_on_id_absence
    attrs = uniq_values(attrs)
    attrs.delete('id')
    unless attrs.nil? || attrs.empty?
        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 697
def domain
    self.class.domain
end
id=(id) click to toggle source

Sets an item id.

# File lib/sdb/active_sdb.rb, line 660
def id=(id)
    @attributes['id'] = id.to_s
end
initialize_from_db(attrs={}) click to toggle source

This is to separate initialization from user vs coming from db (ie: find())

# File lib/sdb/active_sdb.rb, line 638
def initialize_from_db(attrs={})
    initialize(attrs)
end
new_record?() click to toggle source

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

# File lib/sdb/active_sdb.rb, line 955
def new_record?
    @new_record
end
pre_save2() click to toggle source
# File lib/sdb/active_sdb.rb, line 856
def pre_save2
    @attributes = uniq_values(@attributes)
    prepare_for_update
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 782
def put
    @attributes = uniq_values(@attributes)
    prepare_for_update
    attrs = @attributes.dup
    attrs.delete('id')
    connection.put_attributes(domain, id, attrs) unless Aws::Utils.blank?(attrs)
    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 798
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 Aws::Utils.blank?(attrs['id'])
    attrs.delete('id')
    # add new values to all attributes from list
    connection.put_attributes(domain, id, attrs) unless Aws::Utils.blank?(attrs)
    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 726
def reload
    raise_on_id_absence
    old_id = id
    attrs = connection.get_attributes(domain, id)[:attributes]
    @attributes = {}
    unless attrs.nil? || attrs.empty?
        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 749
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 Aws::Utils.blank?(values)
            @attributes[attribute] = result[attribute] = values
        else
            @attributes.delete(attribute)
        end
    end
    mark_as_old
    result
end
save(options={}) 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.save
sandy['toys'] = 'patchwork'
sandy.save
sandy['toys'] = 'kids'
sandy.save
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"]}

Options:

- :except => Array of attributes to NOT save

compare to put method

# File lib/sdb/active_sdb.rb, line 835
def save(options={})
    pre_save2
    atts_to_save = @attributes.dup
    #puts 'atts_to_save=' + atts_to_save.inspect
    #options = params.first.is_a?(Hash) ? params.pop : {}
    if options[:except]
        options[:except].each do |e|
            atts_to_save.delete(e).inspect
        end
    end
    if options[:dirty] # Only used in simple_record right now
        # only save if the attribute is dirty
        dirty_atts = options[:dirty_atts]
        atts_to_save.delete_if { |key, value| !dirty_atts.has_key?(key) }
    end
    #puts 'atts_to_save2=' + atts_to_save.inspect
    connection.put_attributes(domain, id, atts_to_save, :replace)
    apres_save2
    @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 871
def save_attributes(attrs)
    prepare_for_update
    attrs = uniq_values(attrs)
    # if 'id' is present in attrs hash then replace internal 'id' attribute
    unless Aws::Utils.blank?(attrs['id'])
        @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 950
def to_s
    @id
end

Private Instance Methods

prepare_for_update() click to toggle source
# File lib/sdb/active_sdb.rb, line 969
def prepare_for_update
    @attributes['id'] = self.class.generate_id if Aws::Utils.blank?(@attributes['id'])
end
raise_on_id_absence() click to toggle source
# File lib/sdb/active_sdb.rb, line 965
def raise_on_id_absence
    raise ActiveSdbError.new('Unknown record id') unless id
end