aws-sdk-dynamodb 1.0.0.rc1

data/lib/aws-sdk-dynamodb/customizations.rb

@@ -0,0 +1,5 @@
+# utility classes
+require 'aws-sdk-dynamodb/attribute_value'
+
+# customizations to generated classes
+require 'aws-sdk-dynamodb/customizations/client'

data/lib/aws-sdk-dynamodb/customizations/client.rb

@@ -0,0 +1,31 @@
+module Aws
+  module DynamoDB
+    class Client
+
+      def stub_data(operation_name, data = {})
+        if config.simple_attributes
+          rules = config.api.operation(operation_name).output
+          translator = Plugins::SimpleAttributes::ValueTranslator
+          data = translator.apply(rules, :marshal, data)
+          data = super(operation_name, data)
+          translator.apply(rules, :unmarshal, data)
+        else
+          super
+        end
+      end
+
+      private
+
+      def data_to_http_resp(operation_name, data)
+        api = config.api
+        operation = api.operation(operation_name)
+        translator = Plugins::SimpleAttributes::ValueTranslator
+        translator = translator.new(operation.output, :marshal)
+        data = translator.apply(data)
+        ParamValidator.validate!(operation.output, data)
+        protocol_helper.stub_data(api, operation, data)
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-dynamodb/errors.rb

@@ -0,0 +1,23 @@
+# WARNING ABOUT GENERATED CODE
+#
+# This file is generated. See the contributing for info on making contributions:
+# https://github.com/aws/aws-sdk-ruby/blob/master/CONTRIBUTING.md
+#
+# WARNING ABOUT GENERATED CODE
+
+module Aws
+  module DynamoDB
+    module Errors
+
+      extend Aws::Errors::DynamicErrors
+
+      # Raised when calling #load or #data on a resource class that can not be
+      # loaded.  This can happen when:
+      #
+      # * A resource class has identifiers, but no data attributes.
+      # * Resource data is only available when making an API call that
+      # enumerates all resources of that type.
+      class ResourceNotLoadable < RuntimeError; end
+    end
+  end
+end

data/lib/aws-sdk-dynamodb/plugins/crc32_validation.rb

@@ -0,0 +1,56 @@
+module Aws
+  module DynamoDB
+    module Plugins
+      class CRC32Validation < Seahorse::Client::Plugin
+
+        option(:compute_checksums,
+          default: true,
+          doc_type: 'Boolean',
+          docstring: <<-DOCS)
+When `true`, a CRC32 checksum is computed of every HTTP
+response body and compared against the `X-Amz-Crc32` header.
+If the checksums do not match, the request is re-sent.
+Failures can be retried up to `:retry_limit` times.
+          DOCS
+
+        def add_handlers(handlers, config)
+          if config.compute_checksums
+            handlers.add(Handler, step: :sign)
+          end
+        end
+
+        class Handler < Seahorse::Client::Handler
+
+          def call(context)
+            # disable response gzipping - Net::HTTP unzips these responses
+            # before we can see the body, making it impossible to verify
+            # the CRC32 checksum against the compressed body stream
+            context.http_request.headers['accept-encoding'] = ''
+
+            @handler.call(context).on_success do |response|
+              response.error = validate(context)
+            end
+          end
+
+          private
+
+          def validate(context)
+            unless crc32_is_valid?(context.http_response)
+              msg = "Response failed CRC32 check."
+              return Errors::CRC32CheckFailed.new(context, msg)
+            end
+          end
+
+          def crc32_is_valid?(response)
+            if crc_checksum = response.headers['x-amz-crc32']
+              crc_checksum.to_i == Zlib.crc32(response.body_contents)
+            else
+              true
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/aws-sdk-dynamodb/plugins/extended_retries.rb

@@ -0,0 +1,27 @@
+module Aws
+  module DynamoDB
+    module Plugins
+      class ExtendedRetries < Seahorse::Client::Plugin
+
+        option(:retry_limit,
+          default: 10,
+          required: false,
+          doc_type: Integer,
+          docstring: <<-DOCS)
+The maximum number of times to retry failed requests.  Only
+~ 500 level server errors and certain ~ 400 level client errors
+are retried.  Generally, these are throttling errors, data
+checksum errors, networking errors, timeout errors and auth
+errors from expired credentials.
+          DOCS
+
+        option(:retry_backoff, default: lambda { |context|
+          if context.retries > 1
+            Kernel.sleep(50 * (2 ** (context.retries - 1)) / 1000.0)
+          end
+        })
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-dynamodb/plugins/simple_attributes.rb

@@ -0,0 +1,215 @@
+module Aws
+  module DynamoDB
+    module Plugins
+      # Simplifies working with Amazon DynamoDB attribute values.
+      # Translates attribute values for requests and responses to sensible
+      # Ruby natives.
+      #
+      # This plugin is enabled by default for all {DynamoDB::Client}
+      # objects. You can disable this plugin by passing
+      # `simple_attributes: false` to the client constructor:
+      #
+      #     ddb = Aws::DynamoDB::Client.new(simple_attributes: false)
+      #
+      # ## Input Examples
+      #
+      # With this plugin **enabled**, `simple_attributes: true`:
+      #
+      #     dynamodb.put_item(
+      #       table_name: 'aws-sdk',
+      #       item: {
+      #         id: 'uuid',
+      #         age: 35,
+      #         tags: Set.new(%w(simple attributes)),
+      #         data: StringIO.new('data'),
+      #         scores: [5, 4.5, 4.9, nil],
+      #         name: {
+      #           first: 'John',
+      #           last: 'Doe',
+      #         }
+      #       }
+      #     )
+      #
+      # With this plugin **disabled**, `simple_attributes: false`:
+      #
+      #     # note that all types are prefixed in a hash and that
+      #     # numeric types must be serialized as strings
+      #     dynamodb.put_item(
+      #       table_name: 'aws-sdk',
+      #       item: {
+      #         'id' => { s: 'uuid' },
+      #         'age' => { n: '35' },
+      #         'tags' => { ss: ['simple', 'attributes'] },
+      #         'data' => { b: 'data' },
+      #         'scores' => {
+      #           l: [
+      #             { n: '5' },
+      #             { n: '4.5' },
+      #             { n: '4.9' },
+      #             { null: true },
+      #           ]
+      #         },
+      #         'name' => {
+      #           m: {
+      #             'first' => { s: 'John' },
+      #             'last' => { s: 'Doe' },
+      #           }
+      #         }
+      #       }
+      #     )
+      #
+      # ## Output Examples
+      #
+      # With this plugin **enabled**, `simple_attributes: true`:
+      #
+      #     resp = dynamodb.get(table_name: 'aws-sdk', key: { id: 'uuid' })
+      #     resp.item
+      #     {
+      #       id: 'uuid',
+      #       age: 35,
+      #       tags: Set.new(%w(simple attributes)),
+      #       data: StringIO.new('data'),
+      #       scores: [5, 4.5, 4.9, nil],
+      #       name: {
+      #         first: 'John',
+      #         last: 'Doe',
+      #       }
+      #     }
+      #
+      # With this plugin **disabled**, `simple_attributes: false`:
+      #
+      #     # note that the request `:key` had to be type prefixed
+      #     resp = dynamodb.get(table_name: 'aws-sdk', key: { 'id' => { s: 'uuid' }})
+      #     resp.item
+      #     # {
+      #     #   "id"=> <struct s='uuid', n=nil, b=nil, ss=nil, ns=nil, bs=nil, m=nil, l=nil, null=nil, bool=nil>
+      #     #   "age"=> <struct s=nil, n="35", b=nil, ss=nil, ns=nil, bs=nil, m=nil, l=nil, null=nil, bool=nil>
+      #     #   ...
+      #     # }
+      #
+      class SimpleAttributes < Seahorse::Client::Plugin
+
+        option(:simple_attributes,
+          doc_default: true,
+          doc_type: 'Boolean',
+          docstring: <<-DOCS
+Enables working with DynamoDB attribute values using
+hashes, arrays, sets, integers, floats, booleans, and nil.
+
+Disabling this option requires that all attribute values have
+their types specified, e.g. `{ s: 'abc' }` instead of simply
+`'abc'`.
+        DOCS
+        ) do |config|
+          !config.simple_json
+        end
+
+        def add_handlers(handlers, config)
+          if config.simple_attributes
+            handlers.add(Handler, step: :initialize)
+          end
+        end
+
+        class Handler < Seahorse::Client::Handler
+
+          def call(context)
+            context.params = translate_input(context)
+            @handler.call(context).on(200) do |response|
+              response.data = translate_output(response)
+            end
+          end
+
+          private
+
+          def translate_input(context)
+            if shape = context.operation.input
+              ValueTranslator.new(shape, :marshal).apply(context.params)
+            else
+              context.params
+            end
+          end
+
+          def translate_output(response)
+            if shape = response.context.operation.output
+              ValueTranslator.new(shape, :unmarshal).apply(response.data)
+            else
+              response.data
+            end
+          end
+
+        end
+
+        # @api private
+        class ValueTranslator
+
+          include Seahorse::Model::Shapes
+
+          def self.apply(rules, mode, data)
+            new(rules, mode).apply(data)
+          end
+
+          def initialize(rules, mode)
+            @rules = rules
+            @mode = mode
+          end
+
+          def apply(values)
+            structure(@rules, values) if @rules
+          end
+
+          private
+
+          def structure(ref, values)
+            shape = ref.shape
+            if values.is_a?(Struct)
+              values.members.each do |key|
+                values[key] = translate(shape.member(key), values[key])
+              end
+              values
+            elsif values.is_a?(Hash)
+              values.each.with_object({}) do |(key, value), hash|
+                hash[key] = translate(shape.member(key), value)
+              end
+            else
+              values
+            end
+          end
+
+          def list(ref, values)
+            return values unless values.is_a?(Array)
+            member_ref = ref.shape.member
+            values.inject([]) do |list, value|
+              list << translate(member_ref, value)
+            end
+          end
+
+          def map(ref, values)
+            return values unless values.is_a?(Hash)
+            value_ref = ref.shape.value
+            values.each.with_object({}) do |(key, value), hash|
+              hash[key] = translate(value_ref, value)
+            end
+          end
+
+          def translate(ref, value)
+            if ClientApi::AttributeValue === ref.shape
+              AttributeValue.new.send(@mode, value)
+            else
+              translate_complex(ref, value)
+            end
+          end
+
+          def translate_complex(ref, value)
+            case ref.shape
+            when StructureShape then structure(ref, value)
+            when ListShape then list(ref, value)
+            when MapShape then map(ref, value)
+            else value
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/aws-sdk-dynamodb/resource.rb

@@ -0,0 +1,517 @@
+# WARNING ABOUT GENERATED CODE
+#
+# This file is generated. See the contributing for info on making contributions:
+# https://github.com/aws/aws-sdk-ruby/blob/master/CONTRIBUTING.md
+#
+# WARNING ABOUT GENERATED CODE
+
+module Aws
+  module DynamoDB
+    class Resource
+
+      # @param options ({})
+      # @option options [Client] :client
+      def initialize(options = {})
+        @client = options[:client] || Client.new(options)
+      end
+
+      # @return [Client]
+      def client
+        @client
+      end
+
+      # @!group Actions
+
+      # @example Request syntax with placeholder values
+      #
+      #   dynamo_db.batch_get_item({
+      #     request_items: { # required
+      #       "TableName" => {
+      #         keys: [ # required
+      #           {
+      #             "AttributeName" => "value", # value <Hash,Array,String,Numeric,Boolean,IO,Set,nil>
+      #           },
+      #         ],
+      #         attributes_to_get: ["AttributeName"],
+      #         consistent_read: false,
+      #         projection_expression: "ProjectionExpression",
+      #         expression_attribute_names: {
+      #           "ExpressionAttributeNameVariable" => "AttributeName",
+      #         },
+      #       },
+      #     },
+      #     return_consumed_capacity: "INDEXES", # accepts INDEXES, TOTAL, NONE
+      #   })
+      # @param [Hash] options ({})
+      # @option options [required, Hash<String,Types::KeysAndAttributes>] :request_items
+      #   A map of one or more table names and, for each table, a map that
+      #   describes one or more items to retrieve from that table. Each table
+      #   name can be used only once per *BatchGetItem* request.
+      #
+      #   Each element in the map of items to retrieve consists of the
+      #   following:
+      #
+      #   * *ConsistentRead* - If `true`, a strongly consistent read is used; if
+      #     `false` (the default), an eventually consistent read is used.
+      #
+      #   * *ExpressionAttributeNames* - One or more substitution tokens for
+      #     attribute names in the *ProjectionExpression* parameter. The
+      #     following are some use cases for using *ExpressionAttributeNames*\:
+      #
+      #     * To access an attribute whose name conflicts with a DynamoDB
+      #       reserved word.
+      #
+      #     * To create a placeholder for repeating occurrences of an attribute
+      #       name in an expression.
+      #
+      #     * To prevent special characters in an attribute name from being
+      #       misinterpreted in an expression.
+      #
+      #     Use the **#** character in an expression to dereference an attribute
+      #     name. For example, consider the following attribute name:
+      #
+      #     * `Percentile`
+      #
+      #     ^
+      #
+      #     The name of this attribute conflicts with a reserved word, so it
+      #     cannot be used directly in an expression. (For the complete list of
+      #     reserved words, see [Reserved Words][1] in the *Amazon DynamoDB
+      #     Developer Guide*). To work around this, you could specify the
+      #     following for *ExpressionAttributeNames*\:
+      #
+      #     * `\{"#P":"Percentile"\}`
+      #
+      #     ^
+      #
+      #     You could then use this substitution in an expression, as in this
+      #     example:
+      #
+      #     * `#P = :val`
+      #
+      #     ^
+      #
+      #     <note markdown="1"> Tokens that begin with the **\:** character are *expression
+      #     attribute values*, which are placeholders for the actual value at
+      #     runtime.
+      #
+      #      </note>
+      #
+      #     For more information on expression attribute names, see [Accessing
+      #     Item Attributes][2] in the *Amazon DynamoDB Developer Guide*.
+      #
+      #   * *Keys* - An array of primary key attribute values that define
+      #     specific items in the table. For each primary key, you must provide
+      #     *all* of the key attributes. For example, with a simple primary key,
+      #     you only need to provide the partition key value. For a composite
+      #     key, you must provide *both* the partition key value and the sort
+      #     key value.
+      #
+      #   * *ProjectionExpression* - A string that identifies one or more
+      #     attributes to retrieve from the table. These attributes can include
+      #     scalars, sets, or elements of a JSON document. The attributes in the
+      #     expression must be separated by commas.
+      #
+      #     If no attribute names are specified, then all attributes will be
+      #     returned. If any of the requested attributes are not found, they
+      #     will not appear in the result.
+      #
+      #     For more information, see [Accessing Item Attributes][2] in the
+      #     *Amazon DynamoDB Developer Guide*.
+      #
+      #   * *AttributesToGet* -
+      #
+      #     This is a legacy parameter, for backward compatibility. New
+      #     applications should use *ProjectionExpression* instead. Do not
+      #     combine legacy parameters and expression parameters in a single API
+      #     call; otherwise, DynamoDB will return a *ValidationException*
+      #     exception.
+      #
+      #      This parameter allows you to retrieve attributes of type List or
+      #     Map; however, it cannot retrieve individual elements within a List
+      #     or a Map.
+      #
+      #     The names of one or more attributes to retrieve. If no attribute
+      #     names are provided, then all attributes will be returned. If any of
+      #     the requested attributes are not found, they will not appear in the
+      #     result.
+      #
+      #     Note that *AttributesToGet* has no effect on provisioned throughput
+      #     consumption. DynamoDB determines capacity units consumed based on
+      #     item size, not on the amount of data that is returned to an
+      #     application.
+      #
+      #
+      #
+      #   [1]: http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html
+      #   [2]: http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html
+      # @option options [String] :return_consumed_capacity
+      #   Determines the level of detail about provisioned throughput
+      #   consumption that is returned in the response:
+      #
+      #   * *INDEXES* - The response includes the aggregate *ConsumedCapacity*
+      #     for the operation, together with *ConsumedCapacity* for each table
+      #     and secondary index that was accessed.
+      #
+      #     Note that some operations, such as *GetItem* and *BatchGetItem*, do
+      #     not access any indexes at all. In these cases, specifying *INDEXES*
+      #     will only return *ConsumedCapacity* information for table(s).
+      #
+      #   * *TOTAL* - The response includes only the aggregate
+      #     *ConsumedCapacity* for the operation.
+      #
+      #   * *NONE* - No *ConsumedCapacity* details are included in the response.
+      # @return [Types::BatchGetItemOutput]
+      def batch_get_item(options = {})
+        resp = @client.batch_get_item(options)
+        resp.data
+      end
+
+      # @example Request syntax with placeholder values
+      #
+      #   dynamo_db.batch_write_item({
+      #     request_items: { # required
+      #       "TableName" => [
+      #         {
+      #           put_request: {
+      #             item: { # required
+      #               "AttributeName" => "value", # value <Hash,Array,String,Numeric,Boolean,IO,Set,nil>
+      #             },
+      #           },
+      #           delete_request: {
+      #             key: { # required
+      #               "AttributeName" => "value", # value <Hash,Array,String,Numeric,Boolean,IO,Set,nil>
+      #             },
+      #           },
+      #         },
+      #       ],
+      #     },
+      #     return_consumed_capacity: "INDEXES", # accepts INDEXES, TOTAL, NONE
+      #     return_item_collection_metrics: "SIZE", # accepts SIZE, NONE
+      #   })
+      # @param [Hash] options ({})
+      # @option options [required, Hash<String,Array>] :request_items
+      #   A map of one or more table names and, for each table, a list of
+      #   operations to be performed (*DeleteRequest* or *PutRequest*). Each
+      #   element in the map consists of the following:
+      #
+      #   * *DeleteRequest* - Perform a *DeleteItem* operation on the specified
+      #     item. The item to be deleted is identified by a *Key* subelement:
+      #
+      #     * *Key* - A map of primary key attribute values that uniquely
+      #       identify the ! item. Each entry in this map consists of an
+      #       attribute name and an attribute value. For each primary key, you
+      #       must provide *all* of the key attributes. For example, with a
+      #       simple primary key, you only need to provide a value for the
+      #       partition key. For a composite primary key, you must provide
+      #       values for *both* the partition key and the sort key.
+      #
+      #     ^
+      #
+      #   * *PutRequest* - Perform a *PutItem* operation on the specified item.
+      #     The item to be put is identified by an *Item* subelement:
+      #
+      #     * *Item* - A map of attributes and their values. Each entry in this
+      #       map consists of an attribute name and an attribute value.
+      #       Attribute values must not be null; string and binary type
+      #       attributes must have lengths greater than zero; and set type
+      #       attributes must not be empty. Requests that contain empty values
+      #       will be rejected with a *ValidationException* exception.
+      #
+      #       If you specify any attributes that are part of an index key, then
+      #       the data types for those attributes must match those of the schema
+      #       in the table's attribute definition.
+      # @option options [String] :return_consumed_capacity
+      #   Determines the level of detail about provisioned throughput
+      #   consumption that is returned in the response:
+      #
+      #   * *INDEXES* - The response includes the aggregate *ConsumedCapacity*
+      #     for the operation, together with *ConsumedCapacity* for each table
+      #     and secondary index that was accessed.
+      #
+      #     Note that some operations, such as *GetItem* and *BatchGetItem*, do
+      #     not access any indexes at all. In these cases, specifying *INDEXES*
+      #     will only return *ConsumedCapacity* information for table(s).
+      #
+      #   * *TOTAL* - The response includes only the aggregate
+      #     *ConsumedCapacity* for the operation.
+      #
+      #   * *NONE* - No *ConsumedCapacity* details are included in the response.
+      # @option options [String] :return_item_collection_metrics
+      #   Determines whether item collection metrics are returned. If set to
+      #   `SIZE`, the response includes statistics about item collections, if
+      #   any, that were modified during the operation are returned in the
+      #   response. If set to `NONE` (the default), no statistics are returned.
+      # @return [Types::BatchWriteItemOutput]
+      def batch_write_item(options = {})
+        resp = @client.batch_write_item(options)
+        resp.data
+      end
+
+      # @example Request syntax with placeholder values
+      #
+      #   table = dynamo_db.create_table({
+      #     attribute_definitions: [ # required
+      #       {
+      #         attribute_name: "KeySchemaAttributeName", # required
+      #         attribute_type: "S", # required, accepts S, N, B
+      #       },
+      #     ],
+      #     table_name: "TableName", # required
+      #     key_schema: [ # required
+      #       {
+      #         attribute_name: "KeySchemaAttributeName", # required
+      #         key_type: "HASH", # required, accepts HASH, RANGE
+      #       },
+      #     ],
+      #     local_secondary_indexes: [
+      #       {
+      #         index_name: "IndexName", # required
+      #         key_schema: [ # required
+      #           {
+      #             attribute_name: "KeySchemaAttributeName", # required
+      #             key_type: "HASH", # required, accepts HASH, RANGE
+      #           },
+      #         ],
+      #         projection: { # required
+      #           projection_type: "ALL", # accepts ALL, KEYS_ONLY, INCLUDE
+      #           non_key_attributes: ["NonKeyAttributeName"],
+      #         },
+      #       },
+      #     ],
+      #     global_secondary_indexes: [
+      #       {
+      #         index_name: "IndexName", # required
+      #         key_schema: [ # required
+      #           {
+      #             attribute_name: "KeySchemaAttributeName", # required
+      #             key_type: "HASH", # required, accepts HASH, RANGE
+      #           },
+      #         ],
+      #         projection: { # required
+      #           projection_type: "ALL", # accepts ALL, KEYS_ONLY, INCLUDE
+      #           non_key_attributes: ["NonKeyAttributeName"],
+      #         },
+      #         provisioned_throughput: { # required
+      #           read_capacity_units: 1, # required
+      #           write_capacity_units: 1, # required
+      #         },
+      #       },
+      #     ],
+      #     provisioned_throughput: { # required
+      #       read_capacity_units: 1, # required
+      #       write_capacity_units: 1, # required
+      #     },
+      #     stream_specification: {
+      #       stream_enabled: false,
+      #       stream_view_type: "NEW_IMAGE", # accepts NEW_IMAGE, OLD_IMAGE, NEW_AND_OLD_IMAGES, KEYS_ONLY
+      #     },
+      #   })
+      # @param [Hash] options ({})
+      # @option options [required, Array<Types::AttributeDefinition>] :attribute_definitions
+      #   An array of attributes that describe the key schema for the table and
+      #   indexes.
+      # @option options [required, String] :table_name
+      #   The name of the table to create.
+      # @option options [required, Array<Types::KeySchemaElement>] :key_schema
+      #   Specifies the attributes that make up the primary key for a table or
+      #   an index. The attributes in *KeySchema* must also be defined in the
+      #   *AttributeDefinitions* array. For more information, see [Data
+      #   Model][1] in the *Amazon DynamoDB Developer Guide*.
+      #
+      #   Each *KeySchemaElement* in the array is composed of:
+      #
+      #   * *AttributeName* - The name of this key attribute.
+      #
+      #   * *KeyType* - The role that the key attribute will assume:
+      #
+      #     * `HASH` - partition key
+      #
+      #     * `RANGE` - sort key
+      #
+      #   <note markdown="1"> The partition key of an item is also known as its *hash attribute*.
+      #   The term "hash attribute" derives from DynamoDB' usage of an
+      #   internal hash function to evenly distribute data items across
+      #   partitions, based on their partition key values.
+      #
+      #    The sort key of an item is also known as its *range attribute*. The
+      #   term "range attribute" derives from the way DynamoDB stores items
+      #   with the same partition key physically close together, in sorted order
+      #   by the sort key value.
+      #
+      #    </note>
+      #
+      #   For a simple primary key (partition key), you must provide exactly one
+      #   element with a *KeyType* of `HASH`.
+      #
+      #   For a composite primary key (partition key and sort key), you must
+      #   provide exactly two elements, in this order: The first element must
+      #   have a *KeyType* of `HASH`, and the second element must have a
+      #   *KeyType* of `RANGE`.
+      #
+      #   For more information, see [Specifying the Primary Key][2] in the
+      #   *Amazon DynamoDB Developer Guide*.
+      #
+      #
+      #
+      #   [1]: http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataModel.html
+      #   [2]: http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html#WorkingWithTables.primary.key
+      # @option options [Array<Types::LocalSecondaryIndex>] :local_secondary_indexes
+      #   One or more local secondary indexes (the maximum is five) to be
+      #   created on the table. Each index is scoped to a given partition key
+      #   value. There is a 10 GB size limit per partition key value; otherwise,
+      #   the size of a local secondary index is unconstrained.
+      #
+      #   Each local secondary index in the array includes the following:
+      #
+      #   * *IndexName* - The name of the local secondary index. Must be unique
+      #     only for this table.
+      #
+      #
+      #
+      #   * *KeySchema* - Specifies the key schema for the local secondary
+      #     index. The key schema must begin with the same partition key as the
+      #     table.
+      #
+      #   * *Projection* - Specifies attributes that are copied (projected) from
+      #     the table into the index. These are in addition to the primary key
+      #     attributes and index key attributes, which are automatically
+      #     projected. Each attribute specification is composed of:
+      #
+      #     * *ProjectionType* - One of the following:
+      #
+      #       * `KEYS_ONLY` - Only the index and primary keys are projected into
+      #         the index.
+      #
+      #       * `INCLUDE` - Only the specified table attributes are projected
+      #         into the index. The list of projected attributes are in
+      #         *NonKeyAttributes*.
+      #
+      #       * `ALL` - All of the table attributes are projected into the
+      #         index.
+      #
+      #     * *NonKeyAttributes* - A list of one or more non-key attribute names
+      #       that are projected into the secondary index. The total count of
+      #       attributes provided in *NonKeyAttributes*, summed across all of
+      #       the secondary indexes, must not exceed 20. If you project the same
+      #       attribute into two different indexes, this counts as two distinct
+      #       attributes when determining the total.
+      # @option options [Array<Types::GlobalSecondaryIndex>] :global_secondary_indexes
+      #   One or more global secondary indexes (the maximum is five) to be
+      #   created on the table. Each global secondary index in the array
+      #   includes the following:
+      #
+      #   * *IndexName* - The name of the global secondary index. Must be unique
+      #     only for this table.
+      #
+      #
+      #
+      #   * *KeySchema* - Specifies the key schema for the global secondary
+      #     index.
+      #
+      #   * *Projection* - Specifies attributes that are copied (projected) from
+      #     the table into the index. These are in addition to the primary key
+      #     attributes and index key attributes, which are automatically
+      #     projected. Each attribute specification is composed of:
+      #
+      #     * *ProjectionType* - One of the following:
+      #
+      #       * `KEYS_ONLY` - Only the index and primary keys are projected into
+      #         the index.
+      #
+      #       * `INCLUDE` - Only the specified table attributes are projected
+      #         into the index. The list of projected attributes are in
+      #         *NonKeyAttributes*.
+      #
+      #       * `ALL` - All of the table attributes are projected into the
+      #         index.
+      #
+      #     * *NonKeyAttributes* - A list of one or more non-key attribute names
+      #       that are projected into the secondary index. The total count of
+      #       attributes provided in *NonKeyAttributes*, summed across all of
+      #       the secondary indexes, must not exceed 20. If you project the same
+      #       attribute into two different indexes, this counts as two distinct
+      #       attributes when determining the total.
+      #
+      #   * *ProvisionedThroughput* - The provisioned throughput settings for
+      #     the global secondary index, consisting of read and write capacity
+      #     units.
+      # @option options [required, Types::ProvisionedThroughput] :provisioned_throughput
+      #   Represents the provisioned throughput settings for a specified table
+      #   or index. The settings can be modified using the *UpdateTable*
+      #   operation.
+      #
+      #   For current minimum and maximum provisioned throughput values, see
+      #   [Limits][1] in the *Amazon DynamoDB Developer Guide*.
+      #
+      #
+      #
+      #   [1]: http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html
+      # @option options [Types::StreamSpecification] :stream_specification
+      #   The settings for DynamoDB Streams on the table. These settings consist
+      #   of:
+      #
+      #   * *StreamEnabled* - Indicates whether Streams is to be enabled (true)
+      #     or disabled (false).
+      #
+      #   * *StreamViewType* - When an item in the table is modified,
+      #     *StreamViewType* determines what information is written to the
+      #     table's stream. Valid values for *StreamViewType* are:
+      #
+      #     * *KEYS\_ONLY* - Only the key attributes of the modified item are
+      #       written to the stream.
+      #
+      #     * *NEW\_IMAGE* - The entire item, as it appears after it was
+      #       modified, is written to the stream.
+      #
+      #     * *OLD\_IMAGE* - The entire item, as it appeared before it was
+      #       modified, is written to the stream.
+      #
+      #     * *NEW\_AND\_OLD\_IMAGES* - Both the new and the old item images of
+      #       the item are written to the stream.
+      # @return [Table]
+      def create_table(options = {})
+        resp = @client.create_table(options)
+        Table.new(
+          name: resp.data.table_description.table_name,
+          data: resp.data.table_description,
+          client: @client
+        )
+      end
+
+      # @!group Associations
+
+      # @param [String] name
+      # @return [Table]
+      def table(name)
+        Table.new(
+          name: name,
+          client: @client
+        )
+      end
+
+      # @example Request syntax with placeholder values
+      #
+      #   tables = dynamo_db.tables()
+      # @param [Hash] options ({})
+      # @return [Table::Collection]
+      def tables(options = {})
+        batches = Enumerator.new do |y|
+          resp = @client.list_tables(options)
+          resp.each_page do |page|
+            batch = []
+            page.data.table_names.each do |t|
+              batch << Table.new(
+                name: t,
+                client: @client
+              )
+            end
+            y.yield(batch)
+          end
+        end
+        Table::Collection.new(batches)
+      end
+
+    end
+  end
+end