class AWS::DynamoDB::Table

@return [String] The name of this table.

@private

# File lib/aws/dynamo_db/table.rb, line 94
def initialize name, options = {}
  @name = name
  super
end

Raises an exception unless the table schema is loaded.

@return [nil]

# File lib/aws/dynamo_db/table.rb, line 214
def assert_schema!
  raise "table schema not loaded" unless schema_loaded?
end

Requets a list of attributes for a list of items in the same table.

If you want to request a list of attributes for items that span multiple tables, see {AWS::DynamoDB#batch_get}.

You can call this method in two forms:

# block form
table.batch_get(:all, items) do |attributes|
  # yeilds one hash of attribute names/values for each item
  puts attributes.to_yaml
end

# enumerable return value
attribute_hashes = table.batch_get(:all, items)
attribute_hashes.each do |attributes|
  # ...
end

@note This method does not require the table schema to be loaded.

Attributes

You can specify the list of attributes to request in 3 ways:

• The symbol :all (to recieve all attributes)

• A single attribute name (e.g. ‘size’)

• An array of attribute names (e.g. [‘size’, ‘color’])

A few exmaples:

# get all attributes
table.batch_get(:all, items)

# only get the 'color' attribute
table.batch_get('color', items)

# get 'color' and 'size' attributes
table.batch_get(['color', size'], items)

Items

You must specify an array of items to fetch attributes for. The items param should always be an array with:

• String hash key values

• Arrays of string hash key and range key values

• Item objects

Here are a few examples:

# items as a list of hash key values 
items = %w(hashkey1 hashkey2 hashkey3)
table.batch_get(:all, items)

# items as a list of hash and range key values
items = [['hashkey1', 'rangekey2'], ['hashkey1', 'rangekey2']]
table.batch_get(:all, items)

# items as a list of Item objects
items = []
items << Item.new(table, 'hashkey1')
items << Item.new(table, 'hashkey2')
table.batch_get(:all, items)

Please note that you must provide both hash and range keys for tables that include a range key in the schema.

@param [:all, String, Array<String>] attributes The list of

attributes you want to fetch for each item.  +attributes+ may be:

* the symbol +:all+
* a single attribute name string
* an array of attribute name strings

@param [Mixed] items A list of 2 or more items to fetch attributes

for.  You may provide +items+ as:

* an array of hash key value strings
* an array of hash and range key value pairs (nested arrays)
* an array of {Item} objects

@yield [Hash] Yields a hash of attributes for each item.

@return [Enumerable] Returns an enumerable object that yields

hashes of attributes.

# File lib/aws/dynamo_db/table.rb, line 398
def batch_get attributes, items, &block
  batch = BatchGet.new(:config => config)
  batch.table(name, attributes, items)
  enum = batch.to_enum(:each_attributes)
  block_given? ? enum.each(&block) : enum
end

@return [Boolean] Returns true if the table has both a hash key and

a range key.

# File lib/aws/dynamo_db/table.rb, line 193
def composite_key?
  !simple_key?
end

Deletes a table and all of its items. The table must be in an :active state (see {status}).

@return [nil]

# File lib/aws/dynamo_db/table.rb, line 289
def delete
  client.delete_table(:table_name => name)
  nil
end

@return [Boolean] Returns true if the table exists. Note that a table

exists even when it is in a +:deleting+ state; this method
only returns false when DynamoDB no longer returns any
information about the table.

# File lib/aws/dynamo_db/table.rb, line 304
def exists?
  get_resource
  true
rescue Errors::ResourceNotFoundException
  false
end

Configures the hash key element of the table’s key schema. This is the preferred way to load the table schema so that it can be used to work with DynamoDB items.

# these are equivalent:
table.hash_key = [:id, :string]
table.hash_key = { :id => :string }

@note For tables with composite primary keys, you must call

this method first followed by {#range_key=} to configure the
table schema.

@param description A description of the hash key element. If

this is a hash, it may contain a single mapping; the key is
the name of the hash key attribute and the value is the type
(+:string+ or +:number+).  If it is an array, the first
element is the name and the second element is the type.

# File lib/aws/dynamo_db/table.rb, line 253
def hash_key= description
  static_attributes[:hash_key] =
    PrimaryKeyElement.from_description(description)
end

@return [ItemCollection] Returns an object representing all the

items in the table.

# File lib/aws/dynamo_db/table.rb, line 296
def items
  ItemCollection.new(self)
end

Loads the table’s schema information into memory. This method should not be used in a high-volume code path, and is intended only as a convenience for exploring the API. In general you should configure a schema with {hash_key=} and {range_key=} before using the table.

@note You must load the the table schema using {load_schema},

{#hash_key} or {#range_key} or configure it using
{#hash_key=} and optionally {#range_key=} in order to work
with DynamoDB items.

@return self

# File lib/aws/dynamo_db/table.rb, line 230
def load_schema
  hash_key
  self
end

@param [Hash] options

@option options [Integer] :read_capacity_units

@option options [Integer] :write_capacity_units

@return [Hash] Returns a hash with the current throughput

provisioning (+:read_capacity_units+ and +:write_capacity_units+).

# File lib/aws/dynamo_db/table.rb, line 161
def provision_throughput options = {}

  options[:read_capacity_units] ||= read_capacity_units
  options[:write_capacity_units] ||= write_capacity_units

  client_opts = {}
  client_opts[:table_name] = name
  client_opts[:provisioned_throughput] = options
  client.update_table(client_opts)

  options

end

@return [PrimaryKeyElement]

# File lib/aws/dynamo_db/table.rb, line 144
def range_key
  if schema_loaded?
    static_attributes[:range_key]
  else
    range_key_without_schema_override
  end
end

Configures the range key element of the table’s key schema. This is the preferred way to load the table schema so that it can be used to work with DynamoDB items. This method is only valid if the table has a composite key schema, and it may only be called after {hash_key=} has been used to configure the hash key element.

# these are equivalent:
table.range_key = [:id, :string]
table.range_key = { :id => :string }

@param description A description of the range key element. If

this is a hash, it may contain a single mapping; the key is
the name of the hash key attribute and the value is the type
(+:string+ or +:number+).  If it is an array, the first
element is the name and the second element is the type.

# File lib/aws/dynamo_db/table.rb, line 275
def range_key= description
  raise "attempted to set a range key without configuring a hash key first" unless
    schema_loaded?

  static_attributes[:range_key] =
    PrimaryKeyElement.from_description(description)

end

@param [Integer] read_capacity_units

# File lib/aws/dynamo_db/table.rb, line 176
def read_capacity_units= read_capacity_units
  provision_throughput(:read_capacity_units => read_capacity_units)
end

@return [Boolean] True if the table’s schema information is

loaded into memory.

@note You must load the the table schema using {load_schema},

{#hash_key} or {#range_key} or configure it using
{#hash_key=} and optionally {#range_key=} in order to work
with DynamoDB items.

# File lib/aws/dynamo_db/table.rb, line 206
def schema_loaded?
  static_attributes.include?(:hash_key)
end

@return [Boolean] Returns true if the table has a hash key and no

range key.

# File lib/aws/dynamo_db/table.rb, line 187
def simple_key?
  range_key.nil?
end

@param [Integer] write_capacity_units

# File lib/aws/dynamo_db/table.rb, line 181
def write_capacity_units= write_capacity_units
  provision_throughput(:write_capacity_units => write_capacity_units)
end