Class: AWS.DynamoDB (2011-12-05)

var params = {
  RequestItems: { /* required */
    '<TableName>': [
      {
        DeleteRequest: {
          Key: { /* required */
            HashKeyElement: { /* required */
              B: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
              BS: [
                Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
                /* more items */
              ],
              N: 'STRING_VALUE',
              NS: [
                'STRING_VALUE',
                /* more items */
              ],
              S: 'STRING_VALUE',
              SS: [
                'STRING_VALUE',
                /* more items */
              ]
            },
            RangeKeyElement: {
              B: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
              BS: [
                Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
                /* more items */
              ],
              N: 'STRING_VALUE',
              NS: [
                'STRING_VALUE',
                /* more items */
              ],
              S: 'STRING_VALUE',
              SS: [
                'STRING_VALUE',
                /* more items */
              ]
            }
          }
        },
        PutRequest: {
          Item: { /* required */
            '<AttributeName>': {
              B: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
              BS: [
                Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
                /* more items */
              ],
              N: 'STRING_VALUE',
              NS: [
                'STRING_VALUE',
                /* more items */
              ],
              S: 'STRING_VALUE',
              SS: [
                'STRING_VALUE',
                /* more items */
              ]
            },
            /* '<AttributeName>': ... */
          }
        }
      },
      /* more items */
    ],
    /* '<TableName>': ... */
  }
};
dynamodb.batchWriteItem(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

• params (Object) (defaults to: {}) —
  • RequestItems — (map<Array<map>>)

    A map of table name to list-of-write-requests. Used as input to the BatchWriteItem API call

    • PutRequest — (map)

      A container for a Put BatchWrite request

      • Item — required — (map<map>)

        The item to put

        • S — (String)

          Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

        • N — (String)

          Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

        • B — (Buffer, Typed Array, Blob, String)

          Binary attributes are sequences of unsigned bytes.

        • SS — (Array<String>)

          A set of strings.

        • NS — (Array<String>)

          A set of numbers.

        • BS — (Array<Buffer, Typed Array, Blob, String>)

          A set of binary attributes.

    • DeleteRequest — (map)

      A container for a Delete BatchWrite request

      • Key — required — (map)

        The item's key to be delete

        • HashKeyElement — required — (map)

          A hash key element is treated as the primary key, and can be a string or a number. Single attribute primary keys have one index value. The value can be String, Number, StringSet, NumberSet.

          • S — (String)

            Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

          • N — (String)

            Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

          • B — (Buffer, Typed Array, Blob, String)

            Binary attributes are sequences of unsigned bytes.

          • SS — (Array<String>)

            A set of strings.

          • NS — (Array<String>)

            A set of numbers.

          • BS — (Array<Buffer, Typed Array, Blob, String>)

            A set of binary attributes.

        • RangeKeyElement — (map)

          A range key element is treated as a secondary key (used in conjunction with the primary key), and can be a string or a number, and is only used for hash-and-range primary keys. The value can be String, Number, StringSet, NumberSet.

          • S — (String)

            Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

          • N — (String)

            Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

          • B — (Buffer, Typed Array, Blob, String)

            Binary attributes are sequences of unsigned bytes.

          • SS — (Array<String>)

            A set of strings.

          • NS — (Array<String>)

            A set of numbers.

          • BS — (Array<Buffer, Typed Array, Blob, String>)

            A set of binary attributes.

Callback (callback):

• function(err, data) { ... }

  Called when a response from the service is returned. If a callback is not supplied, you must call AWS.Request.send() on the returned request object to initiate the request.

  Context (this):

  • (AWS.Response) —

    the response object containing error, data properties, and the original request object.

  Parameters:

  • err (Error) —

    the error object returned from the request. Set to null if the request is successful.

  • data (Object) —

    the de-serialized data returned from the request. Set to null if a request error occurs. The data object has the following properties:

    • Responses — (map<map>)

      The response object as a result of BatchWriteItem call. This is essentially a map of table name to ConsumedCapacityUnits.

      • ConsumedCapacityUnits — (Float)

        The number of Capacity Units of the provisioned throughput of the table consumed during the operation. GetItem, BatchGetItem, BatchWriteItem, Query, and Scan operations consume ReadCapacityUnits, while PutItem, UpdateItem, and DeleteItem operations consume WriteCapacityUnits.

    • UnprocessedItems — (map<Array<map>>)

      The Items which we could not successfully process in a BatchWriteItem call is returned as UnprocessedItems

      • PutRequest — (map)

        A container for a Put BatchWrite request

        • Item — required — (map<map>)

          The item to put

          • S — (String)

            Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

          • N — (String)

            Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

          • B — (Buffer, Typed Array, Blob, String)

            Binary attributes are sequences of unsigned bytes.

          • SS — (Array<String>)

            A set of strings.

          • NS — (Array<String>)

            A set of numbers.

          • BS — (Array<Buffer, Typed Array, Blob, String>)

            A set of binary attributes.

      • DeleteRequest — (map)

        A container for a Delete BatchWrite request

        • Key — required — (map)

          The item's key to be delete

          • HashKeyElement — required — (map)

            A hash key element is treated as the primary key, and can be a string or a number. Single attribute primary keys have one index value. The value can be String, Number, StringSet, NumberSet.

            • S — (String)

              Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

            • N — (String)

              Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

            • B — (Buffer, Typed Array, Blob, String)

              Binary attributes are sequences of unsigned bytes.

            • SS — (Array<String>)

              A set of strings.

            • NS — (Array<String>)

              A set of numbers.

            • BS — (Array<Buffer, Typed Array, Blob, String>)

              A set of binary attributes.

          • RangeKeyElement — (map)

            A range key element is treated as a secondary key (used in conjunction with the primary key), and can be a string or a number, and is only used for hash-and-range primary keys. The value can be String, Number, StringSet, NumberSet.

            • S — (String)

              Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

            • N — (String)

              Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

            • B — (Buffer, Typed Array, Blob, String)

              Binary attributes are sequences of unsigned bytes.

            • SS — (Array<String>)

              A set of strings.

            • NS — (Array<String>)

              A set of numbers.

            • BS — (Array<Buffer, Typed Array, Blob, String>)

              A set of binary attributes.

Returns:

• (AWS.Request) —

  a handle to the operation request for subsequent event callback registration.

var params = {
  KeySchema: { /* required */
    HashKeyElement: { /* required */
      AttributeName: 'STRING_VALUE', /* required */
      AttributeType: S | N | B /* required */
    },
    RangeKeyElement: {
      AttributeName: 'STRING_VALUE', /* required */
      AttributeType: S | N | B /* required */
    }
  },
  ProvisionedThroughput: { /* required */
    ReadCapacityUnits: 'NUMBER_VALUE', /* required */
    WriteCapacityUnits: 'NUMBER_VALUE' /* required */
  },
  TableName: 'STRING_VALUE' /* required */
};
dynamodb.createTable(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

• params (Object) (defaults to: {}) —
  • TableName — (String)

    The name of the table you want to create. Allowed characters are a-z, A-Z, 0-9, _ (underscore), - (hyphen) and . (period).

  • KeySchema — (map)

    The KeySchema identifies the primary key as a one attribute primary key (hash) or a composite two attribute (hash-and-range) primary key. Single attribute primary keys have one index value: a HashKeyElement. A composite hash-and-range primary key contains two attribute values: a HashKeyElement and a RangeKeyElement.

    • HashKeyElement — required — (map)

      A hash key element is treated as the primary key, and can be a string or a number. Single attribute primary keys have one index value. The value can be String, Number, StringSet, NumberSet.

      • AttributeName — required — (String)

        The AttributeName of the KeySchemaElement.

      • AttributeType — required — (String)

        The AttributeType of the KeySchemaElement which can be a String or a Number.

        Possible values include:
        • "S"
        • "N"
        • "B"
    • RangeKeyElement — (map)

      A range key element is treated as a secondary key (used in conjunction with the primary key), and can be a string or a number, and is only used for hash-and-range primary keys. The value can be String, Number, StringSet, NumberSet.

      • AttributeName — required — (String)

        The AttributeName of the KeySchemaElement.

      • AttributeType — required — (String)

        The AttributeType of the KeySchemaElement which can be a String or a Number.

        Possible values include:
        • "S"
        • "N"
        • "B"
  • ProvisionedThroughput — (map)

    Provisioned throughput reserves the required read and write resources for your table in terms of ReadCapacityUnits and WriteCapacityUnits. Values for provisioned throughput depend upon your expected read/write rates, item size, and consistency. Provide the expected number of read and write operations, assuming an item size of 1k and strictly consistent reads. For 2k item size, double the value. For 3k, triple the value, etc. Eventually-consistent reads consume half the resources of strictly consistent reads.

    • ReadCapacityUnits — required — (Integer)

      ReadCapacityUnits are in terms of strictly consistent reads, assuming items of 1k. 2k items require twice the ReadCapacityUnits. Eventually-consistent reads only require half the ReadCapacityUnits of stirctly consistent reads.

    • WriteCapacityUnits — required — (Integer)

      WriteCapacityUnits are in terms of strictly consistent reads, assuming items of 1k. 2k items require twice the WriteCapacityUnits.

Callback (callback):

• function(err, data) { ... }

  Called when a response from the service is returned. If a callback is not supplied, you must call AWS.Request.send() on the returned request object to initiate the request.

  Context (this):

  • (AWS.Response) —

    the response object containing error, data properties, and the original request object.

  Parameters:

  • err (Error) —

    the error object returned from the request. Set to null if the request is successful.

  • data (Object) —

    the de-serialized data returned from the request. Set to null if a request error occurs. The data object has the following properties:

    • TableDescription — (map)
      • TableName — (String)

        The name of the table being described.

      • KeySchema — (map)

        The KeySchema identifies the primary key as a one attribute primary key (hash) or a composite two attribute (hash-and-range) primary key. Single attribute primary keys have one index value: a HashKeyElement. A composite hash-and-range primary key contains two attribute values: a HashKeyElement and a RangeKeyElement.

        • HashKeyElement — required — (map)

          A hash key element is treated as the primary key, and can be a string or a number. Single attribute primary keys have one index value. The value can be String, Number, StringSet, NumberSet.

          • AttributeName — required — (String)

            The AttributeName of the KeySchemaElement.

          • AttributeType — required — (String)

            The AttributeType of the KeySchemaElement which can be a String or a Number.

            Possible values include:
            • "S"
            • "N"
            • "B"
        • RangeKeyElement — (map)

          A range key element is treated as a secondary key (used in conjunction with the primary key), and can be a string or a number, and is only used for hash-and-range primary keys. The value can be String, Number, StringSet, NumberSet.

          • AttributeName — required — (String)

            The AttributeName of the KeySchemaElement.

          • AttributeType — required — (String)

            The AttributeType of the KeySchemaElement which can be a String or a Number.

            Possible values include:
            • "S"
            • "N"
            • "B"
      • TableStatus — (String) Possible values include:
        • "CREATING"
        • "UPDATING"
        • "DELETING"
        • "ACTIVE"
      • CreationDateTime — (Date)
      • ProvisionedThroughput — (map)
        • LastIncreaseDateTime — (Date)
        • LastDecreaseDateTime — (Date)
        • NumberOfDecreasesToday — (Integer)
        • ReadCapacityUnits — (Integer)
        • WriteCapacityUnits — (Integer)
      • TableSizeBytes — (Integer)
      • ItemCount — (Integer)

Returns:

• (AWS.Request) —

  a handle to the operation request for subsequent event callback registration.

var params = {
  Key: { /* required */
    HashKeyElement: { /* required */
      B: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
      BS: [
        Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
        /* more items */
      ],
      N: 'STRING_VALUE',
      NS: [
        'STRING_VALUE',
        /* more items */
      ],
      S: 'STRING_VALUE',
      SS: [
        'STRING_VALUE',
        /* more items */
      ]
    },
    RangeKeyElement: {
      B: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
      BS: [
        Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
        /* more items */
      ],
      N: 'STRING_VALUE',
      NS: [
        'STRING_VALUE',
        /* more items */
      ],
      S: 'STRING_VALUE',
      SS: [
        'STRING_VALUE',
        /* more items */
      ]
    }
  },
  TableName: 'STRING_VALUE', /* required */
  Expected: {
    '<AttributeName>': {
      Exists: true || false,
      Value: {
        B: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
        BS: [
          Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
          /* more items */
        ],
        N: 'STRING_VALUE',
        NS: [
          'STRING_VALUE',
          /* more items */
        ],
        S: 'STRING_VALUE',
        SS: [
          'STRING_VALUE',
          /* more items */
        ]
      }
    },
    /* '<AttributeName>': ... */
  },
  ReturnValues: NONE | ALL_OLD | UPDATED_OLD | ALL_NEW | UPDATED_NEW
};
dynamodb.deleteItem(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

• params (Object) (defaults to: {}) —
  • TableName — (String)

    The name of the table in which you want to delete an item. Allowed characters are a-z, A-Z, 0-9, _ (underscore), - (hyphen) and . (period).

  • Key — (map)

    The primary key that uniquely identifies each item in a table. A primary key can be a one attribute (hash) primary key or a two attribute (hash-and-range) primary key.

    • HashKeyElement — required — (map)

      A hash key element is treated as the primary key, and can be a string or a number. Single attribute primary keys have one index value. The value can be String, Number, StringSet, NumberSet.

      • S — (String)

        Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

      • N — (String)

        Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

      • B — (Buffer, Typed Array, Blob, String)

        Binary attributes are sequences of unsigned bytes.

      • SS — (Array<String>)

        A set of strings.

      • NS — (Array<String>)

        A set of numbers.

      • BS — (Array<Buffer, Typed Array, Blob, String>)

        A set of binary attributes.

    • RangeKeyElement — (map)

      A range key element is treated as a secondary key (used in conjunction with the primary key), and can be a string or a number, and is only used for hash-and-range primary keys. The value can be String, Number, StringSet, NumberSet.

      • S — (String)

        Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

      • N — (String)

        Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

      • B — (Buffer, Typed Array, Blob, String)

        Binary attributes are sequences of unsigned bytes.

      • SS — (Array<String>)

        A set of strings.

      • NS — (Array<String>)

        A set of numbers.

      • BS — (Array<Buffer, Typed Array, Blob, String>)

        A set of binary attributes.

  • Expected — (map<map>)

    Designates an attribute for a conditional modification. The Expected parameter allows you to provide an attribute name, and whether or not Amazon DynamoDB should check to see if the attribute has a particular value before modifying it.

    • Value — (map)

      Specify whether or not a value already exists and has a specific content for the attribute name-value pair.

      • S — (String)

        Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

      • N — (String)

        Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

      • B — (Buffer, Typed Array, Blob, String)

        Binary attributes are sequences of unsigned bytes.

      • SS — (Array<String>)

        A set of strings.

      • NS — (Array<String>)

        A set of numbers.

      • BS — (Array<Buffer, Typed Array, Blob, String>)

        A set of binary attributes.

    • Exists — (Boolean)

      Specify whether or not a value already exists for the attribute name-value pair.

  • ReturnValues — (String)

    Use this parameter if you want to get the attribute name-value pairs before or after they are modified. For PUT operations, the possible parameter values are NONE (default) or ALL_OLD. For update operations, the possible parameter values are NONE (default) or ALL_OLD, UPDATED_OLD, ALL_NEW or UPDATED_NEW.

    • NONE: Nothing is returned.
    • ALL_OLD: Returns the attributes of the item as they were before the operation.
    • UPDATED_OLD: Returns the values of the updated attributes, only, as they were before the operation.
    • ALL_NEW: Returns all the attributes and their new values after the operation.
    • UPDATED_NEW: Returns the values of the updated attributes, only, as they are after the operation.
    Possible values include:
    • "NONE"
    • "ALL_OLD"
    • "UPDATED_OLD"
    • "ALL_NEW"
    • "UPDATED_NEW"

Callback (callback):

• function(err, data) { ... }

  Called when a response from the service is returned. If a callback is not supplied, you must call AWS.Request.send() on the returned request object to initiate the request.

  Context (this):

  • (AWS.Response) —

    the response object containing error, data properties, and the original request object.

  Parameters:

  • err (Error) —

    the error object returned from the request. Set to null if the request is successful.

  • data (Object) —

    the de-serialized data returned from the request. Set to null if a request error occurs. The data object has the following properties:

    • Attributes — (map<map>)

      If the ReturnValues parameter is provided as ALL_OLD in the request, Amazon DynamoDB returns an array of attribute name-value pairs (essentially, the deleted item). Otherwise, the response contains an empty set.

      • S — (String)

        Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

      • N — (String)

        Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

      • B — (Buffer, Typed Array, Blob, String)

        Binary attributes are sequences of unsigned bytes.

      • SS — (Array<String>)

        A set of strings.

      • NS — (Array<String>)

        A set of numbers.

      • BS — (Array<Buffer, Typed Array, Blob, String>)

        A set of binary attributes.

    • ConsumedCapacityUnits — (Float)

      The number of Capacity Units of the provisioned throughput of the table consumed during the operation. GetItem, BatchGetItem, BatchWriteItem, Query, and Scan operations consume ReadCapacityUnits, while PutItem, UpdateItem, and DeleteItem operations consume WriteCapacityUnits.

Returns:

• (AWS.Request) —

  a handle to the operation request for subsequent event callback registration.

var params = {
  TableName: 'STRING_VALUE' /* required */
};
dynamodb.deleteTable(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

• params (Object) (defaults to: {}) —
  • TableName — (String)

    The name of the table you want to delete. Allowed characters are a-z, A-Z, 0-9, _ (underscore), - (hyphen) and . (period).

Callback (callback):

• function(err, data) { ... }

  Called when a response from the service is returned. If a callback is not supplied, you must call AWS.Request.send() on the returned request object to initiate the request.

  Context (this):

  • (AWS.Response) —

    the response object containing error, data properties, and the original request object.

  Parameters:

  • err (Error) —

    the error object returned from the request. Set to null if the request is successful.

  • data (Object) —

    the de-serialized data returned from the request. Set to null if a request error occurs. The data object has the following properties:

    • TableDescription — (map)
      • TableName — (String)

        The name of the table being described.

      • KeySchema — (map)

        The KeySchema identifies the primary key as a one attribute primary key (hash) or a composite two attribute (hash-and-range) primary key. Single attribute primary keys have one index value: a HashKeyElement. A composite hash-and-range primary key contains two attribute values: a HashKeyElement and a RangeKeyElement.

        • HashKeyElement — required — (map)

          A hash key element is treated as the primary key, and can be a string or a number. Single attribute primary keys have one index value. The value can be String, Number, StringSet, NumberSet.

          • AttributeName — required — (String)

            The AttributeName of the KeySchemaElement.

          • AttributeType — required — (String)

            The AttributeType of the KeySchemaElement which can be a String or a Number.

            Possible values include:
            • "S"
            • "N"
            • "B"
        • RangeKeyElement — (map)

          A range key element is treated as a secondary key (used in conjunction with the primary key), and can be a string or a number, and is only used for hash-and-range primary keys. The value can be String, Number, StringSet, NumberSet.

          • AttributeName — required — (String)

            The AttributeName of the KeySchemaElement.

          • AttributeType — required — (String)

            The AttributeType of the KeySchemaElement which can be a String or a Number.

            Possible values include:
            • "S"
            • "N"
            • "B"
      • TableStatus — (String) Possible values include:
        • "CREATING"
        • "UPDATING"
        • "DELETING"
        • "ACTIVE"
      • CreationDateTime — (Date)
      • ProvisionedThroughput — (map)
        • LastIncreaseDateTime — (Date)
        • LastDecreaseDateTime — (Date)
        • NumberOfDecreasesToday — (Integer)
        • ReadCapacityUnits — (Integer)
        • WriteCapacityUnits — (Integer)
      • TableSizeBytes — (Integer)
      • ItemCount — (Integer)

Returns:

• (AWS.Request) —

  a handle to the operation request for subsequent event callback registration.

var params = {
  TableName: 'STRING_VALUE' /* required */
};
dynamodb.describeTable(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

• params (Object) (defaults to: {}) —
  • TableName — (String)

    The name of the table you want to describe. Allowed characters are a-z, A-Z, 0-9, _ (underscore), - (hyphen) and . (period).

Callback (callback):

• function(err, data) { ... }

  Called when a response from the service is returned. If a callback is not supplied, you must call AWS.Request.send() on the returned request object to initiate the request.

  Context (this):

  • (AWS.Response) —

    the response object containing error, data properties, and the original request object.

  Parameters:

  • err (Error) —

    the error object returned from the request. Set to null if the request is successful.

  • data (Object) —

    the de-serialized data returned from the request. Set to null if a request error occurs. The data object has the following properties:

    • Table — (map)
      • TableName — (String)

        The name of the table being described.

      • KeySchema — (map)

        The KeySchema identifies the primary key as a one attribute primary key (hash) or a composite two attribute (hash-and-range) primary key. Single attribute primary keys have one index value: a HashKeyElement. A composite hash-and-range primary key contains two attribute values: a HashKeyElement and a RangeKeyElement.

        • HashKeyElement — required — (map)

          A hash key element is treated as the primary key, and can be a string or a number. Single attribute primary keys have one index value. The value can be String, Number, StringSet, NumberSet.

          • AttributeName — required — (String)

            The AttributeName of the KeySchemaElement.

          • AttributeType — required — (String)

            The AttributeType of the KeySchemaElement which can be a String or a Number.

            Possible values include:
            • "S"
            • "N"
            • "B"
        • RangeKeyElement — (map)

          A range key element is treated as a secondary key (used in conjunction with the primary key), and can be a string or a number, and is only used for hash-and-range primary keys. The value can be String, Number, StringSet, NumberSet.

          • AttributeName — required — (String)

            The AttributeName of the KeySchemaElement.

          • AttributeType — required — (String)

            The AttributeType of the KeySchemaElement which can be a String or a Number.

            Possible values include:
            • "S"
            • "N"
            • "B"
      • TableStatus — (String) Possible values include:
        • "CREATING"
        • "UPDATING"
        • "DELETING"
        • "ACTIVE"
      • CreationDateTime — (Date)
      • ProvisionedThroughput — (map)
        • LastIncreaseDateTime — (Date)
        • LastDecreaseDateTime — (Date)
        • NumberOfDecreasesToday — (Integer)
        • ReadCapacityUnits — (Integer)
        • WriteCapacityUnits — (Integer)
      • TableSizeBytes — (Integer)
      • ItemCount — (Integer)

Returns:

• (AWS.Request) —

  a handle to the operation request for subsequent event callback registration.

Waiter Resource States:

• tableExists

• tableNotExists

var params = {
  Key: { /* required */
    HashKeyElement: { /* required */
      B: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
      BS: [
        Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
        /* more items */
      ],
      N: 'STRING_VALUE',
      NS: [
        'STRING_VALUE',
        /* more items */
      ],
      S: 'STRING_VALUE',
      SS: [
        'STRING_VALUE',
        /* more items */
      ]
    },
    RangeKeyElement: {
      B: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
      BS: [
        Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
        /* more items */
      ],
      N: 'STRING_VALUE',
      NS: [
        'STRING_VALUE',
        /* more items */
      ],
      S: 'STRING_VALUE',
      SS: [
        'STRING_VALUE',
        /* more items */
      ]
    }
  },
  TableName: 'STRING_VALUE', /* required */
  AttributesToGet: [
    'STRING_VALUE',
    /* more items */
  ],
  ConsistentRead: true || false
};
dynamodb.getItem(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

• params (Object) (defaults to: {}) —
  • TableName — (String)

    The name of the table in which you want to get an item. Allowed characters are a-z, A-Z, 0-9, _ (underscore), - (hyphen) and . (period).

  • Key — (map)

    The primary key that uniquely identifies each item in a table. A primary key can be a one attribute (hash) primary key or a two attribute (hash-and-range) primary key.

    • HashKeyElement — required — (map)

      A hash key element is treated as the primary key, and can be a string or a number. Single attribute primary keys have one index value. The value can be String, Number, StringSet, NumberSet.

      • S — (String)

        Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

      • N — (String)

        Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

      • B — (Buffer, Typed Array, Blob, String)

        Binary attributes are sequences of unsigned bytes.

      • SS — (Array<String>)

        A set of strings.

      • NS — (Array<String>)

        A set of numbers.

      • BS — (Array<Buffer, Typed Array, Blob, String>)

        A set of binary attributes.

    • RangeKeyElement — (map)

      A range key element is treated as a secondary key (used in conjunction with the primary key), and can be a string or a number, and is only used for hash-and-range primary keys. The value can be String, Number, StringSet, NumberSet.

      • S — (String)

        Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

      • N — (String)

        Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

      • B — (Buffer, Typed Array, Blob, String)

        Binary attributes are sequences of unsigned bytes.

      • SS — (Array<String>)

        A set of strings.

      • NS — (Array<String>)

        A set of numbers.

      • BS — (Array<Buffer, Typed Array, Blob, String>)

        A set of binary attributes.

  • AttributesToGet — (Array<String>)

    List of Attribute names. If attribute names are not specified then all attributes will be returned. If some attributes are not found, they will not appear in the result.

  • ConsistentRead — (Boolean)

    If set to true, then a consistent read is issued. Otherwise eventually-consistent is used.

Callback (callback):

• function(err, data) { ... }

  Called when a response from the service is returned. If a callback is not supplied, you must call AWS.Request.send() on the returned request object to initiate the request.

  Context (this):

  • (AWS.Response) —

    the response object containing error, data properties, and the original request object.

  Parameters:

  • err (Error) —

    the error object returned from the request. Set to null if the request is successful.

  • data (Object) —

    the de-serialized data returned from the request. Set to null if a request error occurs. The data object has the following properties:

    • Item — (map<map>)

      Contains the requested attributes.

      • S — (String)

        Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

      • N — (String)

        Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

      • B — (Buffer, Typed Array, Blob, String)

        Binary attributes are sequences of unsigned bytes.

      • SS — (Array<String>)

        A set of strings.

      • NS — (Array<String>)

        A set of numbers.

      • BS — (Array<Buffer, Typed Array, Blob, String>)

        A set of binary attributes.

    • ConsumedCapacityUnits — (Float)

      The number of Capacity Units of the provisioned throughput of the table consumed during the operation. GetItem, BatchGetItem, BatchWriteItem, Query, and Scan operations consume ReadCapacityUnits, while PutItem, UpdateItem, and DeleteItem operations consume WriteCapacityUnits.

Returns:

• (AWS.Request) —

  a handle to the operation request for subsequent event callback registration.

var params = {
  ExclusiveStartTableName: 'STRING_VALUE',
  Limit: 'NUMBER_VALUE'
};
dynamodb.listTables(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

• params (Object) (defaults to: {}) —
  • ExclusiveStartTableName — (String)

    The name of the table that starts the list. If you already ran a ListTables operation and received a LastEvaluatedTableName value in the response, use that value here to continue the list.

  • Limit — (Integer)

    A number of maximum table names to return.

Callback (callback):

• function(err, data) { ... }

  Called when a response from the service is returned. If a callback is not supplied, you must call AWS.Request.send() on the returned request object to initiate the request.

  Context (this):

  • (AWS.Response) —

    the response object containing error, data properties, and the original request object.

  Parameters:

  • err (Error) —

    the error object returned from the request. Set to null if the request is successful.

  • data (Object) —

    the de-serialized data returned from the request. Set to null if a request error occurs. The data object has the following properties:

    • TableNames — (Array<String>)
    • LastEvaluatedTableName — (String)

      The name of the last table in the current list. Use this value as the ExclusiveStartTableName in a new request to continue the list until all the table names are returned. If this value is null, all table names have been returned.

Returns:

• (AWS.Request) —

  a handle to the operation request for subsequent event callback registration.

var params = {
  Item: { /* required */
    '<AttributeName>': {
      B: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
      BS: [
        Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
        /* more items */
      ],
      N: 'STRING_VALUE',
      NS: [
        'STRING_VALUE',
        /* more items */
      ],
      S: 'STRING_VALUE',
      SS: [
        'STRING_VALUE',
        /* more items */
      ]
    },
    /* '<AttributeName>': ... */
  },
  TableName: 'STRING_VALUE', /* required */
  Expected: {
    '<AttributeName>': {
      Exists: true || false,
      Value: {
        B: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
        BS: [
          Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
          /* more items */
        ],
        N: 'STRING_VALUE',
        NS: [
          'STRING_VALUE',
          /* more items */
        ],
        S: 'STRING_VALUE',
        SS: [
          'STRING_VALUE',
          /* more items */
        ]
      }
    },
    /* '<AttributeName>': ... */
  },
  ReturnValues: NONE | ALL_OLD | UPDATED_OLD | ALL_NEW | UPDATED_NEW
};
dynamodb.putItem(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

• params (Object) (defaults to: {}) —
  • TableName — (String)

    The name of the table in which you want to put an item. Allowed characters are a-z, A-Z, 0-9, _ (underscore), - (hyphen) and . (period).

  • Item — (map<map>)

    A map of the attributes for the item, and must include the primary key values that define the item. Other attribute name-value pairs can be provided for the item.

    • S — (String)

      Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

    • N — (String)

      Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

    • B — (Buffer, Typed Array, Blob, String)

      Binary attributes are sequences of unsigned bytes.

    • SS — (Array<String>)

      A set of strings.

    • NS — (Array<String>)

      A set of numbers.

    • BS — (Array<Buffer, Typed Array, Blob, String>)

      A set of binary attributes.

  • Expected — (map<map>)

    Designates an attribute for a conditional modification. The Expected parameter allows you to provide an attribute name, and whether or not Amazon DynamoDB should check to see if the attribute has a particular value before modifying it.

    • Value — (map)

      Specify whether or not a value already exists and has a specific content for the attribute name-value pair.

      • S — (String)

        Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

      • N — (String)

        Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

      • B — (Buffer, Typed Array, Blob, String)

        Binary attributes are sequences of unsigned bytes.

      • SS — (Array<String>)

        A set of strings.

      • NS — (Array<String>)

        A set of numbers.

      • BS — (Array<Buffer, Typed Array, Blob, String>)

        A set of binary attributes.

    • Exists — (Boolean)

      Specify whether or not a value already exists for the attribute name-value pair.

  • ReturnValues — (String)

    Use this parameter if you want to get the attribute name-value pairs before or after they are modified. For PUT operations, the possible parameter values are NONE (default) or ALL_OLD. For update operations, the possible parameter values are NONE (default) or ALL_OLD, UPDATED_OLD, ALL_NEW or UPDATED_NEW.

    • NONE: Nothing is returned.
    • ALL_OLD: Returns the attributes of the item as they were before the operation.
    • UPDATED_OLD: Returns the values of the updated attributes, only, as they were before the operation.
    • ALL_NEW: Returns all the attributes and their new values after the operation.
    • UPDATED_NEW: Returns the values of the updated attributes, only, as they are after the operation.
    Possible values include:
    • "NONE"
    • "ALL_OLD"
    • "UPDATED_OLD"
    • "ALL_NEW"
    • "UPDATED_NEW"

Callback (callback):

• function(err, data) { ... }

  Called when a response from the service is returned. If a callback is not supplied, you must call AWS.Request.send() on the returned request object to initiate the request.

  Context (this):

  • (AWS.Response) —

    the response object containing error, data properties, and the original request object.

  Parameters:

  • err (Error) —

    the error object returned from the request. Set to null if the request is successful.

  • data (Object) —

    the de-serialized data returned from the request. Set to null if a request error occurs. The data object has the following properties:

    • Attributes — (map<map>)

      Attribute values before the put operation, but only if the ReturnValues parameter is specified as ALL_OLD in the request.

      • S — (String)

        Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

      • N — (String)

        Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

      • B — (Buffer, Typed Array, Blob, String)

        Binary attributes are sequences of unsigned bytes.

      • SS — (Array<String>)

        A set of strings.

      • NS — (Array<String>)

        A set of numbers.

      • BS — (Array<Buffer, Typed Array, Blob, String>)

        A set of binary attributes.

    • ConsumedCapacityUnits — (Float)

      The number of Capacity Units of the provisioned throughput of the table consumed during the operation. GetItem, BatchGetItem, BatchWriteItem, Query, and Scan operations consume ReadCapacityUnits, while PutItem, UpdateItem, and DeleteItem operations consume WriteCapacityUnits.

Returns:

• (AWS.Request) —

  a handle to the operation request for subsequent event callback registration.

var params = {
  HashKeyValue: { /* required */
    B: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
    BS: [
      Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
      /* more items */
    ],
    N: 'STRING_VALUE',
    NS: [
      'STRING_VALUE',
      /* more items */
    ],
    S: 'STRING_VALUE',
    SS: [
      'STRING_VALUE',
      /* more items */
    ]
  },
  TableName: 'STRING_VALUE', /* required */
  AttributesToGet: [
    'STRING_VALUE',
    /* more items */
  ],
  ConsistentRead: true || false,
  Count: true || false,
  ExclusiveStartKey: {
    HashKeyElement: { /* required */
      B: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
      BS: [
        Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
        /* more items */
      ],
      N: 'STRING_VALUE',
      NS: [
        'STRING_VALUE',
        /* more items */
      ],
      S: 'STRING_VALUE',
      SS: [
        'STRING_VALUE',
        /* more items */
      ]
    },
    RangeKeyElement: {
      B: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
      BS: [
        Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
        /* more items */
      ],
      N: 'STRING_VALUE',
      NS: [
        'STRING_VALUE',
        /* more items */
      ],
      S: 'STRING_VALUE',
      SS: [
        'STRING_VALUE',
        /* more items */
      ]
    }
  },
  Limit: 'NUMBER_VALUE',
  RangeKeyCondition: {
    ComparisonOperator: EQ | NE | IN | LE | LT | GE | GT | BETWEEN | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH, /* required */
    AttributeValueList: [
      {
        B: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
        BS: [
          Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
          /* more items */
        ],
        N: 'STRING_VALUE',
        NS: [
          'STRING_VALUE',
          /* more items */
        ],
        S: 'STRING_VALUE',
        SS: [
          'STRING_VALUE',
          /* more items */
        ]
      },
      /* more items */
    ]
  },
  ScanIndexForward: true || false
};
dynamodb.query(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

• params (Object) (defaults to: {}) —
  • TableName — (String)

    The name of the table in which you want to query. Allowed characters are a-z, A-Z, 0-9, _ (underscore), - (hyphen) and . (period).

  • AttributesToGet — (Array<String>)

    List of Attribute names. If attribute names are not specified then all attributes will be returned. If some attributes are not found, they will not appear in the result.

  • Limit — (Integer)

    The maximum number of items to return. If Amazon DynamoDB hits this limit while querying the table, it stops the query and returns the matching values up to the limit, and a LastEvaluatedKey to apply in a subsequent operation to continue the query. Also, if the result set size exceeds 1MB before Amazon DynamoDB hits this limit, it stops the query and returns the matching values, and a LastEvaluatedKey to apply in a subsequent operation to continue the query.

  • ConsistentRead — (Boolean)

    If set to true, then a consistent read is issued. Otherwise eventually-consistent is used.

  • Count — (Boolean)

    If set to true, Amazon DynamoDB returns a total number of items that match the query parameters, instead of a list of the matching items and their attributes. Do not set Count to true while providing a list of AttributesToGet, otherwise Amazon DynamoDB returns a validation error.

  • HashKeyValue — (map)

    Attribute value of the hash component of the composite primary key.

    • S — (String)

      Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

    • N — (String)

      Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

    • B — (Buffer, Typed Array, Blob, String)

      Binary attributes are sequences of unsigned bytes.

    • SS — (Array<String>)

      A set of strings.

    • NS — (Array<String>)

      A set of numbers.

    • BS — (Array<Buffer, Typed Array, Blob, String>)

      A set of binary attributes.

  • RangeKeyCondition — (map)

    A container for the attribute values and comparison operators to use for the query.

    • AttributeValueList — (Array<map>)

      A list of attribute values to be used with a comparison operator for a scan or query operation. For comparisons that require more than one value, such as a BETWEEN comparison, the AttributeValueList contains two attribute values and the comparison operator.

      • S — (String)

        Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

      • N — (String)

        Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

      • B — (Buffer, Typed Array, Blob, String)

        Binary attributes are sequences of unsigned bytes.

      • SS — (Array<String>)

        A set of strings.

      • NS — (Array<String>)

        A set of numbers.

      • BS — (Array<Buffer, Typed Array, Blob, String>)

        A set of binary attributes.

    • ComparisonOperator — required — (String)

      A comparison operator is an enumeration of several operations:

      • EQ for equal.
      • NE for not equal.
      • IN checks for exact matches.
      • LE for less than or equal to.
      • LT for less than.
      • GE for greater than or equal to.
      • GT for greater than.
      • BETWEEN for between.
      • NOT_NULL for exists.
      • NULL for not exists.
      • CONTAINS for substring or value in a set.
      • NOT_CONTAINS for absence of a substring or absence of a value in a set.
      • BEGINS_WITH for a substring prefix.

      Scan operations support all available comparison operators.

      Query operations support a subset of the available comparison operators: EQ, LE, LT, GE, GT, BETWEEN, and BEGINS_WITH.

      Possible values include:
      • "EQ"
      • "NE"
      • "IN"
      • "LE"
      • "LT"
      • "GE"
      • "GT"
      • "BETWEEN"
      • "NOT_NULL"
      • "NULL"
      • "CONTAINS"
      • "NOT_CONTAINS"
      • "BEGINS_WITH"
  • ScanIndexForward — (Boolean)

    Specifies forward or backward traversal of the index. Amazon DynamoDB returns results reflecting the requested order, determined by the range key. The default value is true (forward).

  • ExclusiveStartKey — (map)

    Primary key of the item from which to continue an earlier query. An earlier query might provide this value as the LastEvaluatedKey if that query operation was interrupted before completing the query; either because of the result set size or the Limit parameter. The LastEvaluatedKey can be passed back in a new query request to continue the operation from that point.

    • HashKeyElement — required — (map)

      A hash key element is treated as the primary key, and can be a string or a number. Single attribute primary keys have one index value. The value can be String, Number, StringSet, NumberSet.

      • S — (String)

        Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

      • N — (String)

        Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

      • B — (Buffer, Typed Array, Blob, String)

        Binary attributes are sequences of unsigned bytes.

      • SS — (Array<String>)

        A set of strings.

      • NS — (Array<String>)

        A set of numbers.

      • BS — (Array<Buffer, Typed Array, Blob, String>)

        A set of binary attributes.

    • RangeKeyElement — (map)

      A range key element is treated as a secondary key (used in conjunction with the primary key), and can be a string or a number, and is only used for hash-and-range primary keys. The value can be String, Number, StringSet, NumberSet.

      • S — (String)

        Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

      • N — (String)

        Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

      • B — (Buffer, Typed Array, Blob, String)

        Binary attributes are sequences of unsigned bytes.

      • SS — (Array<String>)

        A set of strings.

      • NS — (Array<String>)

        A set of numbers.

      • BS — (Array<Buffer, Typed Array, Blob, String>)

        A set of binary attributes.

Callback (callback):

• function(err, data) { ... }

  Called when a response from the service is returned. If a callback is not supplied, you must call AWS.Request.send() on the returned request object to initiate the request.

  Context (this):

  • (AWS.Response) —

    the response object containing error, data properties, and the original request object.

  Parameters:

  • err (Error) —

    the error object returned from the request. Set to null if the request is successful.

  • data (Object) —

    the de-serialized data returned from the request. Set to null if a request error occurs. The data object has the following properties:

    • Items — (Array<map<map>>)
      • S — (String)

        Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

      • N — (String)

        Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

      • B — (Buffer, Typed Array, Blob, String)

        Binary attributes are sequences of unsigned bytes.

      • SS — (Array<String>)

        A set of strings.

      • NS — (Array<String>)

        A set of numbers.

      • BS — (Array<Buffer, Typed Array, Blob, String>)

        A set of binary attributes.

    • Count — (Integer)

      Number of items in the response.

    • LastEvaluatedKey — (map)

      Primary key of the item where the query operation stopped, inclusive of the previous result set. Use this value to start a new operation excluding this value in the new request. The LastEvaluatedKey is null when the entire query result set is complete (i.e. the operation processed the "last page").

      • HashKeyElement — required — (map)

        A hash key element is treated as the primary key, and can be a string or a number. Single attribute primary keys have one index value. The value can be String, Number, StringSet, NumberSet.

        • S — (String)

          Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

        • N — (String)

          Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

        • B — (Buffer, Typed Array, Blob, String)

          Binary attributes are sequences of unsigned bytes.

        • SS — (Array<String>)

          A set of strings.

        • NS — (Array<String>)

          A set of numbers.

        • BS — (Array<Buffer, Typed Array, Blob, String>)

          A set of binary attributes.

      • RangeKeyElement — (map)

        A range key element is treated as a secondary key (used in conjunction with the primary key), and can be a string or a number, and is only used for hash-and-range primary keys. The value can be String, Number, StringSet, NumberSet.

        • S — (String)

          Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

        • N — (String)

          Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

        • B — (Buffer, Typed Array, Blob, String)

          Binary attributes are sequences of unsigned bytes.

        • SS — (Array<String>)

          A set of strings.

        • NS — (Array<String>)

          A set of numbers.

        • BS — (Array<Buffer, Typed Array, Blob, String>)

          A set of binary attributes.

    • ConsumedCapacityUnits — (Float)

      The number of Capacity Units of the provisioned throughput of the table consumed during the operation. GetItem, BatchGetItem, BatchWriteItem, Query, and Scan operations consume ReadCapacityUnits, while PutItem, UpdateItem, and DeleteItem operations consume WriteCapacityUnits.

Returns:

• (AWS.Request) —

  a handle to the operation request for subsequent event callback registration.

var params = {
  TableName: 'STRING_VALUE', /* required */
  AttributesToGet: [
    'STRING_VALUE',
    /* more items */
  ],
  Count: true || false,
  ExclusiveStartKey: {
    HashKeyElement: { /* required */
      B: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
      BS: [
        Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
        /* more items */
      ],
      N: 'STRING_VALUE',
      NS: [
        'STRING_VALUE',
        /* more items */
      ],
      S: 'STRING_VALUE',
      SS: [
        'STRING_VALUE',
        /* more items */
      ]
    },
    RangeKeyElement: {
      B: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
      BS: [
        Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
        /* more items */
      ],
      N: 'STRING_VALUE',
      NS: [
        'STRING_VALUE',
        /* more items */
      ],
      S: 'STRING_VALUE',
      SS: [
        'STRING_VALUE',
        /* more items */
      ]
    }
  },
  Limit: 'NUMBER_VALUE',
  ScanFilter: {
    '<String>': {
      ComparisonOperator: EQ | NE | IN | LE | LT | GE | GT | BETWEEN | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH, /* required */
      AttributeValueList: [
        {
          B: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
          BS: [
            Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
            /* more items */
          ],
          N: 'STRING_VALUE',
          NS: [
            'STRING_VALUE',
            /* more items */
          ],
          S: 'STRING_VALUE',
          SS: [
            'STRING_VALUE',
            /* more items */
          ]
        },
        /* more items */
      ]
    },
    /* '<String>': ... */
  }
};
dynamodb.scan(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

• params (Object) (defaults to: {}) —
  • TableName — (String)

    The name of the table in which you want to scan. Allowed characters are a-z, A-Z, 0-9, _ (underscore), - (hyphen) and . (period).

  • AttributesToGet — (Array<String>)

    List of Attribute names. If attribute names are not specified then all attributes will be returned. If some attributes are not found, they will not appear in the result.

  • Limit — (Integer)

    The maximum number of items to return. If Amazon DynamoDB hits this limit while scanning the table, it stops the scan and returns the matching values up to the limit, and a LastEvaluatedKey to apply in a subsequent operation to continue the scan. Also, if the scanned data set size exceeds 1 MB before Amazon DynamoDB hits this limit, it stops the scan and returns the matching values up to the limit, and a LastEvaluatedKey to apply in a subsequent operation to continue the scan.

  • Count — (Boolean)

    If set to true, Amazon DynamoDB returns a total number of items for the Scan operation, even if the operation has no matching items for the assigned filter. Do not set Count to true while providing a list of AttributesToGet, otherwise Amazon DynamoDB returns a validation error.

  • ScanFilter — (map<map>)

    Evaluates the scan results and returns only the desired values.

    • AttributeValueList — (Array<map>)

      A list of attribute values to be used with a comparison operator for a scan or query operation. For comparisons that require more than one value, such as a BETWEEN comparison, the AttributeValueList contains two attribute values and the comparison operator.

      • S — (String)

        Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

      • N — (String)

        Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

      • B — (Buffer, Typed Array, Blob, String)

        Binary attributes are sequences of unsigned bytes.

      • SS — (Array<String>)

        A set of strings.

      • NS — (Array<String>)

        A set of numbers.

      • BS — (Array<Buffer, Typed Array, Blob, String>)

        A set of binary attributes.

    • ComparisonOperator — required — (String)

      A comparison operator is an enumeration of several operations:

      • EQ for equal.
      • NE for not equal.
      • IN checks for exact matches.
      • LE for less than or equal to.
      • LT for less than.
      • GE for greater than or equal to.
      • GT for greater than.
      • BETWEEN for between.
      • NOT_NULL for exists.
      • NULL for not exists.
      • CONTAINS for substring or value in a set.
      • NOT_CONTAINS for absence of a substring or absence of a value in a set.
      • BEGINS_WITH for a substring prefix.

      Scan operations support all available comparison operators.

      Query operations support a subset of the available comparison operators: EQ, LE, LT, GE, GT, BETWEEN, and BEGINS_WITH.

      Possible values include:
      • "EQ"
      • "NE"
      • "IN"
      • "LE"
      • "LT"
      • "GE"
      • "GT"
      • "BETWEEN"
      • "NOT_NULL"
      • "NULL"
      • "CONTAINS"
      • "NOT_CONTAINS"
      • "BEGINS_WITH"
  • ExclusiveStartKey — (map)

    Primary key of the item from which to continue an earlier scan. An earlier scan might provide this value if that scan operation was interrupted before scanning the entire table; either because of the result set size or the Limit parameter. The LastEvaluatedKey can be passed back in a new scan request to continue the operation from that point.

    • HashKeyElement — required — (map)

      A hash key element is treated as the primary key, and can be a string or a number. Single attribute primary keys have one index value. The value can be String, Number, StringSet, NumberSet.

      • S — (String)

        Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

      • N — (String)

        Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

      • B — (Buffer, Typed Array, Blob, String)

        Binary attributes are sequences of unsigned bytes.

      • SS — (Array<String>)

        A set of strings.

      • NS — (Array<String>)

        A set of numbers.

      • BS — (Array<Buffer, Typed Array, Blob, String>)

        A set of binary attributes.

    • RangeKeyElement — (map)

      A range key element is treated as a secondary key (used in conjunction with the primary key), and can be a string or a number, and is only used for hash-and-range primary keys. The value can be String, Number, StringSet, NumberSet.

      • S — (String)

        Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

      • N — (String)

        Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

      • B — (Buffer, Typed Array, Blob, String)

        Binary attributes are sequences of unsigned bytes.

      • SS — (Array<String>)

        A set of strings.

      • NS — (Array<String>)

        A set of numbers.

      • BS — (Array<Buffer, Typed Array, Blob, String>)

        A set of binary attributes.

Callback (callback):

• function(err, data) { ... }

  Called when a response from the service is returned. If a callback is not supplied, you must call AWS.Request.send() on the returned request object to initiate the request.

  Context (this):

  • (AWS.Response) —

    the response object containing error, data properties, and the original request object.

  Parameters:

  • err (Error) —

    the error object returned from the request. Set to null if the request is successful.

  • data (Object) —

    the de-serialized data returned from the request. Set to null if a request error occurs. The data object has the following properties:

    • Items — (Array<map<map>>)
      • S — (String)

        Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

      • N — (String)

        Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

      • B — (Buffer, Typed Array, Blob, String)

        Binary attributes are sequences of unsigned bytes.

      • SS — (Array<String>)

        A set of strings.

      • NS — (Array<String>)

        A set of numbers.

      • BS — (Array<Buffer, Typed Array, Blob, String>)

        A set of binary attributes.

    • Count — (Integer)

      Number of items in the response.

    • ScannedCount — (Integer)

      Number of items in the complete scan before any filters are applied. A high ScannedCount value with few, or no, Count results indicates an inefficient Scan operation.

    • LastEvaluatedKey — (map)

      Primary key of the item where the scan operation stopped. Provide this value in a subsequent scan operation to continue the operation from that point. The LastEvaluatedKey is null when the entire scan result set is complete (i.e. the operation processed the "last page").

      • HashKeyElement — required — (map)

        A hash key element is treated as the primary key, and can be a string or a number. Single attribute primary keys have one index value. The value can be String, Number, StringSet, NumberSet.

        • S — (String)

          Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

        • N — (String)

          Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

        • B — (Buffer, Typed Array, Blob, String)

          Binary attributes are sequences of unsigned bytes.

        • SS — (Array<String>)

          A set of strings.

        • NS — (Array<String>)

          A set of numbers.

        • BS — (Array<Buffer, Typed Array, Blob, String>)

          A set of binary attributes.

      • RangeKeyElement — (map)

        A range key element is treated as a secondary key (used in conjunction with the primary key), and can be a string or a number, and is only used for hash-and-range primary keys. The value can be String, Number, StringSet, NumberSet.

        • S — (String)

          Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

        • N — (String)

          Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

        • B — (Buffer, Typed Array, Blob, String)

          Binary attributes are sequences of unsigned bytes.

        • SS — (Array<String>)

          A set of strings.

        • NS — (Array<String>)

          A set of numbers.

        • BS — (Array<Buffer, Typed Array, Blob, String>)

          A set of binary attributes.

    • ConsumedCapacityUnits — (Float)

      The number of Capacity Units of the provisioned throughput of the table consumed during the operation. GetItem, BatchGetItem, BatchWriteItem, Query, and Scan operations consume ReadCapacityUnits, while PutItem, UpdateItem, and DeleteItem operations consume WriteCapacityUnits.

Returns:

• (AWS.Request) —

  a handle to the operation request for subsequent event callback registration.

var params = {
  AttributeUpdates: { /* required */
    '<AttributeName>': {
      Action: ADD | PUT | DELETE,
      Value: {
        B: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
        BS: [
          Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
          /* more items */
        ],
        N: 'STRING_VALUE',
        NS: [
          'STRING_VALUE',
          /* more items */
        ],
        S: 'STRING_VALUE',
        SS: [
          'STRING_VALUE',
          /* more items */
        ]
      }
    },
    /* '<AttributeName>': ... */
  },
  Key: { /* required */
    HashKeyElement: { /* required */
      B: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
      BS: [
        Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
        /* more items */
      ],
      N: 'STRING_VALUE',
      NS: [
        'STRING_VALUE',
        /* more items */
      ],
      S: 'STRING_VALUE',
      SS: [
        'STRING_VALUE',
        /* more items */
      ]
    },
    RangeKeyElement: {
      B: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
      BS: [
        Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
        /* more items */
      ],
      N: 'STRING_VALUE',
      NS: [
        'STRING_VALUE',
        /* more items */
      ],
      S: 'STRING_VALUE',
      SS: [
        'STRING_VALUE',
        /* more items */
      ]
    }
  },
  TableName: 'STRING_VALUE', /* required */
  Expected: {
    '<AttributeName>': {
      Exists: true || false,
      Value: {
        B: Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
        BS: [
          Buffer.from('...') || 'STRING_VALUE' /* Strings will be Base-64 encoded on your behalf */,
          /* more items */
        ],
        N: 'STRING_VALUE',
        NS: [
          'STRING_VALUE',
          /* more items */
        ],
        S: 'STRING_VALUE',
        SS: [
          'STRING_VALUE',
          /* more items */
        ]
      }
    },
    /* '<AttributeName>': ... */
  },
  ReturnValues: NONE | ALL_OLD | UPDATED_OLD | ALL_NEW | UPDATED_NEW
};
dynamodb.updateItem(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

• params (Object) (defaults to: {}) —
  • TableName — (String)

    The name of the table in which you want to update an item. Allowed characters are a-z, A-Z, 0-9, _ (underscore), - (hyphen) and . (period).

  • Key — (map)

    The primary key that uniquely identifies each item in a table. A primary key can be a one attribute (hash) primary key or a two attribute (hash-and-range) primary key.

    • HashKeyElement — required — (map)

      A hash key element is treated as the primary key, and can be a string or a number. Single attribute primary keys have one index value. The value can be String, Number, StringSet, NumberSet.

      • S — (String)

        Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

      • N — (String)

        Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

      • B — (Buffer, Typed Array, Blob, String)

        Binary attributes are sequences of unsigned bytes.

      • SS — (Array<String>)

        A set of strings.

      • NS — (Array<String>)

        A set of numbers.

      • BS — (Array<Buffer, Typed Array, Blob, String>)

        A set of binary attributes.

    • RangeKeyElement — (map)

      A range key element is treated as a secondary key (used in conjunction with the primary key), and can be a string or a number, and is only used for hash-and-range primary keys. The value can be String, Number, StringSet, NumberSet.

      • S — (String)

        Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

      • N — (String)

        Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

      • B — (Buffer, Typed Array, Blob, String)

        Binary attributes are sequences of unsigned bytes.

      • SS — (Array<String>)

        A set of strings.

      • NS — (Array<String>)

        A set of numbers.

      • BS — (Array<Buffer, Typed Array, Blob, String>)

        A set of binary attributes.

  • AttributeUpdates — (map<map>)

    Map of attribute name to the new value and action for the update. The attribute names specify the attributes to modify, and cannot contain any primary key attributes.

    • Value — (map)

      AttributeValue can be String, Number, Binary, StringSet, NumberSet, BinarySet.

      • S — (String)

        Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

      • N — (String)

        Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

      • B — (Buffer, Typed Array, Blob, String)

        Binary attributes are sequences of unsigned bytes.

      • SS — (Array<String>)

        A set of strings.

      • NS — (Array<String>)

        A set of numbers.

      • BS — (Array<Buffer, Typed Array, Blob, String>)

        A set of binary attributes.

    • Action — (String)

      The type of action for an item update operation. Only use the add action for numbers or sets; the specified value is added to the existing value. If a set of values is specified, the values are added to the existing set. Adds the specified attribute. If the attribute exists, it is replaced by the new value. If no value is specified, this removes the attribute and its value. If a set of values is specified, then the values in the specified set are removed from the old set.

      Possible values include:
      • "ADD"
      • "PUT"
      • "DELETE"
  • Expected — (map<map>)

    Designates an attribute for a conditional modification. The Expected parameter allows you to provide an attribute name, and whether or not Amazon DynamoDB should check to see if the attribute has a particular value before modifying it.

    • Value — (map)

      Specify whether or not a value already exists and has a specific content for the attribute name-value pair.

      • S — (String)

        Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

      • N — (String)

        Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

      • B — (Buffer, Typed Array, Blob, String)

        Binary attributes are sequences of unsigned bytes.

      • SS — (Array<String>)

        A set of strings.

      • NS — (Array<String>)

        A set of numbers.

      • BS — (Array<Buffer, Typed Array, Blob, String>)

        A set of binary attributes.

    • Exists — (Boolean)

      Specify whether or not a value already exists for the attribute name-value pair.

  • ReturnValues — (String)

    Use this parameter if you want to get the attribute name-value pairs before or after they are modified. For PUT operations, the possible parameter values are NONE (default) or ALL_OLD. For update operations, the possible parameter values are NONE (default) or ALL_OLD, UPDATED_OLD, ALL_NEW or UPDATED_NEW.

    • NONE: Nothing is returned.
    • ALL_OLD: Returns the attributes of the item as they were before the operation.
    • UPDATED_OLD: Returns the values of the updated attributes, only, as they were before the operation.
    • ALL_NEW: Returns all the attributes and their new values after the operation.
    • UPDATED_NEW: Returns the values of the updated attributes, only, as they are after the operation.
    Possible values include:
    • "NONE"
    • "ALL_OLD"
    • "UPDATED_OLD"
    • "ALL_NEW"
    • "UPDATED_NEW"

Callback (callback):

• function(err, data) { ... }

  Called when a response from the service is returned. If a callback is not supplied, you must call AWS.Request.send() on the returned request object to initiate the request.

  Context (this):

  • (AWS.Response) —

    the response object containing error, data properties, and the original request object.

  Parameters:

  • err (Error) —

    the error object returned from the request. Set to null if the request is successful.

  • data (Object) —

    the de-serialized data returned from the request. Set to null if a request error occurs. The data object has the following properties:

    • Attributes — (map<map>)

      A map of attribute name-value pairs, but only if the ReturnValues parameter is specified as something other than NONE in the request.

      • S — (String)

        Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).

      • N — (String)

        Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.

      • B — (Buffer, Typed Array, Blob, String)

        Binary attributes are sequences of unsigned bytes.

      • SS — (Array<String>)

        A set of strings.

      • NS — (Array<String>)

        A set of numbers.

      • BS — (Array<Buffer, Typed Array, Blob, String>)

        A set of binary attributes.

    • ConsumedCapacityUnits — (Float)

      The number of Capacity Units of the provisioned throughput of the table consumed during the operation. GetItem, BatchGetItem, BatchWriteItem, Query, and Scan operations consume ReadCapacityUnits, while PutItem, UpdateItem, and DeleteItem operations consume WriteCapacityUnits.

Returns:

• (AWS.Request) —

  a handle to the operation request for subsequent event callback registration.

var params = {
  ProvisionedThroughput: { /* required */
    ReadCapacityUnits: 'NUMBER_VALUE', /* required */
    WriteCapacityUnits: 'NUMBER_VALUE' /* required */
  },
  TableName: 'STRING_VALUE' /* required */
};
dynamodb.updateTable(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

• params (Object) (defaults to: {}) —
  • TableName — (String)

    The name of the table you want to update. Allowed characters are a-z, A-Z, 0-9, _ (underscore), - (hyphen) and . (period).

  • ProvisionedThroughput — (map)

    Provisioned throughput reserves the required read and write resources for your table in terms of ReadCapacityUnits and WriteCapacityUnits. Values for provisioned throughput depend upon your expected read/write rates, item size, and consistency. Provide the expected number of read and write operations, assuming an item size of 1k and strictly consistent reads. For 2k item size, double the value. For 3k, triple the value, etc. Eventually-consistent reads consume half the resources of strictly consistent reads.

    • ReadCapacityUnits — required — (Integer)

      ReadCapacityUnits are in terms of strictly consistent reads, assuming items of 1k. 2k items require twice the ReadCapacityUnits. Eventually-consistent reads only require half the ReadCapacityUnits of stirctly consistent reads.

    • WriteCapacityUnits — required — (Integer)

      WriteCapacityUnits are in terms of strictly consistent reads, assuming items of 1k. 2k items require twice the WriteCapacityUnits.

Callback (callback):

• function(err, data) { ... }

  Called when a response from the service is returned. If a callback is not supplied, you must call AWS.Request.send() on the returned request object to initiate the request.

  Context (this):

  • (AWS.Response) —

    the response object containing error, data properties, and the original request object.

  Parameters:

  • err (Error) —

    the error object returned from the request. Set to null if the request is successful.

  • data (Object) —

    the de-serialized data returned from the request. Set to null if a request error occurs. The data object has the following properties:

    • TableDescription — (map)
      • TableName — (String)

        The name of the table being described.

      • KeySchema — (map)

        The KeySchema identifies the primary key as a one attribute primary key (hash) or a composite two attribute (hash-and-range) primary key. Single attribute primary keys have one index value: a HashKeyElement. A composite hash-and-range primary key contains two attribute values: a HashKeyElement and a RangeKeyElement.

        • HashKeyElement — required — (map)

          A hash key element is treated as the primary key, and can be a string or a number. Single attribute primary keys have one index value. The value can be String, Number, StringSet, NumberSet.

          • AttributeName — required — (String)

            The AttributeName of the KeySchemaElement.

          • AttributeType — required — (String)

            The AttributeType of the KeySchemaElement which can be a String or a Number.

            Possible values include:
            • "S"
            • "N"
            • "B"
        • RangeKeyElement — (map)

          A range key element is treated as a secondary key (used in conjunction with the primary key), and can be a string or a number, and is only used for hash-and-range primary keys. The value can be String, Number, StringSet, NumberSet.

          • AttributeName — required — (String)

            The AttributeName of the KeySchemaElement.

          • AttributeType — required — (String)

            The AttributeType of the KeySchemaElement which can be a String or a Number.

            Possible values include:
            • "S"
            • "N"
            • "B"
      • TableStatus — (String) Possible values include:
        • "CREATING"
        • "UPDATING"
        • "DELETING"
        • "ACTIVE"
      • CreationDateTime — (Date)
      • ProvisionedThroughput — (map)
        • LastIncreaseDateTime — (Date)
        • LastDecreaseDateTime — (Date)
        • NumberOfDecreasesToday — (Integer)
        • ReadCapacityUnits — (Integer)
        • WriteCapacityUnits — (Integer)
      • TableSizeBytes — (Integer)
      • ItemCount — (Integer)

Returns:

• (AWS.Request) —

  a handle to the operation request for subsequent event callback registration.

var params = {
  TableName: 'STRING_VALUE' /* required */
};
dynamodb_20111205.waitFor('tableExists', params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Parameters:

• state (String) —

  the resource state to wait for. Available states for this service are listed in "Waiter Resource States" below.

• params (map) (defaults to: {}) —

  a list of parameters for the given state. See each waiter resource state for required parameters.

Callback (callback):

• function(err, data) { ... }

  Callback containing error and data information. See the respective resource state for the expected error or data information.

  If the waiter times out its requests, it will return a ResourceNotReady error.

Returns:

• (AWS.Request) —

  a handle to the operation request for subsequent event callback registration.

Waiter Resource States:

• tableExists

• tableNotExists