README

dynamo GoDoc Circle CI

import "github.com/guregu/dynamo"

dynamo is an expressive DynamoDB client for Go, with an API heavily inspired by mgo. dynamo integrates with the official AWS SDK.

dynamo is still under development, so the API may change rarely. However, breaking changes will be avoided and the API can be considered relatively stable.

Example

package dynamo

import (
	"time"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/guregu/dynamo"
)

// Use struct tags much like the standard JSON library,
// you can embed anonymous structs too!
type widget struct {
	UserID int       // Hash key, a.k.a. partition key
	Time   time.Time // Range key, a.k.a. sort key

	Msg       string              `dynamo:"Message"`
	Count     int                 `dynamo:",omitempty"`
	Friends   []string            `dynamo:",set"` // Sets
	Set       map[string]struct{} `dynamo:",set"` // Map sets, too!
	SecretKey string              `dynamo:"-"`    // Ignored
	Children  []any               // Lists
}


func main() {
	db := dynamo.New(session.New(), &aws.Config{Region: aws.String("us-west-2")})
	table := db.Table("Widgets")
	
	// put item
	w := widget{UserID: 613, Time: time.Now(), Msg: "hello"}
	err := table.Put(w).Run() 
	
	// get the same item 
	var result widget
	err = table.Get("UserID", w.UserID).
		Range("Time", dynamo.Equal, w.Time).
		Filter("'Count' = ? AND $ = ?", w.Count, "Message", w.Msg). // placeholders in expressions
		One(&result)
	
	// get all items
	var results []widget
	err = table.Scan().All(&results)
}

Expressions

dynamo will help you write expressions used to filter results in queries and scans, and add conditions to puts and deletes.

Attribute names may be written as is if it is not a reserved word, or be escaped with single quotes (''). You may also use dollar signs ($) as placeholders for attribute names. DynamoDB has very large amount of reserved words so it may be a good idea to just escape everything.

Question marks (?) are used as placeholders for attribute values. DynamoDB doesn't have value literals, so you need to substitute everything.

Please see the DynamoDB reference on expressions for more information.

// Using single quotes to escape a reserved word, and a question mark as a value placeholder.
// Finds all items whose date is greater than or equal to lastUpdate.
table.Scan().Filter("'Date' >= ?", lastUpdate).All(&results)

// Using dollar signs as a placeholder for attribute names. 
// Deletes the item with an ID of 42 if its score is at or below the cutoff, and its name starts with G.
table.Delete("ID", 42).If("Score <= ? AND begins_with($, ?)", cutoff, "Name", "G").Run()

// Put a new item, only if it doesn't already exist.
table.Put(item{ID: 42}).If("attribute_not_exists(ID)").Run()

Encoding support

dynamo automatically handles the following interfaces:

This allows you to define custom encodings and provides built-in support for types such as time.Time.

Compatibility with the official AWS library

dynamo has been in development before the official AWS libraries were stable. We use a different encoder and decoder than the dynamodbattribute package. dynamo uses the dynamo struct tag instead of the dynamodbav struct tag, and we also prefer to automatically omit invalid values such as empty strings, whereas the dynamodbattribute package substitutes null values for them. Items that satisfy the dynamodbattribute.(Un)marshaler interfaces are compatibile with both libraries.

In order to use dynamodbattribute's encoding facilities, you must wrap objects passed to dynamo with dynamo.AWSEncoding. Here is a quick example:

// Notice the use of the dynamodbav struct tag
type book struct {
	ID    int    `dynamodbav:"id"`
	Title string `dynamodbav:"title"`
}
// Putting an item
err := db.Table("Books").Put(dynamo.AWSEncoding(book{
	ID:    42,
	Title: "Principia Discordia",
})).Run()
// When getting an item you MUST pass a pointer to AWSEncoding!
var someBook book
err := db.Table("Books").Get("ID", 555).One(dynamo.AWSEncoding(&someBook))

Integration tests

By default, tests are run in offline mode. Create a table called TestDB, with a Number Parition Key called UserID and a String Sort Key called Time. Change the table name with the environment variable DYNAMO_TEST_TABLE. You must specify DYNAMO_TEST_REGION, setting it to the AWS region where your test table is.

DYNAMO_TEST_REGION=us-west-2 go test github.com/guregu/dynamo/... -cover

License

BSD

Expand ▾ Collapse ▴

Documentation

Overview

    Package dynamo offers a rich DynamoDB client.

    Index

    Constants

    View Source
    const (
    	BinaryType KeyType = "B"
    	StringType         = "S"
    	NumberType         = "N"
    	NoneType           = ""
    )

      Key types for table and index hash/range keys.

      View Source
      const (
      	Equal          Operator = "EQ"
      	NotEqual                = "NE"
      	Less                    = "LT"
      	LessOrEqual             = "LE"
      	Greater                 = "GT"
      	GreaterOrEqual          = "GE"
      	BeginsWith              = "BEGINS_WITH"
      	Between                 = "BETWEEN"
      )

        Operators used for comparing against the range key in queries.

        View Source
        const (
        	// The table or index is ready for use.
        	ActiveStatus Status = "ACTIVE"
        	// The table or index is being created.
        	CreatingStatus = "CREATING"
        	// The table or index is being updated.
        	UpdatingStatus = "UPDATING"
        	// The table or index is being deleted.
        	DeletingStatus = "DELETING"
        )

        Variables

        View Source
        var (
        	// ErrNotFound is returned when no items could be found in Get or OldValue a and similar operations.
        	ErrNotFound = errors.New("dynamo: no item found")
        	// ErrTooMany is returned when one item was requested, but the query returned multiple items.
        	ErrTooMany = errors.New("dynamo: too many items")
        )
        View Source
        var RetryTimeout = 1 * time.Minute

          RetryTimeout defines the maximum amount of time that requests will attempt to automatically retry for. In other words, this is the maximum amount of time that dynamo operations will block. RetryTimeout is only considered by methods that do not take a context. Higher values are better when using tables with lower throughput.

          Functions

          func Marshal

          func Marshal(v interface{}) (*dynamodb.AttributeValue, error)

            Marshal converts the given value into a DynamoDB attribute value.

            func MarshalItem

            func MarshalItem(v interface{}) (map[string]*dynamodb.AttributeValue, error)

              MarshalItem converts the given struct into a DynamoDB item.

              func Unmarshal

              func Unmarshal(av *dynamodb.AttributeValue, out interface{}) error

                Unmarshal decodes a DynamoDB value into out, which must be a pointer.

                func UnmarshalItem

                func UnmarshalItem(item map[string]*dynamodb.AttributeValue, out interface{}) error

                  Unmarshal decodes a DynamoDB item into out, which must be a pointer.

                  Types

                  type Batch

                  type Batch struct {
                  	// contains filtered or unexported fields
                  }

                    Batch stores the names of the hash key and range key for creating new batches.

                    func (Batch) Get

                    func (b Batch) Get(keys ...Keyed) *BatchGet

                      Get creates a new batch get item request with the given keys.

                      table.Batch("ID", "Month").
                      	Get([]dynamo.Keys{{1, "2015-10"}, {42, "2015-12"}, {42, "1992-02"}}...).
                      	All(&results)
                      

                      func (Batch) Write

                      func (b Batch) Write() *BatchWrite

                        Write creates a new batch write request, to which puts and deletes can be added.

                        type BatchGet

                        type BatchGet struct {
                        	// contains filtered or unexported fields
                        }

                          BatchGet is a BatchGetItem operation.

                          func (*BatchGet) All

                          func (bg *BatchGet) All(out interface{}) error

                            All executes this request and unmarshals all results to out, which must be a pointer to a slice.

                            func (*BatchGet) And

                            func (bg *BatchGet) And(keys ...Keyed) *BatchGet

                              And adds more keys to be gotten.

                              func (*BatchGet) Consistent

                              func (bg *BatchGet) Consistent(on bool) *BatchGet

                                Consistent will, if on is true, make this batch use a strongly consistent read. Reads are eventually consistent by default. Strongly consistent reads are more resource-heavy than eventually consistent reads.

                                func (*BatchGet) ConsumedCapacity

                                func (bg *BatchGet) ConsumedCapacity(cc *ConsumedCapacity) *BatchGet

                                  ConsumedCapacity will measure the throughput capacity consumed by this operation and add it to cc.

                                  func (*BatchGet) Iter

                                  func (bg *BatchGet) Iter() Iter

                                    Iter returns a results iterator for this batch.

                                    type BatchWrite

                                    type BatchWrite struct {
                                    	// contains filtered or unexported fields
                                    }

                                      BatchWrite is a BatchWriteItem operation.

                                      func (*BatchWrite) ConsumedCapacity

                                      func (bw *BatchWrite) ConsumedCapacity(cc *ConsumedCapacity) *BatchWrite

                                        ConsumedCapacity will measure the throughput capacity consumed by this operation and add it to cc.

                                        func (*BatchWrite) Delete

                                        func (bw *BatchWrite) Delete(keys ...Keyed) *BatchWrite

                                          Delete adds delete operations for the given keys to this batch.

                                          func (*BatchWrite) Put

                                          func (bw *BatchWrite) Put(items ...interface{}) *BatchWrite

                                            Put adds put operations for items to this batch.

                                            func (*BatchWrite) Run

                                            func (bw *BatchWrite) Run() (wrote int, err error)

                                              Run executes this batch. For batches with more than 25 operations, an error could indicate that some records have been written and some have not. Consult the wrote return amount to figure out which operations have succeeded.

                                              func (*BatchWrite) RunWithContext

                                              func (bw *BatchWrite) RunWithContext(ctx aws.Context) (wrote int, err error)

                                              type Coder

                                              type Coder interface {
                                              	Marshaler
                                              	Unmarshaler
                                              }

                                              func AWSEncoding

                                              func AWSEncoding(v interface{}) Coder

                                                AWSEncoding wraps an object, forcing it to use AWS's official dynamodbattribute package for encoding and decoding. This allows you to use the "dynamodbav" struct tags. When decoding, v must be a pointer.

                                                type ConsumedCapacity

                                                type ConsumedCapacity struct {
                                                	// Total is the total number of capacity units consumed during this operation.
                                                	Total float64
                                                	// GSI is a map of Global Secondary Index names to consumed capacity units.
                                                	GSI map[string]float64
                                                	// GSI is a map of Local Secondary Index names to consumed capacity units.
                                                	LSI map[string]float64
                                                	// Table is the amount of throughput consumed by the table.
                                                	Table float64
                                                	// TableName is the name of the table affected by this operation.
                                                	TableName string
                                                }

                                                  ConsumedCapacity represents the amount of throughput capacity consumed during an operation.

                                                  type CreateTable

                                                  type CreateTable struct {
                                                  	// contains filtered or unexported fields
                                                  }

                                                    CreateTable is a request to create a new table. See: http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_CreateTable.html

                                                    func (*CreateTable) Index

                                                    func (ct *CreateTable) Index(index Index) *CreateTable

                                                      Index specifies an index to add to this table.

                                                      func (*CreateTable) Project

                                                      func (ct *CreateTable) Project(index string, projection IndexProjection, includeAttribs ...string) *CreateTable

                                                        Project specifies the projection type for the given table. When using IncludeProjection, you must specify the additional attributes to include via includeAttribs.

                                                        func (*CreateTable) Provision

                                                        func (ct *CreateTable) Provision(readUnits, writeUnits int64) *CreateTable

                                                          Provision specifies the provisioned read and write capacity for this table. If Provision isn't called, the table will be created with 1 unit each.

                                                          func (*CreateTable) ProvisionIndex

                                                          func (ct *CreateTable) ProvisionIndex(index string, readUnits, writeUnits int64) *CreateTable

                                                            ProvisionIndex specifies the provisioned read and write capacity for the given global secondary index. Local secondary indices share their capacity with the table.

                                                            func (*CreateTable) Run

                                                            func (ct *CreateTable) Run() error

                                                              Run creates this table or returns and error.

                                                              func (*CreateTable) RunWithContext

                                                              func (ct *CreateTable) RunWithContext(ctx aws.Context) error

                                                              func (*CreateTable) Stream

                                                              func (ct *CreateTable) Stream(view StreamView) *CreateTable

                                                                Stream enables DynamoDB Streams for this table which the specified type of view. Streams are disabled by default.

                                                                type DB

                                                                type DB struct {
                                                                	// contains filtered or unexported fields
                                                                }

                                                                  DB is a DynamoDB client.

                                                                  func New

                                                                  func New(p client.ConfigProvider, cfgs ...*aws.Config) *DB

                                                                    New creates a new client with the given configuration.

                                                                    func NewFromIface

                                                                    func NewFromIface(client dynamodbiface.DynamoDBAPI) *DB

                                                                      NewFromIface creates a new client with the given interface.

                                                                      func (*DB) Client

                                                                      func (db *DB) Client() dynamodbiface.DynamoDBAPI

                                                                        Client returns this DB's internal client used to make API requests.

                                                                        func (*DB) CreateTable

                                                                        func (db *DB) CreateTable(name string, from interface{}) *CreateTable

                                                                          CreateTable begins a new operation to create a table with the given name. The second parameter must be a struct with appropriate hash and range key struct tags for the primary key and all indices.

                                                                          An example of a from struct follows:

                                                                          type UserAction struct {
                                                                          	UserID string    `dynamo:"ID,hash" index:"Seq-ID-index,range"`
                                                                          	Time   time.Time `dynamo:",range"`
                                                                          	Seq    int64     `localIndex:"ID-Seq-index,range" index:"Seq-ID-index,hash"`
                                                                          	UUID   string    `index:"UUID-index,hash"`
                                                                          }
                                                                          

                                                                          This creates a table with the primary hash key ID and range key Time. It creates two global secondary indices called UUID-index and Seq-ID-index, and a local secondary index called ID-Seq-index.

                                                                          func (*DB) ListTables

                                                                          func (db *DB) ListTables() *ListTables

                                                                            ListTables begins a new request to list all tables.

                                                                            func (*DB) Table

                                                                            func (db *DB) Table(name string) Table

                                                                              Table returns a Table handle specified by name.

                                                                              type Delete

                                                                              type Delete struct {
                                                                              	// contains filtered or unexported fields
                                                                              }

                                                                                Delete is a request to delete an item. See: http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DeleteItem.html

                                                                                func (*Delete) ConsumedCapacity

                                                                                func (d *Delete) ConsumedCapacity(cc *ConsumedCapacity) *Delete

                                                                                  ConsumedCapacity will measure the throughput capacity consumed by this operation and add it to cc.

                                                                                  func (*Delete) If

                                                                                  func (d *Delete) If(expr string, args ...interface{}) *Delete

                                                                                    If specifies a conditional expression for this delete to succeed. Use single quotes to specificy reserved names inline (like 'Count'). Use the placeholder ? within the expression to substitute values, and use $ for names. You need to use quoted or placeholder names when the name is a reserved word in DynamoDB.

                                                                                    func (*Delete) OldValue

                                                                                    func (d *Delete) OldValue(out interface{}) error

                                                                                      OldValue executes this delete request, unmarshaling the previous value to out. Returns ErrNotFound is there was no previous value.

                                                                                      func (*Delete) OldValueWithContext

                                                                                      func (d *Delete) OldValueWithContext(ctx aws.Context, out interface{}) error

                                                                                      func (*Delete) Range

                                                                                      func (d *Delete) Range(name string, value interface{}) *Delete

                                                                                        Range specifies the range key (a.k.a. sort key) to delete. Name is the name of the range key. Value is the value of the range key.

                                                                                        func (*Delete) Run

                                                                                        func (d *Delete) Run() error

                                                                                          Run executes this delete request.

                                                                                          func (*Delete) RunWithContext

                                                                                          func (d *Delete) RunWithContext(ctx aws.Context) error

                                                                                          type DeleteTable

                                                                                          type DeleteTable struct {
                                                                                          	// contains filtered or unexported fields
                                                                                          }

                                                                                            DeleteTable is a request to delete a table. See: http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DeleteTable.html

                                                                                            func (*DeleteTable) Run

                                                                                            func (dt *DeleteTable) Run() error

                                                                                              Run executes this request and deletes the table.

                                                                                              func (*DeleteTable) RunWithContext

                                                                                              func (dt *DeleteTable) RunWithContext(ctx aws.Context) error

                                                                                                RunWithContext executes this request and deletes the table.

                                                                                                type DescribeTable

                                                                                                type DescribeTable struct {
                                                                                                	// contains filtered or unexported fields
                                                                                                }

                                                                                                  DescribeTable is a request for information about a table and its indexes. See: http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html

                                                                                                  func (*DescribeTable) Run

                                                                                                  func (dt *DescribeTable) Run() (Description, error)

                                                                                                    Run executes this request and describe the table.

                                                                                                    func (*DescribeTable) RunWithContext

                                                                                                    func (dt *DescribeTable) RunWithContext(ctx aws.Context) (Description, error)

                                                                                                    type Description

                                                                                                    type Description struct {
                                                                                                    	Name    string
                                                                                                    	ARN     string
                                                                                                    	Status  Status
                                                                                                    	Created time.Time
                                                                                                    
                                                                                                    	// Attribute name of the hash key (a.k.a. partition key).
                                                                                                    	HashKey     string
                                                                                                    	HashKeyType KeyType
                                                                                                    	// Attribute name of the range key (a.k.a. sort key) or blank if nonexistant.
                                                                                                    	RangeKey     string
                                                                                                    	RangeKeyType KeyType
                                                                                                    
                                                                                                    	// Provisioned throughput for this table.
                                                                                                    	Throughput Throughput
                                                                                                    
                                                                                                    	// The number of items of the table, updated every 6 hours.
                                                                                                    	Items int64
                                                                                                    	// The size of this table in bytes, updated every 6 hours.
                                                                                                    	Size int64
                                                                                                    
                                                                                                    	// Global secondary indexes.
                                                                                                    	GSI []Index
                                                                                                    	// Local secondary indexes.
                                                                                                    	LSI []Index
                                                                                                    
                                                                                                    	StreamEnabled     bool
                                                                                                    	StreamView        StreamView
                                                                                                    	LatestStreamARN   string
                                                                                                    	LatestStreamLabel string
                                                                                                    }

                                                                                                      Description contains information about a table.

                                                                                                      func (Description) Active

                                                                                                      func (d Description) Active() bool

                                                                                                      type Index

                                                                                                      type Index struct {
                                                                                                      	Name        string
                                                                                                      	ARN         string
                                                                                                      	Status      Status
                                                                                                      	Backfilling bool // only for GSI
                                                                                                      
                                                                                                      	// Local is true when this index is a local secondary index, otherwise it is a global secondary index.
                                                                                                      	Local bool
                                                                                                      
                                                                                                      	// Attribute name of the hash key (a.k.a. partition key).
                                                                                                      	HashKey     string
                                                                                                      	HashKeyType KeyType
                                                                                                      	// Attribute name of the range key (a.k.a. sort key) or blank if nonexistant.
                                                                                                      	RangeKey     string
                                                                                                      	RangeKeyType KeyType
                                                                                                      
                                                                                                      	// The provisioned throughput for this index.
                                                                                                      	Throughput Throughput
                                                                                                      
                                                                                                      	Items int64
                                                                                                      	Size  int64
                                                                                                      
                                                                                                      	ProjectionType IndexProjection
                                                                                                      	// Non-key attributes for this index's projection (if ProjectionType is IncludeProjection).
                                                                                                      	ProjectionAttribs []string
                                                                                                      }

                                                                                                      type IndexProjection

                                                                                                      type IndexProjection string

                                                                                                        IndexProjection determines which attributes are mirrored into indices.

                                                                                                        var (
                                                                                                        	// Only the key attributes of the modified item are written to the stream.
                                                                                                        	KeysOnlyProjection IndexProjection = dynamodb.ProjectionTypeKeysOnly
                                                                                                        	// All of the table attributes are projected into the index.
                                                                                                        	AllProjection IndexProjection = dynamodb.ProjectionTypeAll
                                                                                                        	// Only the specified table attributes are projected into the index.
                                                                                                        	IncludeProjection IndexProjection = dynamodb.ProjectionTypeInclude
                                                                                                        )

                                                                                                        type Iter

                                                                                                        type Iter interface {
                                                                                                        	// Next tries to unmarshal the next result into out.
                                                                                                        	// Returns false when it is complete or if it runs into an error.
                                                                                                        	Next(out interface{}) bool
                                                                                                        	// NextWithContext tries to unmarshal the next result into out.
                                                                                                        	// Returns false when it is complete or if it runs into an error.
                                                                                                        	NextWithContext(ctx aws.Context, out interface{}) bool
                                                                                                        	// Err returns the error encountered, if any.
                                                                                                        	// You should check this after Next is finished.
                                                                                                        	Err() error
                                                                                                        }

                                                                                                          Iter is an iterator for request results.

                                                                                                          type KeyType

                                                                                                          type KeyType string

                                                                                                            KeyType is used to specify the type of hash and range keys for tables and indexes.

                                                                                                            type Keyed

                                                                                                            type Keyed interface {
                                                                                                            	HashKey() interface{}
                                                                                                            	RangeKey() interface{}
                                                                                                            }

                                                                                                              Keyed provides hash key and range key values.

                                                                                                              type Keys

                                                                                                              type Keys [2]interface{}

                                                                                                                Keys provides an easy way to specify the hash and range keys.

                                                                                                                table.Batch("ID", "Month").
                                                                                                                	Get([]dynamo.Keys{{1, "2015-10"}, {42, "2015-12"}, {42, "1992-02"}}...).
                                                                                                                	All(&results)
                                                                                                                

                                                                                                                func (Keys) HashKey

                                                                                                                func (k Keys) HashKey() interface{}

                                                                                                                  HashKey returns the hash key's value.

                                                                                                                  func (Keys) RangeKey

                                                                                                                  func (k Keys) RangeKey() interface{}

                                                                                                                    RangeKey returns the range key's value.

                                                                                                                    type ListTables

                                                                                                                    type ListTables struct {
                                                                                                                    	// contains filtered or unexported fields
                                                                                                                    }

                                                                                                                      ListTables is a request to list tables. See: http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_ListTables.html

                                                                                                                      func (*ListTables) All

                                                                                                                      func (lt *ListTables) All() ([]string, error)

                                                                                                                        All returns every table or an error.

                                                                                                                        func (*ListTables) AllWithContext

                                                                                                                        func (lt *ListTables) AllWithContext(ctx aws.Context) ([]string, error)

                                                                                                                          AllWithContext returns every table or an error.

                                                                                                                          func (*ListTables) Iter

                                                                                                                          func (lt *ListTables) Iter() Iter

                                                                                                                            Iter returns an iterator of table names. This iterator's Next functions will only accept type *string as their out parameter.

                                                                                                                            type Marshaler

                                                                                                                            type Marshaler interface {
                                                                                                                            	MarshalDynamo() (*dynamodb.AttributeValue, error)
                                                                                                                            }

                                                                                                                              Marshaler is the interface implemented by objects that can marshal themselves into an AttributeValue.

                                                                                                                              type Operator

                                                                                                                              type Operator string

                                                                                                                                Operator is an operation to apply in key comparisons.

                                                                                                                                type Order

                                                                                                                                type Order bool

                                                                                                                                  Order is used for specifying the order of results.

                                                                                                                                  const (
                                                                                                                                  	Ascending  Order = true  // ScanIndexForward = true
                                                                                                                                  	Descending       = false // ScanIndexForward = false
                                                                                                                                  )

                                                                                                                                    Orders for sorting results.

                                                                                                                                    type PagingIter

                                                                                                                                    type PagingIter interface {
                                                                                                                                    	Iter
                                                                                                                                    	// LastEvaluatedKey returns a key that can be passed to StartFrom in Query or Scan.
                                                                                                                                    	// Combined with SearchLimit, it is useful for paginating partial results.
                                                                                                                                    	LastEvaluatedKey() PagingKey
                                                                                                                                    }

                                                                                                                                      PagingIter is an iterator of request results that can also return a key used for splitting results.

                                                                                                                                      type PagingKey

                                                                                                                                      type PagingKey map[string]*dynamodb.AttributeValue

                                                                                                                                        PagingKey is a key used for splitting up partial results. Get a PagingKey from a PagingIter and pass it to StartFrom in Query or Scan.

                                                                                                                                        type Put

                                                                                                                                        type Put struct {
                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                        }

                                                                                                                                          Put is a request to create or replace an item. See: http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html

                                                                                                                                          func (*Put) ConsumedCapacity

                                                                                                                                          func (p *Put) ConsumedCapacity(cc *ConsumedCapacity) *Put

                                                                                                                                            ConsumedCapacity will measure the throughput capacity consumed by this operation and add it to cc.

                                                                                                                                            func (*Put) If

                                                                                                                                            func (p *Put) If(expr string, args ...interface{}) *Put

                                                                                                                                              If specifies a conditional expression for this put to succeed. Use single quotes to specificy reserved names inline (like 'Count'). Use the placeholder ? within the expression to substitute values, and use $ for names. You need to use quoted or placeholder names when the name is a reserved word in DynamoDB.

                                                                                                                                              func (*Put) OldValue

                                                                                                                                              func (p *Put) OldValue(out interface{}) error

                                                                                                                                                OldValue executes this put, unmarshaling the previous value into out. Returns ErrNotFound is there was no previous value.

                                                                                                                                                func (*Put) OldValueWithContext

                                                                                                                                                func (p *Put) OldValueWithContext(ctx aws.Context, out interface{}) error

                                                                                                                                                  OldValue executes this put, unmarshaling the previous value into out. Returns ErrNotFound is there was no previous value.

                                                                                                                                                  func (*Put) Run

                                                                                                                                                  func (p *Put) Run() error

                                                                                                                                                    Run executes this put.

                                                                                                                                                    func (*Put) RunWithContext

                                                                                                                                                    func (p *Put) RunWithContext(ctx aws.Context) error

                                                                                                                                                      Run executes this put.

                                                                                                                                                      type Query

                                                                                                                                                      type Query struct {
                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                      }

                                                                                                                                                        Query is a request to get one or more items in a table. Query uses the DynamoDB query for requests for multiple items, and GetItem for one. See: http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Query.html and http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_GetItem.html

                                                                                                                                                        func (*Query) All

                                                                                                                                                        func (q *Query) All(out interface{}) error

                                                                                                                                                          All executes this request and unmarshals all results to out, which must be a pointer to a slice.

                                                                                                                                                          func (*Query) AllWithContext

                                                                                                                                                          func (q *Query) AllWithContext(ctx aws.Context, out interface{}) error

                                                                                                                                                          func (*Query) AllWithLastEvaluatedKey

                                                                                                                                                          func (q *Query) AllWithLastEvaluatedKey(out interface{}) (PagingKey, error)

                                                                                                                                                            AllWithLastEvaluatedKey executes this request and unmarshals all results to out, which must be a pointer to a slice. This returns a PagingKey you can use with StartFrom to split up results.

                                                                                                                                                            func (*Query) AllWithLastEvaluatedKeyContext

                                                                                                                                                            func (q *Query) AllWithLastEvaluatedKeyContext(ctx aws.Context, out interface{}) (PagingKey, error)

                                                                                                                                                            func (*Query) Consistent

                                                                                                                                                            func (q *Query) Consistent(on bool) *Query

                                                                                                                                                              Consistent will, if on is true, make this query a strongly consistent read. Queries are eventually consistent by default. Strongly consistent reads are more resource-heavy than eventually consistent reads.

                                                                                                                                                              func (*Query) ConsumedCapacity

                                                                                                                                                              func (q *Query) ConsumedCapacity(cc *ConsumedCapacity) *Query

                                                                                                                                                                ConsumedCapacity will measure the throughput capacity consumed by this operation and add it to cc.

                                                                                                                                                                func (*Query) Count

                                                                                                                                                                func (q *Query) Count() (int64, error)

                                                                                                                                                                  Count executes this request, returning the number of results.

                                                                                                                                                                  func (*Query) CountWithContext

                                                                                                                                                                  func (q *Query) CountWithContext(ctx aws.Context) (int64, error)

                                                                                                                                                                  func (*Query) Filter

                                                                                                                                                                  func (q *Query) Filter(expr string, args ...interface{}) *Query

                                                                                                                                                                    Filter takes an expression that all results will be evaluated against. Use single quotes to specificy reserved names inline (like 'Count'). Use the placeholder ? within the expression to substitute values, and use $ for names. You need to use quoted or placeholder names when the name is a reserved word in DynamoDB. Multiple calls to Filter will be combined with AND.

                                                                                                                                                                    func (*Query) Index

                                                                                                                                                                    func (q *Query) Index(name string) *Query

                                                                                                                                                                      Index specifies the name of the index that this query will operate on.

                                                                                                                                                                      func (*Query) Iter

                                                                                                                                                                      func (q *Query) Iter() PagingIter

                                                                                                                                                                        Iter returns a results iterator for this request.

                                                                                                                                                                        func (*Query) Limit

                                                                                                                                                                        func (q *Query) Limit(limit int64) *Query

                                                                                                                                                                          Limit specifies the maximum amount of results to return.

                                                                                                                                                                          func (*Query) One

                                                                                                                                                                          func (q *Query) One(out interface{}) error

                                                                                                                                                                            One executes this query and retrieves a single result, unmarshaling the result to out.

                                                                                                                                                                            func (*Query) OneWithContext

                                                                                                                                                                            func (q *Query) OneWithContext(ctx aws.Context, out interface{}) error

                                                                                                                                                                            func (*Query) Order

                                                                                                                                                                            func (q *Query) Order(order Order) *Query

                                                                                                                                                                              Order specifies the desired result order. Requires a range key (a.k.a. partition key) to be specified.

                                                                                                                                                                              func (*Query) Project

                                                                                                                                                                              func (q *Query) Project(paths ...string) *Query

                                                                                                                                                                                Project limits the result attributes to the given paths.

                                                                                                                                                                                func (*Query) ProjectExpr

                                                                                                                                                                                func (q *Query) ProjectExpr(expr string, args ...interface{}) *Query

                                                                                                                                                                                  ProjectExpr limits the result attributes to the given expression. Use single quotes to specificy reserved names inline (like 'Count'). Use the placeholder ? within the expression to substitute values, and use $ for names. You need to use quoted or placeholder names when the name is a reserved word in DynamoDB.

                                                                                                                                                                                  func (*Query) Range

                                                                                                                                                                                  func (q *Query) Range(name string, op Operator, values ...interface{}) *Query

                                                                                                                                                                                    Range specifies the range key (a.k.a. sort key) or keys to get. For single item requests using One, op must be Equal. Name is the name of the range key. Op specifies the operator to use when comparing values.

                                                                                                                                                                                    func (*Query) SearchLimit

                                                                                                                                                                                    func (q *Query) SearchLimit(limit int64) *Query

                                                                                                                                                                                      SearchLimit specifies the maximum amount of results to examine. If a filter is not specified, the number of results will be limited. If a filter is specified, the number of results to consider for filtering will be limited.

                                                                                                                                                                                      func (*Query) StartFrom

                                                                                                                                                                                      func (q *Query) StartFrom(key PagingKey) *Query

                                                                                                                                                                                        StartFrom makes this query continue from a previous one. Use Query.Iter's LastEvaluatedKey.

                                                                                                                                                                                        type Scan

                                                                                                                                                                                        type Scan struct {
                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                        }

                                                                                                                                                                                          Scan is a request to scan all the data in a table. See: http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Scan.html

                                                                                                                                                                                          func (*Scan) All

                                                                                                                                                                                          func (s *Scan) All(out interface{}) error

                                                                                                                                                                                            All executes this request and unmarshals all results to out, which must be a pointer to a slice.

                                                                                                                                                                                            func (*Scan) AllWithContext

                                                                                                                                                                                            func (s *Scan) AllWithContext(ctx aws.Context, out interface{}) error

                                                                                                                                                                                              AllWithContext executes this request and unmarshals all results to out, which must be a pointer to a slice.

                                                                                                                                                                                              func (*Scan) AllWithLastEvaluatedKey

                                                                                                                                                                                              func (s *Scan) AllWithLastEvaluatedKey(out interface{}) (PagingKey, error)

                                                                                                                                                                                                AllWithLastEvaluatedKey executes this request and unmarshals all results to out, which must be a pointer to a slice. It returns a key you can use with StartWith to continue this query.

                                                                                                                                                                                                func (*Scan) AllWithLastEvaluatedKeyContext

                                                                                                                                                                                                func (s *Scan) AllWithLastEvaluatedKeyContext(ctx aws.Context, out interface{}) (PagingKey, error)

                                                                                                                                                                                                  AllWithLastEvaluatedKeyContext executes this request and unmarshals all results to out, which must be a pointer to a slice. It returns a key you can use with StartWith to continue this query.

                                                                                                                                                                                                  func (*Scan) Consistent

                                                                                                                                                                                                  func (s *Scan) Consistent(on bool) *Scan

                                                                                                                                                                                                    Consistent will, if on is true, make this scan use a strongly consistent read. Scans are eventually consistent by default. Strongly consistent reads are more resource-heavy than eventually consistent reads.

                                                                                                                                                                                                    func (*Scan) ConsumedCapacity

                                                                                                                                                                                                    func (s *Scan) ConsumedCapacity(cc *ConsumedCapacity) *Scan

                                                                                                                                                                                                      ConsumedCapacity will measure the throughput capacity consumed by this operation and add it to cc.

                                                                                                                                                                                                      func (*Scan) Filter

                                                                                                                                                                                                      func (s *Scan) Filter(expr string, args ...interface{}) *Scan

                                                                                                                                                                                                        Filter takes an expression that all results will be evaluated against. Use single quotes to specificy reserved names inline (like 'Count'). Use the placeholder ? within the expression to substitute values, and use $ for names. You need to use quoted or placeholder names when the name is a reserved word in DynamoDB. Multiple calls to Filter will be combined with AND.

                                                                                                                                                                                                        func (*Scan) Index

                                                                                                                                                                                                        func (s *Scan) Index(name string) *Scan

                                                                                                                                                                                                          Index specifies the name of the index that Scan will operate on.

                                                                                                                                                                                                          func (*Scan) Iter

                                                                                                                                                                                                          func (s *Scan) Iter() PagingIter

                                                                                                                                                                                                            Iter returns a results iterator for this request.

                                                                                                                                                                                                            func (*Scan) Limit

                                                                                                                                                                                                            func (s *Scan) Limit(limit int64) *Scan

                                                                                                                                                                                                              Limit specifies the maximum amount of results to return.

                                                                                                                                                                                                              func (*Scan) Project

                                                                                                                                                                                                              func (s *Scan) Project(paths ...string) *Scan

                                                                                                                                                                                                                Project limits the result attributes to the given paths.

                                                                                                                                                                                                                func (*Scan) SearchLimit

                                                                                                                                                                                                                func (s *Scan) SearchLimit(limit int64) *Scan

                                                                                                                                                                                                                  SearchLimit specifies a maximum amount of results to evaluate. Use this along with StartFrom and Iter's LastEvaluatedKey to split up results. Note that DynamoDB limits result sets to 1MB.

                                                                                                                                                                                                                  func (*Scan) StartFrom

                                                                                                                                                                                                                  func (s *Scan) StartFrom(key PagingKey) *Scan

                                                                                                                                                                                                                    StartFrom makes this scan continue from a previous one. Use Scan.Iter's LastEvaluatedKey.

                                                                                                                                                                                                                    type Status

                                                                                                                                                                                                                    type Status string

                                                                                                                                                                                                                      Status is an enumeration of table and index statuses.

                                                                                                                                                                                                                      type StreamView

                                                                                                                                                                                                                      type StreamView string

                                                                                                                                                                                                                        StreamView determines what information is written to a table's stream.

                                                                                                                                                                                                                        var (
                                                                                                                                                                                                                        	// Only the key attributes of the modified item are written to the stream.
                                                                                                                                                                                                                        	KeysOnlyView StreamView = dynamodb.StreamViewTypeKeysOnly
                                                                                                                                                                                                                        	// The entire item, as it appears after it was modified, is written to the stream.
                                                                                                                                                                                                                        	NewImageView StreamView = dynamodb.StreamViewTypeNewImage
                                                                                                                                                                                                                        	// The entire item, as it appeared before it was modified, is written to the stream.
                                                                                                                                                                                                                        	OldImageView StreamView = dynamodb.StreamViewTypeOldImage
                                                                                                                                                                                                                        	// Both the new and the old item images of the item are written to the stream.
                                                                                                                                                                                                                        	NewAndOldImagesView StreamView = dynamodb.StreamViewTypeNewAndOldImages
                                                                                                                                                                                                                        )

                                                                                                                                                                                                                        type Table

                                                                                                                                                                                                                        type Table struct {
                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                        }

                                                                                                                                                                                                                          Table is a DynamoDB table.

                                                                                                                                                                                                                          func (Table) Batch

                                                                                                                                                                                                                          func (table Table) Batch(hashAndRangeKeyName ...string) Batch

                                                                                                                                                                                                                            Batch creates a new batch with the given hash key name, and range key name if provided. For purely Put batches, neither is necessary.

                                                                                                                                                                                                                            func (Table) Delete

                                                                                                                                                                                                                            func (table Table) Delete(name string, value interface{}) *Delete

                                                                                                                                                                                                                              Delete creates a new request to delete an item. Key is the name of the hash key (a.k.a. partition key). Value is the value of the hash key.

                                                                                                                                                                                                                              func (Table) DeleteTable

                                                                                                                                                                                                                              func (table Table) DeleteTable() *DeleteTable

                                                                                                                                                                                                                                DeleteTable begins a new request to delete this table.

                                                                                                                                                                                                                                func (Table) Describe

                                                                                                                                                                                                                                func (table Table) Describe() *DescribeTable

                                                                                                                                                                                                                                  Describe begins a new request to describe this table.

                                                                                                                                                                                                                                  func (Table) Get

                                                                                                                                                                                                                                  func (table Table) Get(name string, value interface{}) *Query

                                                                                                                                                                                                                                    Get creates a new request to get an item. Name is the name of the hash key (a.k.a. partition key). Value is the value of the hash key.

                                                                                                                                                                                                                                    func (Table) Name

                                                                                                                                                                                                                                    func (table Table) Name() string

                                                                                                                                                                                                                                      Name returns this table's name.

                                                                                                                                                                                                                                      func (Table) Put

                                                                                                                                                                                                                                      func (table Table) Put(item interface{}) *Put

                                                                                                                                                                                                                                        Put creates a new request to create or replace an item.

                                                                                                                                                                                                                                        func (Table) Scan

                                                                                                                                                                                                                                        func (table Table) Scan() *Scan

                                                                                                                                                                                                                                          Scan creates a new request to scan this table.

                                                                                                                                                                                                                                          func (Table) Update

                                                                                                                                                                                                                                          func (table Table) Update(hashKey string, value interface{}) *Update

                                                                                                                                                                                                                                            Update creates a new request to modify an existing item.

                                                                                                                                                                                                                                            func (Table) UpdateTable

                                                                                                                                                                                                                                            func (table Table) UpdateTable() *UpdateTable

                                                                                                                                                                                                                                              UpdateTable makes changes to this table's settings.

                                                                                                                                                                                                                                              type Throughput

                                                                                                                                                                                                                                              type Throughput struct {
                                                                                                                                                                                                                                              	// Read capacity units.
                                                                                                                                                                                                                                              	Read int64
                                                                                                                                                                                                                                              	// Write capacity units.
                                                                                                                                                                                                                                              	Write int64
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// Time at which throughput was last increased for this table.
                                                                                                                                                                                                                                              	LastInc time.Time
                                                                                                                                                                                                                                              	// Time at which throughput was last decreased for this table.
                                                                                                                                                                                                                                              	LastDec time.Time
                                                                                                                                                                                                                                              	// The number of throughput decreases in this UTC calendar day.
                                                                                                                                                                                                                                              	DecsToday int64
                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                              type Unmarshaler

                                                                                                                                                                                                                                              type Unmarshaler interface {
                                                                                                                                                                                                                                              	UnmarshalDynamo(av *dynamodb.AttributeValue) error
                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                Unmarshaler is the interface implemented by objects that can unmarshal an AttributeValue into themselves.

                                                                                                                                                                                                                                                type Update

                                                                                                                                                                                                                                                type Update struct {
                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                  Update represents changes to an existing item. It uses the UpdateItem API. See: http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html

                                                                                                                                                                                                                                                  func (*Update) Add

                                                                                                                                                                                                                                                  func (u *Update) Add(path string, value interface{}) *Update

                                                                                                                                                                                                                                                    Add adds value to path. Path can be a number or a set. If path represents a number, value is atomically added to the number. If path represents a set, value must be a slice, a map[*]struct{}, or map[*]bool. Path must be a top-level attribute.

                                                                                                                                                                                                                                                    func (*Update) AddFloatsToSet

                                                                                                                                                                                                                                                    func (u *Update) AddFloatsToSet(path string, values ...float64) *Update

                                                                                                                                                                                                                                                      AddFloatsToSet adds the given values to the number set specified by path.

                                                                                                                                                                                                                                                      func (*Update) AddIntsToSet

                                                                                                                                                                                                                                                      func (u *Update) AddIntsToSet(path string, values ...int) *Update

                                                                                                                                                                                                                                                        AddIntsToSet adds the given values to the number set specified by path.

                                                                                                                                                                                                                                                        func (*Update) AddStringsToSet

                                                                                                                                                                                                                                                        func (u *Update) AddStringsToSet(path string, values ...string) *Update

                                                                                                                                                                                                                                                          AddStringsToSet adds the given values to the string set specified by path.

                                                                                                                                                                                                                                                          func (*Update) Append

                                                                                                                                                                                                                                                          func (u *Update) Append(path string, value interface{}) *Update

                                                                                                                                                                                                                                                            Append appends value to the end of the list specified by path.

                                                                                                                                                                                                                                                            func (*Update) ConsumedCapacity

                                                                                                                                                                                                                                                            func (u *Update) ConsumedCapacity(cc *ConsumedCapacity) *Update

                                                                                                                                                                                                                                                              ConsumedCapacity will measure the throughput capacity consumed by this operation and add it to cc.

                                                                                                                                                                                                                                                              func (*Update) DeleteFloatsFromSet

                                                                                                                                                                                                                                                              func (u *Update) DeleteFloatsFromSet(path string, values ...float64) *Update

                                                                                                                                                                                                                                                                DeleteFloatsFromSet deletes the given values from the number set specified by path.

                                                                                                                                                                                                                                                                func (*Update) DeleteIntsFromSet

                                                                                                                                                                                                                                                                func (u *Update) DeleteIntsFromSet(path string, values ...int) *Update

                                                                                                                                                                                                                                                                  DeleteIntsFromSet deletes the given values from the number set specified by path.

                                                                                                                                                                                                                                                                  func (*Update) DeleteStringsFromSet

                                                                                                                                                                                                                                                                  func (u *Update) DeleteStringsFromSet(path string, values ...string) *Update

                                                                                                                                                                                                                                                                    DeleteStringsFromSet deletes the given values from the string set specified by path.

                                                                                                                                                                                                                                                                    func (*Update) If

                                                                                                                                                                                                                                                                    func (u *Update) If(expr string, args ...interface{}) *Update

                                                                                                                                                                                                                                                                      If specifies a conditional expression for this update to succeed. Use single quotes to specificy reserved names inline (like 'Count'). Use the placeholder ? within the expression to substitute values, and use $ for names. You need to use quoted or placeholder names when the name is a reserved word in DynamoDB.

                                                                                                                                                                                                                                                                      func (*Update) OldValue

                                                                                                                                                                                                                                                                      func (u *Update) OldValue(out interface{}) error

                                                                                                                                                                                                                                                                        OldValue executes this update, encoding out with the previous value.

                                                                                                                                                                                                                                                                        func (*Update) OldValueWithContext

                                                                                                                                                                                                                                                                        func (u *Update) OldValueWithContext(ctx aws.Context, out interface{}) error

                                                                                                                                                                                                                                                                        func (*Update) Prepend

                                                                                                                                                                                                                                                                        func (u *Update) Prepend(path string, value interface{}) *Update

                                                                                                                                                                                                                                                                          Prepend inserts value to the beginning of the list specified by path.

                                                                                                                                                                                                                                                                          func (*Update) Range

                                                                                                                                                                                                                                                                          func (u *Update) Range(name string, value interface{}) *Update

                                                                                                                                                                                                                                                                            Range specifies the range key (sort key) for the item to update.

                                                                                                                                                                                                                                                                            func (*Update) Remove

                                                                                                                                                                                                                                                                            func (u *Update) Remove(paths ...string) *Update

                                                                                                                                                                                                                                                                              Remove removes the paths from this item, deleting the specified attributes.

                                                                                                                                                                                                                                                                              func (*Update) RemoveExpr

                                                                                                                                                                                                                                                                              func (u *Update) RemoveExpr(expr string, args ...interface{}) *Update

                                                                                                                                                                                                                                                                                RemoveExpr performs a custom remove expression, substituting the args into expr as in filter expressions.

                                                                                                                                                                                                                                                                                RemoveExpr("MyList[$]", 5)
                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                func (*Update) Run

                                                                                                                                                                                                                                                                                func (u *Update) Run() error

                                                                                                                                                                                                                                                                                  Run executes this update.

                                                                                                                                                                                                                                                                                  func (*Update) RunWithContext

                                                                                                                                                                                                                                                                                  func (u *Update) RunWithContext(ctx aws.Context) error

                                                                                                                                                                                                                                                                                  func (*Update) Set

                                                                                                                                                                                                                                                                                  func (u *Update) Set(path string, value interface{}) *Update

                                                                                                                                                                                                                                                                                    Set changes path to the given value. Paths that are reserved words are automatically escaped. Use single quotes to escape complex values like 'User'.'Count'.

                                                                                                                                                                                                                                                                                    func (*Update) SetExpr

                                                                                                                                                                                                                                                                                    func (u *Update) SetExpr(expr string, args ...interface{}) *Update

                                                                                                                                                                                                                                                                                      SetExpr performs a custom set expression, substituting the args into expr as in filter expressions. See: http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html#DDB-UpdateItem-request-UpdateExpression

                                                                                                                                                                                                                                                                                      SetExpr("MyMap.$.$ = ?", key1, key2, val)
                                                                                                                                                                                                                                                                                      SetExpr("'Counter' = 'Counter' + ?", 1)
                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                      func (*Update) SetIfNotExists

                                                                                                                                                                                                                                                                                      func (u *Update) SetIfNotExists(path string, value interface{}) *Update

                                                                                                                                                                                                                                                                                        SetIfNotExists changes path to the given value, if it does not already exist.

                                                                                                                                                                                                                                                                                        func (*Update) SetSet

                                                                                                                                                                                                                                                                                        func (u *Update) SetSet(path string, value interface{}) *Update

                                                                                                                                                                                                                                                                                          SetSet changes a set at the given path to the given value. SetSet marshals value to a string set, number set, or binary set. If value is of zero length or nil, path will be removed instead. Paths that are reserved words are automatically escaped. Use single quotes to escape complex values like 'User'.'Count'.

                                                                                                                                                                                                                                                                                          func (*Update) Value

                                                                                                                                                                                                                                                                                          func (u *Update) Value(out interface{}) error

                                                                                                                                                                                                                                                                                            Value executes this update, encoding out with the new value.

                                                                                                                                                                                                                                                                                            func (*Update) ValueWithContext

                                                                                                                                                                                                                                                                                            func (u *Update) ValueWithContext(ctx aws.Context, out interface{}) error

                                                                                                                                                                                                                                                                                            type UpdateTable

                                                                                                                                                                                                                                                                                            type UpdateTable struct {
                                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                              UpdateTable is a request to change a table's settings. See: http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html

                                                                                                                                                                                                                                                                                              func (*UpdateTable) CreateIndex

                                                                                                                                                                                                                                                                                              func (ut *UpdateTable) CreateIndex(index Index) *UpdateTable

                                                                                                                                                                                                                                                                                                CreateIndex adds a new secondary global index. You must specify the index name, keys, key types, projection, and throughput.

                                                                                                                                                                                                                                                                                                func (*UpdateTable) DeleteIndex

                                                                                                                                                                                                                                                                                                func (ut *UpdateTable) DeleteIndex(name string) *UpdateTable

                                                                                                                                                                                                                                                                                                  DeleteIndex deletes the specified index.

                                                                                                                                                                                                                                                                                                  func (*UpdateTable) DisableStream

                                                                                                                                                                                                                                                                                                  func (ut *UpdateTable) DisableStream() *UpdateTable

                                                                                                                                                                                                                                                                                                    DisableStream disables this table's stream.

                                                                                                                                                                                                                                                                                                    func (*UpdateTable) Provision

                                                                                                                                                                                                                                                                                                    func (ut *UpdateTable) Provision(read, write int64) *UpdateTable

                                                                                                                                                                                                                                                                                                      Provision sets this table's read and write throughput capacity.

                                                                                                                                                                                                                                                                                                      func (*UpdateTable) ProvisionIndex

                                                                                                                                                                                                                                                                                                      func (ut *UpdateTable) ProvisionIndex(name string, read, write int64) *UpdateTable

                                                                                                                                                                                                                                                                                                        ProvisionIndex updates a global secondary index's read and write throughput capacity.

                                                                                                                                                                                                                                                                                                        func (*UpdateTable) Run

                                                                                                                                                                                                                                                                                                        func (ut *UpdateTable) Run() (Description, error)

                                                                                                                                                                                                                                                                                                          Run executes this request and describes the table.

                                                                                                                                                                                                                                                                                                          func (*UpdateTable) RunWithContext

                                                                                                                                                                                                                                                                                                          func (ut *UpdateTable) RunWithContext(ctx aws.Context) (Description, error)

                                                                                                                                                                                                                                                                                                          func (*UpdateTable) Stream

                                                                                                                                                                                                                                                                                                          func (ut *UpdateTable) Stream(view StreamView) *UpdateTable

                                                                                                                                                                                                                                                                                                            Stream enables streaming and sets the stream view type.

                                                                                                                                                                                                                                                                                                            Directories

                                                                                                                                                                                                                                                                                                            Path Synopsis
                                                                                                                                                                                                                                                                                                            internal
                                                                                                                                                                                                                                                                                                            exprs
                                                                                                                                                                                                                                                                                                            Package exprs is the internal package for parsing DynamoDB "expressions", including condition expressions and filter expressions.
                                                                                                                                                                                                                                                                                                            Package exprs is the internal package for parsing DynamoDB "expressions", including condition expressions and filter expressions.