class AWS::DynamoDB::TableCollection

Represents the tables in your account. Each table is represented by an instance of the {Table} class.

## Schemas

Before you can operate on items in a table you must specify the schema. You do this by calling hash_key= (and optionally range_key=) on a table.

table = dynamo_db.tables['mytable']
table.hash_key = [:id, :string]

@example Creating a Table

table = dynamo_db.tables.create('mytable', 10, 10, :hash_key => { :id => :string })

@example Enumerating Tables

dynamo_db.tables.each {|table| puts table.name }

@example Getting a Table by Name

table = dynamo_db.tables['mytable']

Public Instance Methods

[](name) click to toggle source

References a table by name.

dynamo_db.tables["MyTable"]

@param [String] name @return [Table] Returns the table with the given name.

# File lib/aws/dynamo_db/table_collection.rb, line 110
def [] name
  Table.new(name, :config => config)
end
create(name, read_capacity_units, write_capacity_units, options = {}) click to toggle source

Creates a new table.

table = dynamo_db.tables.create('mytable', 25, 25,
  :hash_key => { :id => :string })

@note Creating a table is an eventualy consistent operation. You

can not interact with the table until its status
({Table#status}) is `:active`.

@param [String] name The name of the table.

@param [Integer] read_capacity_units Sets the minimum

number of reads supported before read requests are throttled.

@param [Integer] write_capacity_units Sets the minimum

number of writes supported before writes requests are throttled.

@param [Hash] options

@option options [Hash] :hash_key A hash key is a combination

of an attribute name and type.  If you want to have the
hash key on the string attribute username you would call #create
with:

    :hash_key => { :username => :string }

The other supported types are %x:number` and %x:binary`.  If you
wanted to set the hash key on a numeric (integer) attribute then you
could call #create with:

    :hash_key => { :id => :number }

All tables require a hash key.  If %x:hash_key` is not provided
then a default hash key will be provided.  The default hash
key is:

    :hash_key => { :id => :string }

@option options [String] :range_key You can setup a table to use

composite keys by providing a `:range_key`.  Range keys are
configured the same way as hash keys.  They are useful
for ordering items that share the same hash key.

@return [Table] The newly created table.

# File lib/aws/dynamo_db/table_collection.rb, line 87
def create name, read_capacity_units, write_capacity_units, options = {}

  client_opts = {
    :table_name => name.to_s,
    :key_schema => key_schema(options),
    :provisioned_throughput => {
      :read_capacity_units => read_capacity_units,
      :write_capacity_units => write_capacity_units,
    },
  }

  response = client.create_table(client_opts)

  Table.new(name, :config => config)

end

Protected Instance Methods

_each_item(next_token, limit, options = {}) { |table(name, :config => config)| ... } click to toggle source

@api private

# File lib/aws/dynamo_db/table_collection.rb, line 116
def _each_item next_token, limit, options = {}, &block

  options[:limit] = limit if limit
  options[:exclusive_start_table_name] = next_token if next_token

  response = client.list_tables(options)
  response.data['TableNames'].each do |name|
    yield Table.new(name, :config => config)
  end

  response.data['LastEvaluatedTableName']

end

Private Instance Methods

key_schema(options) click to toggle source
# File lib/aws/dynamo_db/table_collection.rb, line 131
def key_schema options

  hash_key, range_key = options.values_at(:hash_key, :range_key)

  # default options for :hash_key
  hash_key ||= { :id => :string }

  schema = {}
  schema[:hash_key_element] = schema_element(hash_key, "hash")
  if range_key
    schema[:range_key_element] = schema_element(range_key, "range")
  end
  schema

end
schema_element(desc, key_type) click to toggle source
# File lib/aws/dynamo_db/table_collection.rb, line 148
def schema_element desc, key_type

  (name, type) = desc.to_a.first

  unless [:string, :number, :binary].include?(type)
    msg = "invalid #{key_type} key type, expected :string, :number or :binary"
    raise ArgumentError, msg
  end

  { :attribute_name => name.to_s,
    :attribute_type => type.to_s[0,1].upcase }

end