Returns an enumerable scope object represents all records.

  Book.all.each do |book|
    # ...
  end

This method is equivalent to +find(:all)+, and therefore you can also pass aditional options.

  Book.all(:where => { :author' => 'me' }).each do |my_book|
    # ...
  end

@return [Scope] Returns an enumerable scope object.

Adds a boolean attribute to this class.

@example

  class Book < AWS::Record::HashModel
    boolean_attr :read
  end

  b = Book.new
  b.read? # => false
  b.read = true
  b.read? # => true

  listing = Listing.new(:score => '123.456'
  listing.score # => 123.456

@param [Symbol] name The name of the attribute.

Counts records Amazon DynamoDB.

  class Product < AWS::Record::HashModel
  end

  # returns the count of records in the 'Product' table
  Product.count

You can specify the table via shard

  # returns the count of records in the 'products-1' table
  Product.shard('products-1').count

You can also specify the shard as an option to count.

  Product.count(:shard => 'table-name')

Chaining count with limit has no effect on the count.

  Product.limit(10).count # same as Product.count, limit ignored

@param [Hash] options

@option [String] :shard Which shard to count records in.

@return [Integer] The count of records in the table.

Creates the DynamoDB table that is configured for this class.

  class Product < AWS::Record::HashModel
  end

  # create the table 'Product' with 10 read/write capacity units
  Product.create_table 10, 10

If you shard you data across multiple tables, you can specify the shard name:

  # create two tables, with the given names
  Product.create_table 500, 10, :shard_name => 'products-1'
  Product.create_table 500, 10, :shard_name => 'products-2'

If you share a single AWS account with multiple applications, you can provide a table prefix to group tables and to avoid name collisions:

  AWS::Record.table_prefix = 'myapp-'

  # creates the table 'myapp-Product'
  Product.create_table 250, 50

  # creates the table 'myapp-products-1'
  Product.create_table 250, 50, :shard_name => 'products-1'

@param [Integer] read_capacity_units

  See {DynamoDB::TableCollection#create} for more information.

@param [Integer] write_capacity_units

  See {DynamoDB::TableCollection#create} for more information.

@param [Hash] options

@option options [String] :shard_name Defaults to the class name. The

  shard name will be prefixed with {AWS::Record.table_prefix},
  and that becomes the table name.

@return [DynamoDB::Table]

Adds a date attribute to this class.

@example A standard date attribute

  class Person < AWS::Record::HashModel
    date_attr :birthdate
  end

  baby = Person.new
  baby.birthdate = Time.now
  baby.birthdate #=> <Date: ....>

@param [Symbol] name The name of the attribute.

@param [Hash] options

@option options [Boolean] :set (false) When true this attribute

  can have multiple dates.

Adds a datetime attribute to this class.

@example A standard datetime attribute

  class Recipe < AWS::Record::HashModel
    datetime_attr :invented
  end

  recipe = Recipe.new(:invented => Time.now)
  recipe.invented #=> <DateTime ...>

If you add a datetime_attr for +:created_at+ and/or +:updated_at+ those will be automanaged.

@param [Symbol] name The name of the attribute.

@param [Hash] options

@option options [Boolean] :set (false) When true this attribute

  can have multiple date times.

@return [DynamoDB::Table] @private

Yields once for each record.

Finds records in Amazon DynamoDB and returns them as objects of the current class.

Finding +:all+ returns an enumerable scope object

 People.find(:all, :limit => 10).each do |person|
   puts person.name
 end

Finding +:first+ returns a single record (or nil)

 boss = People.find(:first)

Find accepts a hash of find modifiers (+:shard+ and +:limit+). You can also choose to omit these modifiers and chain them on the scope object returned. In the following example only one request is made to SimpleDB (when each is called)

  people = People.find(:all, :limit => 10)

  people = people.limit(10).find(:all)

@overload find(id)

  @param id The record to find, raises an exception if the record is
    not found.

@overload find(mode, options = {})

  @param [:all,:first] mode (:all) When finding +:all+ matching records
    and array is returned of records.  When finding +:first+ then
    +nil+ or a single record will be returned.
  @param [Hash] options
  @option options [Integer] :shard The shard name of the Amazon
    DynamoDB table to search.
  @option options [Integer] :limit The max number of records to fetch.

@param [String] id The id of the record to load. @param [Hash] options @option options [String] :shard Specifies what shard (i.e. table)

  should be searched.

@raise [RecordNotFound] Raises a record not found exception if there

  was no data found for the given id.

@return [Record::HashModel] Returns the record with the given id.

@return [Object,nil] Returns the first record found. If there were

  no records found, nil is returned.

Adds a float attribute to this class.

  class Listing < AWS::Record::HashModel
    float_attr :score
  end

  listing = Listing.new(:score => '123.456')
  listing.score # => 123.456

@param [Symbol] name The name of the attribute. @param [Hash] options @option options [Boolean] :set (false) When true this attribute

  can have multiple values.

Adds an integer attribute to this class.

  class Recipe < AWS::Record::HashModel
    integer_attr :servings
  end

  recipe = Recipe.new(:servings => '10')
  recipe.servings #=> 10

@param [Symbol] name The name of the attribute. @param [Hash] options @option options [Boolean] :set (false) When true this attribute

  can have multiple values.

The maximum number of records to return. By default, all records matching the where conditions will be returned from a find.

  People.limit(10).each {|person| ... }

Limit can be chained with other scope modifiers:

  People.where(:age => 40).limit(10).each {|person| ... }

Returns a chainable scope object that restricts further scopes to a particular table.

 Book.shard('books-2').each do |book|
   # ...
 end

@param [String] shard_name @return [Scope] Returns a scope for restricting the table searched.

Adds a string attribute to this class.

@example A standard string attribute

  class Recipe < AWS::Record::HashModel
    string_attr :name
  end

  recipe = Recipe.new(:name => "Buttermilk Pancakes")
  recipe.name #=> 'Buttermilk Pancakes'

@example A string attribute with +:set+ set to true

  class Recipe < AWS::Record::HashModel
    string_attr :tags, :set => true
  end

  recipe = Recipe.new(:tags => %w(popular dessert))
  recipe.tags #=> #<Set: {"popular", "desert"}>

@param [Symbol] name The name of the attribute. @param [Hash] options @option options [Boolean] :set (false) When true this attribute

  can have multiple values.

A convenience method for adding the standard two datetime attributes +:created_at+ and +:updated_at+.

@example

  class Recipe < AWS::Record::HashModel
    timestamps
  end

  recipe = Recipe.new
  recipe.save
  recipe.created_at #=> <DateTime ...>
  recipe.updated_at #=> <DateTime ...>