Documentation

Overview

    Package timestreamwrite provides the API client, operations, and parameter types for Amazon Timestream Write.

    Amazon Timestream is a fast, scalable, fully managed time series database service that makes it easy to store and analyze trillions of time series data points per day. With Timestream, you can easily store and analyze IoT sensor data to derive insights from your IoT applications. You can analyze industrial telemetry to streamline equipment management and maintenance. You can also store and analyze log data and metrics to improve the performance and availability of your applications. Timestream is built from the ground up to effectively ingest, process, and store time series data. It organizes data to optimize query processing. It automatically scales based on the volume of data ingested and on the query volume to ensure you receive optimal performance while inserting and querying data. As your data grows over time, Timestream’s adaptive query processing engine spans across storage tiers to provide fast analysis while reducing costs.

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2018-11-01"
    View Source
    const ServiceID = "Timestream Write"

    Variables

    This section is empty.

    Functions

    func NewDefaultEndpointResolver

    func NewDefaultEndpointResolver() *internalendpoints.Resolver

      NewDefaultEndpointResolver constructs a new service endpoint resolver

      func WithAPIOptions

      func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options)

        WithAPIOptions returns a functional option for setting the Client's APIOptions option.

        func WithEndpointResolver

        func WithEndpointResolver(v EndpointResolver) func(*Options)

          WithEndpointResolver returns a functional option for setting the Client's EndpointResolver option.

          Types

          type Client

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

            Client provides the API client to make operations call for Amazon Timestream Write.

            func New

            func New(options Options, optFns ...func(*Options)) *Client

              New returns an initialized Client based on the functional options. Provide additional functional options to further configure the behavior of the client, such as changing the client's endpoint or adding custom middleware behavior.

              func NewFromConfig

              func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client

                NewFromConfig returns a new client from the provided config.

                func (*Client) CreateDatabase

                func (c *Client) CreateDatabase(ctx context.Context, params *CreateDatabaseInput, optFns ...func(*Options)) (*CreateDatabaseOutput, error)

                  Creates a new Timestream database. If the KMS key is not specified, the database will be encrypted with a Timestream managed KMS key located in your account. Refer to AWS managed KMS keys (https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk) for more info. Service quotas apply. For more information, see Access Management (https://docs.aws.amazon.com/timestream/latest/developerguide/ts-limits.html) in the Timestream Developer Guide.

                  func (*Client) CreateTable

                  func (c *Client) CreateTable(ctx context.Context, params *CreateTableInput, optFns ...func(*Options)) (*CreateTableOutput, error)

                    The CreateTable operation adds a new table to an existing database in your account. In an AWS account, table names must be at least unique within each Region if they are in the same database. You may have identical table names in the same Region if the tables are in seperate databases. While creating the table, you must specify the table name, database name, and the retention properties. Service quotas apply. For more information, see Access Management (https://docs.aws.amazon.com/timestream/latest/developerguide/ts-limits.html) in the Timestream Developer Guide.

                    func (*Client) DeleteDatabase

                    func (c *Client) DeleteDatabase(ctx context.Context, params *DeleteDatabaseInput, optFns ...func(*Options)) (*DeleteDatabaseOutput, error)

                      Deletes a given Timestream database. This is an irreversible operation. After a database is deleted, the time series data from its tables cannot be recovered. All tables in the database must be deleted first, or a ValidationException error will be thrown. Due to the nature of distributed retries, the operation can return either success or a ResourceNotFoundException. Clients should consider them equivalent.

                      func (*Client) DeleteTable

                      func (c *Client) DeleteTable(ctx context.Context, params *DeleteTableInput, optFns ...func(*Options)) (*DeleteTableOutput, error)

                        Deletes a given Timestream table. This is an irreversible operation. After a Timestream database table is deleted, the time series data stored in the table cannot be recovered. Due to the nature of distributed retries, the operation can return either success or a ResourceNotFoundException. Clients should consider them equivalent.

                        func (*Client) DescribeDatabase

                        func (c *Client) DescribeDatabase(ctx context.Context, params *DescribeDatabaseInput, optFns ...func(*Options)) (*DescribeDatabaseOutput, error)

                          Returns information about the database, including the database name, time that the database was created, and the total number of tables found within the database. Service quotas apply. For more information, see Access Management (https://docs.aws.amazon.com/timestream/latest/developerguide/ts-limits.html) in the Timestream Developer Guide.

                          func (*Client) DescribeEndpoints

                          func (c *Client) DescribeEndpoints(ctx context.Context, params *DescribeEndpointsInput, optFns ...func(*Options)) (*DescribeEndpointsOutput, error)

                            DescribeEndpoints returns a list of available endpoints to make Timestream API calls against. This API is available through both Write and Query. Because Timestream’s SDKs are designed to transparently work with the service’s architecture, including the management and mapping of the service endpoints, it is not recommended that you use this API unless:

                            * Your application uses a programming language that does not yet have SDK support

                            * You require better control over the client-side implementation

                            For detailed information on how to use DescribeEndpoints, see The Endpoint Discovery Pattern and REST APIs (https://docs.aws.amazon.com/timestream/latest/developerguide/Using-API.endpoint-discovery.html).

                            func (*Client) DescribeTable

                            func (c *Client) DescribeTable(ctx context.Context, params *DescribeTableInput, optFns ...func(*Options)) (*DescribeTableOutput, error)

                              Returns information about the table, including the table name, database name, retention duration of the memory store and the magnetic store. Service quotas apply. For more information, see Access Management (https://docs.aws.amazon.com/timestream/latest/developerguide/ts-limits.html) in the Timestream Developer Guide.

                              func (*Client) ListDatabases

                              func (c *Client) ListDatabases(ctx context.Context, params *ListDatabasesInput, optFns ...func(*Options)) (*ListDatabasesOutput, error)

                                Returns a list of your Timestream databases. Service quotas apply. For more information, see Access Management (https://docs.aws.amazon.com/timestream/latest/developerguide/ts-limits.html) in the Timestream Developer Guide.

                                func (*Client) ListTables

                                func (c *Client) ListTables(ctx context.Context, params *ListTablesInput, optFns ...func(*Options)) (*ListTablesOutput, error)

                                  A list of tables, along with the name, status and retention properties of each table.

                                  func (*Client) ListTagsForResource

                                  func (c *Client) ListTagsForResource(ctx context.Context, params *ListTagsForResourceInput, optFns ...func(*Options)) (*ListTagsForResourceOutput, error)

                                    List all tags on a Timestream resource.

                                    func (*Client) TagResource

                                    func (c *Client) TagResource(ctx context.Context, params *TagResourceInput, optFns ...func(*Options)) (*TagResourceOutput, error)

                                      Associate a set of tags with a Timestream resource. You can then activate these user-defined tags so that they appear on the Billing and Cost Management console for cost allocation tracking.

                                      func (*Client) UntagResource

                                      func (c *Client) UntagResource(ctx context.Context, params *UntagResourceInput, optFns ...func(*Options)) (*UntagResourceOutput, error)

                                        Removes the association of tags from a Timestream resource.

                                        func (*Client) UpdateDatabase

                                        func (c *Client) UpdateDatabase(ctx context.Context, params *UpdateDatabaseInput, optFns ...func(*Options)) (*UpdateDatabaseOutput, error)

                                          Modifies the KMS key for an existing database. While updating the database, you must specify the database name and the identifier of the new KMS key to be used (KmsKeyId). If there are any concurrent UpdateDatabase requests, first writer wins.

                                          func (*Client) UpdateTable

                                          func (c *Client) UpdateTable(ctx context.Context, params *UpdateTableInput, optFns ...func(*Options)) (*UpdateTableOutput, error)

                                            Modifies the retention duration of the memory store and magnetic store for your Timestream table. Note that the change in retention duration takes effect immediately. For example, if the retention period of the memory store was initially set to 2 hours and then changed to 24 hours, the memory store will be capable of holding 24 hours of data, but will be populated with 24 hours of data 22 hours after this change was made. Timestream does not retrieve data from the magnetic store to populate the memory store. Service quotas apply. For more information, see Access Management (https://docs.aws.amazon.com/timestream/latest/developerguide/ts-limits.html) in the Timestream Developer Guide.

                                            func (*Client) WriteRecords

                                            func (c *Client) WriteRecords(ctx context.Context, params *WriteRecordsInput, optFns ...func(*Options)) (*WriteRecordsOutput, error)

                                              The WriteRecords operation enables you to write your time series data into Timestream. You can specify a single data point or a batch of data points to be inserted into the system. Timestream offers you with a flexible schema that auto detects the column names and data types for your Timestream tables based on the dimension names and data types of the data points you specify when invoking writes into the database. Timestream support eventual consistency read semantics. This means that when you query data immediately after writing a batch of data into Timestream, the query results might not reflect the results of a recently completed write operation. The results may also include some stale data. If you repeat the query request after a short time, the results should return the latest data. Service quotas apply. For more information, see Access Management (https://docs.aws.amazon.com/timestream/latest/developerguide/ts-limits.html) in the Timestream Developer Guide.

                                              type CreateDatabaseInput

                                              type CreateDatabaseInput struct {
                                              
                                              	// The name of the Timestream database.
                                              	//
                                              	// This member is required.
                                              	DatabaseName *string
                                              
                                              	// The KMS key for the database. If the KMS key is not specified, the database will
                                              	// be encrypted with a Timestream managed KMS key located in your account. Refer to
                                              	// AWS managed KMS keys
                                              	// (https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk)
                                              	// for more info.
                                              	KmsKeyId *string
                                              
                                              	// A list of key-value pairs to label the table.
                                              	Tags []types.Tag
                                              }

                                              type CreateDatabaseOutput

                                              type CreateDatabaseOutput struct {
                                              
                                              	// The newly created Timestream database.
                                              	Database *types.Database
                                              
                                              	// Metadata pertaining to the operation's result.
                                              	ResultMetadata middleware.Metadata
                                              }

                                              type CreateTableInput

                                              type CreateTableInput struct {
                                              
                                              	// The name of the Timestream database.
                                              	//
                                              	// This member is required.
                                              	DatabaseName *string
                                              
                                              	// The name of the Timestream table.
                                              	//
                                              	// This member is required.
                                              	TableName *string
                                              
                                              	// The duration for which your time series data must be stored in the memory store
                                              	// and the magnetic store.
                                              	RetentionProperties *types.RetentionProperties
                                              
                                              	// A list of key-value pairs to label the table.
                                              	Tags []types.Tag
                                              }

                                              type CreateTableOutput

                                              type CreateTableOutput struct {
                                              
                                              	// The newly created Timestream table.
                                              	Table *types.Table
                                              
                                              	// Metadata pertaining to the operation's result.
                                              	ResultMetadata middleware.Metadata
                                              }

                                              type DeleteDatabaseInput

                                              type DeleteDatabaseInput struct {
                                              
                                              	// The name of the Timestream database to be deleted.
                                              	//
                                              	// This member is required.
                                              	DatabaseName *string
                                              }

                                              type DeleteDatabaseOutput

                                              type DeleteDatabaseOutput struct {
                                              	// Metadata pertaining to the operation's result.
                                              	ResultMetadata middleware.Metadata
                                              }

                                              type DeleteTableInput

                                              type DeleteTableInput struct {
                                              
                                              	// The name of the database where the Timestream database is to be deleted.
                                              	//
                                              	// This member is required.
                                              	DatabaseName *string
                                              
                                              	// The name of the Timestream table to be deleted.
                                              	//
                                              	// This member is required.
                                              	TableName *string
                                              }

                                              type DeleteTableOutput

                                              type DeleteTableOutput struct {
                                              	// Metadata pertaining to the operation's result.
                                              	ResultMetadata middleware.Metadata
                                              }

                                              type DescribeDatabaseInput

                                              type DescribeDatabaseInput struct {
                                              
                                              	// The name of the Timestream database.
                                              	//
                                              	// This member is required.
                                              	DatabaseName *string
                                              }

                                              type DescribeDatabaseOutput

                                              type DescribeDatabaseOutput struct {
                                              
                                              	// The name of the Timestream table.
                                              	Database *types.Database
                                              
                                              	// Metadata pertaining to the operation's result.
                                              	ResultMetadata middleware.Metadata
                                              }

                                              type DescribeEndpointsInput

                                              type DescribeEndpointsInput struct {
                                              }

                                              type DescribeEndpointsOutput

                                              type DescribeEndpointsOutput struct {
                                              
                                              	// An Endpoints object is returned when a DescribeEndpoints request is made.
                                              	//
                                              	// This member is required.
                                              	Endpoints []types.Endpoint
                                              
                                              	// Metadata pertaining to the operation's result.
                                              	ResultMetadata middleware.Metadata
                                              }

                                              type DescribeTableInput

                                              type DescribeTableInput struct {
                                              
                                              	// The name of the Timestream database.
                                              	//
                                              	// This member is required.
                                              	DatabaseName *string
                                              
                                              	// The name of the Timestream table.
                                              	//
                                              	// This member is required.
                                              	TableName *string
                                              }

                                              type DescribeTableOutput

                                              type DescribeTableOutput struct {
                                              
                                              	// The Timestream table.
                                              	Table *types.Table
                                              
                                              	// Metadata pertaining to the operation's result.
                                              	ResultMetadata middleware.Metadata
                                              }

                                              type EndpointResolver

                                              type EndpointResolver interface {
                                              	ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
                                              }

                                                EndpointResolver interface for resolving service endpoints.

                                                func EndpointResolverFromURL

                                                func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver

                                                  EndpointResolverFromURL returns an EndpointResolver configured using the provided endpoint url. By default, the resolved endpoint resolver uses the client region as signing region, and the endpoint source is set to EndpointSourceCustom.You can provide functional options to configure endpoint values for the resolved endpoint.

                                                  type EndpointResolverFunc

                                                  type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)

                                                    EndpointResolverFunc is a helper utility that wraps a function so it satisfies the EndpointResolver interface. This is useful when you want to add additional endpoint resolving logic, or stub out specific endpoints with custom values.

                                                    func (EndpointResolverFunc) ResolveEndpoint

                                                    func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error)

                                                    type EndpointResolverOptions

                                                    type EndpointResolverOptions = internalendpoints.Options

                                                      EndpointResolverOptions is the service endpoint resolver options

                                                      type HTTPClient

                                                      type HTTPClient interface {
                                                      	Do(*http.Request) (*http.Response, error)
                                                      }

                                                      type HTTPSignerV4

                                                      type HTTPSignerV4 interface {
                                                      	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
                                                      }

                                                      type ListDatabasesAPIClient

                                                      type ListDatabasesAPIClient interface {
                                                      	ListDatabases(context.Context, *ListDatabasesInput, ...func(*Options)) (*ListDatabasesOutput, error)
                                                      }

                                                        ListDatabasesAPIClient is a client that implements the ListDatabases operation.

                                                        type ListDatabasesInput

                                                        type ListDatabasesInput struct {
                                                        
                                                        	// The total number of items to return in the output. If the total number of items
                                                        	// available is more than the value specified, a NextToken is provided in the
                                                        	// output. To resume pagination, provide the NextToken value as argument of a
                                                        	// subsequent API invocation.
                                                        	MaxResults *int32
                                                        
                                                        	// The pagination token. To resume pagination, provide the NextToken value as
                                                        	// argument of a subsequent API invocation.
                                                        	NextToken *string
                                                        }

                                                        type ListDatabasesOutput

                                                        type ListDatabasesOutput struct {
                                                        
                                                        	// A list of database names.
                                                        	Databases []types.Database
                                                        
                                                        	// The pagination token. This parameter is returned when the response is truncated.
                                                        	NextToken *string
                                                        
                                                        	// Metadata pertaining to the operation's result.
                                                        	ResultMetadata middleware.Metadata
                                                        }

                                                        type ListDatabasesPaginator

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

                                                          ListDatabasesPaginator is a paginator for ListDatabases

                                                          func NewListDatabasesPaginator

                                                          func NewListDatabasesPaginator(client ListDatabasesAPIClient, params *ListDatabasesInput, optFns ...func(*ListDatabasesPaginatorOptions)) *ListDatabasesPaginator

                                                            NewListDatabasesPaginator returns a new ListDatabasesPaginator

                                                            func (*ListDatabasesPaginator) HasMorePages

                                                            func (p *ListDatabasesPaginator) HasMorePages() bool

                                                              HasMorePages returns a boolean indicating whether more pages are available

                                                              func (*ListDatabasesPaginator) NextPage

                                                              func (p *ListDatabasesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDatabasesOutput, error)

                                                                NextPage retrieves the next ListDatabases page.

                                                                type ListDatabasesPaginatorOptions

                                                                type ListDatabasesPaginatorOptions struct {
                                                                	// The total number of items to return in the output. If the total number of items
                                                                	// available is more than the value specified, a NextToken is provided in the
                                                                	// output. To resume pagination, provide the NextToken value as argument of a
                                                                	// subsequent API invocation.
                                                                	Limit int32
                                                                
                                                                	// Set to true if pagination should stop if the service returns a pagination token
                                                                	// that matches the most recent token provided to the service.
                                                                	StopOnDuplicateToken bool
                                                                }

                                                                  ListDatabasesPaginatorOptions is the paginator options for ListDatabases

                                                                  type ListTablesAPIClient

                                                                  type ListTablesAPIClient interface {
                                                                  	ListTables(context.Context, *ListTablesInput, ...func(*Options)) (*ListTablesOutput, error)
                                                                  }

                                                                    ListTablesAPIClient is a client that implements the ListTables operation.

                                                                    type ListTablesInput

                                                                    type ListTablesInput struct {
                                                                    
                                                                    	// The name of the Timestream database.
                                                                    	DatabaseName *string
                                                                    
                                                                    	// The total number of items to return in the output. If the total number of items
                                                                    	// available is more than the value specified, a NextToken is provided in the
                                                                    	// output. To resume pagination, provide the NextToken value as argument of a
                                                                    	// subsequent API invocation.
                                                                    	MaxResults *int32
                                                                    
                                                                    	// The pagination token. To resume pagination, provide the NextToken value as
                                                                    	// argument of a subsequent API invocation.
                                                                    	NextToken *string
                                                                    }

                                                                    type ListTablesOutput

                                                                    type ListTablesOutput struct {
                                                                    
                                                                    	// A token to specify where to start paginating. This is the NextToken from a
                                                                    	// previously truncated response.
                                                                    	NextToken *string
                                                                    
                                                                    	// A list of tables.
                                                                    	Tables []types.Table
                                                                    
                                                                    	// Metadata pertaining to the operation's result.
                                                                    	ResultMetadata middleware.Metadata
                                                                    }

                                                                    type ListTablesPaginator

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

                                                                      ListTablesPaginator is a paginator for ListTables

                                                                      func NewListTablesPaginator

                                                                      func NewListTablesPaginator(client ListTablesAPIClient, params *ListTablesInput, optFns ...func(*ListTablesPaginatorOptions)) *ListTablesPaginator

                                                                        NewListTablesPaginator returns a new ListTablesPaginator

                                                                        func (*ListTablesPaginator) HasMorePages

                                                                        func (p *ListTablesPaginator) HasMorePages() bool

                                                                          HasMorePages returns a boolean indicating whether more pages are available

                                                                          func (*ListTablesPaginator) NextPage

                                                                          func (p *ListTablesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListTablesOutput, error)

                                                                            NextPage retrieves the next ListTables page.

                                                                            type ListTablesPaginatorOptions

                                                                            type ListTablesPaginatorOptions struct {
                                                                            	// The total number of items to return in the output. If the total number of items
                                                                            	// available is more than the value specified, a NextToken is provided in the
                                                                            	// output. To resume pagination, provide the NextToken value as argument of a
                                                                            	// subsequent API invocation.
                                                                            	Limit int32
                                                                            
                                                                            	// Set to true if pagination should stop if the service returns a pagination token
                                                                            	// that matches the most recent token provided to the service.
                                                                            	StopOnDuplicateToken bool
                                                                            }

                                                                              ListTablesPaginatorOptions is the paginator options for ListTables

                                                                              type ListTagsForResourceInput

                                                                              type ListTagsForResourceInput struct {
                                                                              
                                                                              	// The Timestream resource with tags to be listed. This value is an Amazon Resource
                                                                              	// Name (ARN).
                                                                              	//
                                                                              	// This member is required.
                                                                              	ResourceARN *string
                                                                              }

                                                                              type ListTagsForResourceOutput

                                                                              type ListTagsForResourceOutput struct {
                                                                              
                                                                              	// The tags currently associated with the Timestream resource.
                                                                              	Tags []types.Tag
                                                                              
                                                                              	// Metadata pertaining to the operation's result.
                                                                              	ResultMetadata middleware.Metadata
                                                                              }

                                                                              type Options

                                                                              type Options struct {
                                                                              	// Set of options to modify how an operation is invoked. These apply to all
                                                                              	// operations invoked for this client. Use functional options on operation call to
                                                                              	// modify this list for per operation behavior.
                                                                              	APIOptions []func(*middleware.Stack) error
                                                                              
                                                                              	// Configures the events that will be sent to the configured logger.
                                                                              	ClientLogMode aws.ClientLogMode
                                                                              
                                                                              	// The credentials object to use when signing requests.
                                                                              	Credentials aws.CredentialsProvider
                                                                              
                                                                              	// The endpoint options to be used when attempting to resolve an endpoint.
                                                                              	EndpointOptions EndpointResolverOptions
                                                                              
                                                                              	// The service endpoint resolver.
                                                                              	EndpointResolver EndpointResolver
                                                                              
                                                                              	// Signature Version 4 (SigV4) Signer
                                                                              	HTTPSignerV4 HTTPSignerV4
                                                                              
                                                                              	// The logger writer interface to write logging messages to.
                                                                              	Logger logging.Logger
                                                                              
                                                                              	// The region to send requests to. (Required)
                                                                              	Region string
                                                                              
                                                                              	// Retryer guides how HTTP requests should be retried in case of recoverable
                                                                              	// failures. When nil the API client will use a default retryer.
                                                                              	Retryer aws.Retryer
                                                                              
                                                                              	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
                                                                              	// implementation if nil.
                                                                              	HTTPClient HTTPClient
                                                                              }

                                                                              func (Options) Copy

                                                                              func (o Options) Copy() Options

                                                                                Copy creates a clone where the APIOptions list is deep copied.

                                                                                type ResolveEndpoint

                                                                                type ResolveEndpoint struct {
                                                                                	Resolver EndpointResolver
                                                                                	Options  EndpointResolverOptions
                                                                                }

                                                                                func (*ResolveEndpoint) HandleSerialize

                                                                                func (*ResolveEndpoint) ID

                                                                                func (*ResolveEndpoint) ID() string

                                                                                type TagResourceInput

                                                                                type TagResourceInput struct {
                                                                                
                                                                                	// Identifies the Timestream resource to which tags should be added. This value is
                                                                                	// an Amazon Resource Name (ARN).
                                                                                	//
                                                                                	// This member is required.
                                                                                	ResourceARN *string
                                                                                
                                                                                	// The tags to be assigned to the Timestream resource.
                                                                                	//
                                                                                	// This member is required.
                                                                                	Tags []types.Tag
                                                                                }

                                                                                type TagResourceOutput

                                                                                type TagResourceOutput struct {
                                                                                	// Metadata pertaining to the operation's result.
                                                                                	ResultMetadata middleware.Metadata
                                                                                }

                                                                                type UntagResourceInput

                                                                                type UntagResourceInput struct {
                                                                                
                                                                                	// The Timestream resource that the tags will be removed from. This value is an
                                                                                	// Amazon Resource Name (ARN).
                                                                                	//
                                                                                	// This member is required.
                                                                                	ResourceARN *string
                                                                                
                                                                                	// A list of tags keys. Existing tags of the resource whose keys are members of
                                                                                	// this list will be removed from the Timestream resource.
                                                                                	//
                                                                                	// This member is required.
                                                                                	TagKeys []string
                                                                                }

                                                                                type UntagResourceOutput

                                                                                type UntagResourceOutput struct {
                                                                                	// Metadata pertaining to the operation's result.
                                                                                	ResultMetadata middleware.Metadata
                                                                                }

                                                                                type UpdateDatabaseInput

                                                                                type UpdateDatabaseInput struct {
                                                                                
                                                                                	// The name of the database.
                                                                                	//
                                                                                	// This member is required.
                                                                                	DatabaseName *string
                                                                                
                                                                                	// The identifier of the new KMS key (KmsKeyId) to be used to encrypt the data
                                                                                	// stored in the database. If the KmsKeyId currently registered with the database
                                                                                	// is the same as the KmsKeyId in the request, there will not be any update. You
                                                                                	// can specify the KmsKeyId using any of the following:
                                                                                	//
                                                                                	// * Key ID:
                                                                                	// 1234abcd-12ab-34cd-56ef-1234567890ab
                                                                                	//
                                                                                	// * Key ARN:
                                                                                	// arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
                                                                                	//
                                                                                	// *
                                                                                	// Alias name: alias/ExampleAlias
                                                                                	//
                                                                                	// * Alias ARN:
                                                                                	// arn:aws:kms:us-east-1:111122223333:alias/ExampleAlias
                                                                                	//
                                                                                	// This member is required.
                                                                                	KmsKeyId *string
                                                                                }

                                                                                type UpdateDatabaseOutput

                                                                                type UpdateDatabaseOutput struct {
                                                                                
                                                                                	// A top level container for a table. Databases and tables are the fundamental
                                                                                	// management concepts in Amazon Timestream. All tables in a database are encrypted
                                                                                	// with the same KMS key.
                                                                                	Database *types.Database
                                                                                
                                                                                	// Metadata pertaining to the operation's result.
                                                                                	ResultMetadata middleware.Metadata
                                                                                }

                                                                                type UpdateTableInput

                                                                                type UpdateTableInput struct {
                                                                                
                                                                                	// The name of the Timestream database.
                                                                                	//
                                                                                	// This member is required.
                                                                                	DatabaseName *string
                                                                                
                                                                                	// The retention duration of the memory store and the magnetic store.
                                                                                	//
                                                                                	// This member is required.
                                                                                	RetentionProperties *types.RetentionProperties
                                                                                
                                                                                	// The name of the Timesream table.
                                                                                	//
                                                                                	// This member is required.
                                                                                	TableName *string
                                                                                }

                                                                                type UpdateTableOutput

                                                                                type UpdateTableOutput struct {
                                                                                
                                                                                	// The updated Timestream table.
                                                                                	Table *types.Table
                                                                                
                                                                                	// Metadata pertaining to the operation's result.
                                                                                	ResultMetadata middleware.Metadata
                                                                                }

                                                                                type WriteRecordsInput

                                                                                type WriteRecordsInput struct {
                                                                                
                                                                                	// The name of the Timestream database.
                                                                                	//
                                                                                	// This member is required.
                                                                                	DatabaseName *string
                                                                                
                                                                                	// An array of records containing the unique dimension and measure attributes for
                                                                                	// each time series data point.
                                                                                	//
                                                                                	// This member is required.
                                                                                	Records []types.Record
                                                                                
                                                                                	// The name of the Timesream table.
                                                                                	//
                                                                                	// This member is required.
                                                                                	TableName *string
                                                                                
                                                                                	// A record containing the common measure and dimension attributes shared across
                                                                                	// all the records in the request. The measure and dimension attributes specified
                                                                                	// in here will be merged with the measure and dimension attributes in the records
                                                                                	// object when the data is written into Timestream.
                                                                                	CommonAttributes *types.Record
                                                                                }

                                                                                type WriteRecordsOutput

                                                                                type WriteRecordsOutput struct {
                                                                                	// Metadata pertaining to the operation's result.
                                                                                	ResultMetadata middleware.Metadata
                                                                                }

                                                                                Directories

                                                                                Path Synopsis
                                                                                internal