timestreamwrite

package
v1.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 19, 2026 License: MIT Imports: 24 Imported by: 0

README

Timestream Write

Parity grade: A · SDK aws-sdk-go-v2/service/timestreamwrite@v1.35.19 · last audited 2026-07-13 (df8c6377)

Coverage
Operations audited 19 (15 ok, 4 partial)
Feature families 1 (1 ok)
Known gaps 4
Deferred items 0
Resource leaks clean
Known gaps
  • UpdateDatabase does not enforce KmsKeyId as required (real UpdateDatabaseRequest marks it required) — not fixed, conflicts with an existing intentional test that uses empty string to clear the key (bd: file if desired)
  • UntagResource/ListTagsForResource never return ResourceNotFoundException for an unknown ARN (real API can) — not fixed, would require an interface signature change and conflicts with existing post-delete cleanup test assertions; AWS's own docs note the two outcomes are meant to be treated as equivalent for DeleteDatabase's ARN-cleanup race anyway (bd: file if desired)
  • CreateBatchLoadTask does not validate ReportConfiguration as required, and ClientToken is accepted but not used for idempotent dedup (bd: file if desired)
  • DescribeEndpoints Address is hardcoded "localhost" instead of echoing the request Host (sibling timestreamquery does echo it); verified inert for normal custom-endpoint usage, but would matter for tooling that inspects the raw response instead of relying on SDK routing (bd: file if desired, low priority)

More

Documentation

Index

Constants

View Source 
const (
	// BatchLoadStatusCreated indicates a task has been created and is pending execution.
	BatchLoadStatusCreated = "CREATED"
	// BatchLoadStatusInProgress indicates a task is currently loading data.
	BatchLoadStatusInProgress = "IN_PROGRESS"
	// BatchLoadStatusFailed indicates a task has failed.
	BatchLoadStatusFailed = "FAILED"
	// BatchLoadStatusSucceeded indicates a task completed successfully.
	BatchLoadStatusSucceeded = "SUCCEEDED"
	// BatchLoadStatusProgressStopped indicates a task was stopped before completion.
	BatchLoadStatusProgressStopped = "PROGRESS_STOPPED"
	// BatchLoadStatusPendingResume indicates a task is pending a resume operation.
	BatchLoadStatusPendingResume = "PENDING_RESUME"
)

Variables

View Source 
var (
	// ErrDatabaseNotFound is returned when the requested database does not exist.
	ErrDatabaseNotFound = awserr.New("ResourceNotFoundException", awserr.ErrNotFound)
	// ErrTableNotFound is returned when the requested table does not exist.
	ErrTableNotFound = awserr.New("ResourceNotFoundException", awserr.ErrNotFound)
	// ErrDatabaseAlreadyExists is returned when a database with the same name already exists.
	ErrDatabaseAlreadyExists = awserr.New("ConflictException", awserr.ErrConflict)
	// ErrTableAlreadyExists is returned when a table with the same name already exists.
	ErrTableAlreadyExists = awserr.New("ConflictException", awserr.ErrConflict)
	// ErrBatchLoadTaskNotFound is returned when the requested batch load task does not exist.
	ErrBatchLoadTaskNotFound = awserr.New("ResourceNotFoundException", awserr.ErrNotFound)
	// ErrInvalidBatchLoadStatus is returned when a task cannot be resumed from its current status.
	ErrInvalidBatchLoadStatus = awserr.New("ValidationException", awserr.ErrInvalidParameter)
	// ErrValidation is returned for invalid request parameters.
	ErrValidation = awserr.New("ValidationException", awserr.ErrInvalidParameter)
	// ErrResourceNotFound is returned when tagging an ARN that is not registered in the backend.
	ErrResourceNotFound = awserr.New("ResourceNotFoundException", awserr.ErrNotFound)
)
View Source 
var ErrNilAppContext = errors.New("timestreamwrite: nil app context")

ErrNilAppContext is returned when Init is called with a nil AppContext.

View Source 
var ErrRejectedRecords = &RejectedRecordsError{}

ErrRejectedRecords is the sentinel used with errors.Is for RejectedRecordsError.

Functions

This section is empty.

Types

type BatchLoadProgressReport 

type BatchLoadProgressReport struct {
	BytesMetered            int64 `json:"bytes_metered,omitempty"`
	FileFailures            int64 `json:"file_failures,omitempty"`
	ParseFailures           int64 `json:"parse_failures,omitempty"`
	RecordIngestionFailures int64 `json:"record_ingestion_failures,omitempty"`
	RecordsIngested         int64 `json:"records_ingested,omitempty"`
	RecordsProcessed        int64 `json:"records_processed,omitempty"`
}

BatchLoadProgressReport captures incremental progress metrics for a batch load task.

type BatchLoadTask 

type BatchLoadTask struct {
	CreationTime            time.Time                `json:"creation_time"`
	LastUpdatedTime         time.Time                `json:"last_updated_time"`
	ResumableUntil          *time.Time               `json:"resumable_until,omitempty"`
	DataSourceConfiguration *DataSourceConfiguration `json:"data_source_configuration,omitempty"`
	ReportConfiguration     *ReportConfiguration     `json:"report_configuration,omitempty"`
	ProgressReport          *BatchLoadProgressReport `json:"progress_report,omitempty"`
	TargetDatabaseName      string                   `json:"target_database_name"`
	TargetTableName         string                   `json:"target_table_name"`
	TaskID                  string                   `json:"task_id"`
	TaskStatus              string                   `json:"task_status"`
	ErrorMessage            string                   `json:"error_message,omitempty"`
	RecordVersion           int64                    `json:"record_version,omitempty"`
}

BatchLoadTask represents a Timestream batch load task.

type CreateTableInput 

type CreateTableInput struct {
	RetentionProperties          *RetentionProperties
	MagneticStoreWriteProperties *MagneticStoreWriteProperties
	Schema                       *Schema
}

CreateTableInput holds the parameters for creating a table.

type DataSourceConfiguration 

type DataSourceConfiguration struct {
	DataSourceS3Configuration *DataSourceS3Configuration `json:"DataSourceS3Configuration,omitempty"`
	DataFormat                string                     `json:"DataFormat,omitempty"`
}

DataSourceConfiguration holds the data source for a batch load task.

type DataSourceS3Configuration 

type DataSourceS3Configuration struct {
	BucketName      string `json:"BucketName"`
	ObjectKeyPrefix string `json:"ObjectKeyPrefix,omitempty"`
	DataFormat      string `json:"DataFormat,omitempty"`
}

DataSourceS3Configuration holds S3 source configuration for batch loads.

type Database 

type Database struct {
	CreationTime    time.Time `json:"creation_time"`
	LastUpdatedTime time.Time `json:"last_updated_time"`
	DatabaseName    string    `json:"database_name"`
	ARN             string    `json:"arn"`
	KmsKeyID        string    `json:"kms_key_id,omitempty"`
	TableCount      int       `json:"table_count"`
}

Database represents a Timestream database.

type Dimension 

type Dimension struct {
	Name               string `json:"name"`
	Value              string `json:"value"`
	DimensionValueType string `json:"dimension_value_type,omitempty"`
}

Dimension holds a name/value pair for a time-series record.

type Handler 

type Handler struct {
	Backend *InMemoryBackend
	// contains filtered or unexported fields
}

Handler is the Echo HTTP handler for Amazon Timestream Write operations.

func NewHandler 

func NewHandler(backend *InMemoryBackend) *Handler

NewHandler creates a new Timestream Write handler.

func (*Handler) ChaosOperations 

func (h *Handler) ChaosOperations() []string

ChaosOperations returns all operations that can be fault-injected.

func (*Handler) ChaosRegions 

func (h *Handler) ChaosRegions() []string

ChaosRegions returns all regions this handler covers.

func (*Handler) ChaosServiceName 

func (h *Handler) ChaosServiceName() string

ChaosServiceName returns the lowercase AWS service name for fault rule matching.

func (*Handler) ExtractOperation 

func (h *Handler) ExtractOperation(c *echo.Context) string

ExtractOperation extracts the Timestream Write action from the X-Amz-Target header.

func (*Handler) ExtractResource 

func (h *Handler) ExtractResource(_ *echo.Context) string

ExtractResource returns an empty string (no meaningful resource in request body for routing).

func (*Handler) GetSupportedOperations 

func (h *Handler) GetSupportedOperations() []string

GetSupportedOperations returns the list of supported Timestream Write operations.

func (*Handler) Handler 

func (h *Handler) Handler() echo.HandlerFunc

Handler returns the Echo handler function.

func (*Handler) MatchPriority 

func (h *Handler) MatchPriority() int

MatchPriority returns the routing priority.

func (*Handler) Name 

func (h *Handler) Name() string

Name returns the service name.

func (*Handler) Reset 

func (h *Handler) Reset()

Reset clears the backend state and rebuilds the dispatch table.

func (*Handler) Restore 

func (h *Handler) Restore(ctx context.Context, data []byte) error

Restore implements persistence.Persistable by delegating to the backend.

func (*Handler) RouteMatcher 

func (h *Handler) RouteMatcher() service.Matcher

RouteMatcher returns a function that matches Timestream Write requests. It only matches operations explicitly supported by this handler to avoid intercepting operations belonging to other Timestream services (e.g. TimestreamQuery) that share the same X-Amz-Target prefix.

func (*Handler) Snapshot 

func (h *Handler) Snapshot(ctx context.Context) []byte

Snapshot implements persistence.Persistable by delegating to the backend.

h.Backend is *InMemoryBackend (a concrete type, not the StorageBackend interface), so no type assertion is needed here -- but its methods are still not promoted to Handler, since Backend is a named field rather than an embedded one. Without this delegation, cli.go's setupPersistence type-asserts the registered service.Registerable (this *Handler) against persistence.Persistable, fails silently, and never registers timestreamwrite for snapshot/restore despite the backend being fully capable. Mirrors services/securityhub's Handler-level delegation.

InMemoryBackend.Snapshot has a different shape than persistence.Persistable (no ctx parameter, and it returns an error instead of logging one itself), so this adapts: it calls the backend's Snapshot() and logs+swallows any marshal error, matching the Persistable contract (a nil snapshot is skipped by the persistence Manager).

func (*Handler) StartWorker 

func (h *Handler) StartWorker(ctx context.Context) error

StartWorker starts the background janitor for Timestream record retention.

type InMemoryBackend 

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

InMemoryBackend is the in-memory store for Timestream Write resources.

func NewInMemoryBackend 

func NewInMemoryBackend() *InMemoryBackend

NewInMemoryBackend creates a new InMemoryBackend.

func (*InMemoryBackend) AccountID 

func (b *InMemoryBackend) AccountID() string

AccountID returns the simulated AWS account ID.

func (*InMemoryBackend) AddBatchLoadTaskInternal 

func (b *InMemoryBackend) AddBatchLoadTaskInternal(task *BatchLoadTask)

AddBatchLoadTaskInternal directly inserts a batch load task, bypassing validation. Intended only for test setup.

func (*InMemoryBackend) AddDatabaseInternal 

func (b *InMemoryBackend) AddDatabaseInternal(db *Database)

AddDatabaseInternal directly inserts a database into the backend, bypassing validation. Intended only for test setup.

func (*InMemoryBackend) AddTableInternal 

func (b *InMemoryBackend) AddTableInternal(tbl *Table)

AddTableInternal directly inserts a table into the backend, bypassing validation. The parent database must exist. Intended only for test setup.

func (*InMemoryBackend) CreateBatchLoadTask 

func (b *InMemoryBackend) CreateBatchLoadTask(
	targetDatabase, targetTable string,
	dataSourceCfg *DataSourceConfiguration,
	reportCfg *ReportConfiguration,
) (*BatchLoadTask, error)

CreateBatchLoadTask creates a new batch load task targeting the specified database and table.

func (*InMemoryBackend) CreateDatabase 

func (b *InMemoryBackend) CreateDatabase(name, kmsKeyID string, tags map[string]string) (*Database, error)

CreateDatabase creates a new Timestream database with an optional KMS key and initial tags. KmsKeyID is applied atomically at creation time (matching the AWS API, which accepts KmsKeyId directly on CreateDatabaseInput) so CreationTime and LastUpdatedTime stay equal on the returned Database, and no other request can observe the database without its KMS key in between.

func (*InMemoryBackend) CreateTable 

func (b *InMemoryBackend) CreateTable(
	dbName, tblName string,
	tags map[string]string,
	inp *CreateTableInput,
) (*Table, error)

CreateTable creates a new table in the specified database with optional initial tags.

func (*InMemoryBackend) DeleteDatabase 

func (b *InMemoryBackend) DeleteDatabase(name string) error

DeleteDatabase deletes a database and all its tables.

func (*InMemoryBackend) DeleteTable 

func (b *InMemoryBackend) DeleteTable(dbName, tblName string) error

DeleteTable deletes a table from a database.

func (*InMemoryBackend) DescribeBatchLoadTask 

func (b *InMemoryBackend) DescribeBatchLoadTask(taskID string) (*BatchLoadTask, error)

DescribeBatchLoadTask returns information about a batch load task.

func (*InMemoryBackend) DescribeDatabase 

func (b *InMemoryBackend) DescribeDatabase(name string) (*Database, error)

DescribeDatabase returns information about a database.

func (*InMemoryBackend) DescribeTable 

func (b *InMemoryBackend) DescribeTable(dbName, tblName string) (*Table, error)

DescribeTable returns information about a table.

func (*InMemoryBackend) ListBatchLoadTasks 

func (b *InMemoryBackend) ListBatchLoadTasks(statusFilter string) []BatchLoadTask

ListBatchLoadTasks returns all batch load tasks, optionally filtered by status. Results are sorted by creation time (oldest first).

func (*InMemoryBackend) ListDatabases 

func (b *InMemoryBackend) ListDatabases() []Database

ListDatabases returns all databases sorted by name.

func (*InMemoryBackend) ListTables 

func (b *InMemoryBackend) ListTables(dbName string) ([]Table, error)

ListTables returns all tables in a database sorted by name.

func (*InMemoryBackend) ListTagsForResource 

func (b *InMemoryBackend) ListTagsForResource(arn string) map[string]string

ListTagsForResource returns tags for the given ARN.

func (*InMemoryBackend) Region 

func (b *InMemoryBackend) Region() string

Region returns the simulated AWS region.

func (*InMemoryBackend) Reset 

func (b *InMemoryBackend) Reset()

Reset clears all stored state, returning the backend to its initial empty state.

func (*InMemoryBackend) Restore 

func (b *InMemoryBackend) Restore(ctx context.Context, data []byte) error

Restore replaces the backend state with the data from a previous Snapshot call.

func (*InMemoryBackend) ResumeBatchLoadTask 

func (b *InMemoryBackend) ResumeBatchLoadTask(taskID string) error

ResumeBatchLoadTask resumes a batch load task that is in PENDING_RESUME or FAILED status.

func (*InMemoryBackend) SetBatchLoadTaskStatus 

func (b *InMemoryBackend) SetBatchLoadTaskStatus(taskID, status string) error

SetBatchLoadTaskStatus sets the status of a batch load task. This is a test seed helper to set specific task states.

func (*InMemoryBackend) Snapshot 

func (b *InMemoryBackend) Snapshot() ([]byte, error)

Snapshot serialises the current backend state into a JSON byte slice.

Holds the global write lock to serialise against WriteRecords, which only holds the global read lock and writes to the inner b.records map; concurrent map iteration here and map write there would be a fatal Go data race.

func (*InMemoryBackend) SweepRetention 

func (b *InMemoryBackend) SweepRetention(ctx context.Context)

SweepRetention prunes records that exceed the memory store retention period.

func (*InMemoryBackend) TagResource 

func (b *InMemoryBackend) TagResource(arn string, tags map[string]string) error

TagResource stores tags for the given ARN. It accepts database, table, and scheduled-query ARNs because the Timestream Write and Query services share a single TagResource endpoint.

func (*InMemoryBackend) UntagResource 

func (b *InMemoryBackend) UntagResource(arn string, tagKeys []string) error

UntagResource removes tag keys from the given ARN.

func (*InMemoryBackend) UpdateDatabase 

func (b *InMemoryBackend) UpdateDatabase(name, kmsKeyID string) (*Database, error)

UpdateDatabase updates the KMS key for a database.

func (*InMemoryBackend) UpdateTable 

func (b *InMemoryBackend) UpdateTable(dbName, tblName string, inp *UpdateTableInput) (*Table, error)

UpdateTable updates a table's properties.

func (*InMemoryBackend) WriteRecords 

func (b *InMemoryBackend) WriteRecords(dbName, tblName string, records []Record) (*WriteRecordsOutput, error)

WriteRecords appends records to the specified table.

Lock ordering: global RLock first, then per-table WLock on the *tableRecords slot. The global read lock prevents structural changes (CreateTable/DeleteTable/CreateDatabase/DeleteDatabase) from racing with writes; the slot's write lock serialises concurrent writes to the same table while allowing writes to different tables to proceed in parallel.

Records are mutated through the slot pointer (slot.records = append(...)) rather than the enclosing map, so two writers in different tables of the same database never write to the b.records[dbName] map concurrently.

type Janitor 

type Janitor struct {
	Backend  *InMemoryBackend
	Interval time.Duration
}

Janitor is the Timestream background worker that enforces record retention.

func NewJanitor 

func NewJanitor(backend *InMemoryBackend) *Janitor

NewJanitor creates a new Timestream Janitor.

func (*Janitor) Run 

func (j *Janitor) Run(ctx context.Context)

Run runs the janitor loop until ctx is cancelled.

type MagneticStoreRejectedDataLocation 

type MagneticStoreRejectedDataLocation struct {
	S3Configuration *S3Configuration `json:"s3_configuration,omitempty"`
}

MagneticStoreRejectedDataLocation configures where rejected magnetic-store records are written.

type MagneticStoreWriteProperties 

type MagneticStoreWriteProperties struct {
	MagneticStoreRejectedDataLocation *MagneticStoreRejectedDataLocation `json:"magnetic_store_rejected_data_location,omitempty"` //nolint:lll // AWS field name is inherently long
	EnableMagneticStoreWrites         bool                               `json:"enable_magnetic_store_writes"`
}

MagneticStoreWriteProperties configures magnetic store writes and rejected-record delivery.

type MeasureValue 

type MeasureValue struct {
	Name  string `json:"name"`
	Value string `json:"value"`
	Type  string `json:"type"`
}

MeasureValue holds a name-value-type triple for multi-measure (MULTI type) records.

type PartitionKey 

type PartitionKey struct {
	Type                PartitionKeyType             `json:"type"`
	Name                string                       `json:"name,omitempty"`
	EnforcementInRecord PartitionKeyEnforcementLevel `json:"enforcement_in_record,omitempty"`
}

PartitionKey defines a single key in a table's composite partition key schema.

type PartitionKeyEnforcementLevel 

type PartitionKeyEnforcementLevel = string

PartitionKeyEnforcementLevel controls whether a dimension partition key is required on write. 

const (
	PartitionKeyEnforcementRequired PartitionKeyEnforcementLevel = "REQUIRED"
	PartitionKeyEnforcementOptional PartitionKeyEnforcementLevel = "OPTIONAL"
)

type PartitionKeyType 

type PartitionKeyType = string

PartitionKeyType specifies whether a partition key is a dimension or measure key. 

const (
	PartitionKeyTypeDimension PartitionKeyType = "DIMENSION"
	PartitionKeyTypeMeasure   PartitionKeyType = "MEASURE"
)

type Provider 

type Provider struct{}

Provider implements service.Provider for Amazon Timestream Write.

func (*Provider) Init 

func (p *Provider) Init(ctx *service.AppContext) (service.Registerable, error)

Init initializes the Timestream Write service backend and handler.

func (*Provider) Name 

func (p *Provider) Name() string

Name returns the provider name.

type Record 

type Record struct {
	// InternalTimestamp is the parsed value of Time, used for retention sweeping.
	InternalTimestamp time.Time      `json:"-"`
	MeasureName       string         `json:"measure_name"`
	MeasureValue      string         `json:"measure_value"`
	MeasureValueType  string         `json:"measure_value_type"`
	Time              string         `json:"time"`
	TimeUnit          string         `json:"time_unit"`
	Dimensions        []Dimension    `json:"dimensions,omitempty"`
	MeasureValues     []MeasureValue `json:"measure_values,omitempty"`
	Version           int64          `json:"version,omitempty"`
}

Record represents a time-series data point written to a table.

type RejectedRecord 

type RejectedRecord struct {
	Reason          string `json:"Reason"`
	ExistingVersion int64  `json:"ExistingVersion,omitempty"`
	RecordIndex     int    `json:"RecordIndex"`
}

RejectedRecord describes a single record that could not be written due to a version conflict.

type RejectedRecordsError 

type RejectedRecordsError struct {
	RejectedRecords []RejectedRecord
}

RejectedRecordsError is returned by WriteRecords when one or more records are rejected due to version conflicts.

func (*RejectedRecordsError) Error 

func (e *RejectedRecordsError) Error() string

func (*RejectedRecordsError) Is 

func (e *RejectedRecordsError) Is(target error) bool

Is satisfies errors.Is so that errors.Is(err, ErrRejectedRecords) returns true.

type ReportConfiguration 

type ReportConfiguration struct {
	ReportS3Configuration *DataSourceS3Configuration `json:"ReportS3Configuration,omitempty"`
}

ReportConfiguration holds the report output configuration for a batch load task.

type RetentionProperties 

type RetentionProperties struct {
	MemoryStoreRetentionPeriodInHours  int64 `json:"MemoryStoreRetentionPeriodInHours,omitempty"`
	MagneticStoreRetentionPeriodInDays int64 `json:"MagneticStoreRetentionPeriodInDays,omitempty"`
}

RetentionProperties holds the memory and magnetic store retention durations.

type S3Configuration 

type S3Configuration struct {
	BucketName       string `json:"bucket_name,omitempty"`
	ObjectKeyPrefix  string `json:"object_key_prefix,omitempty"`
	EncryptionOption string `json:"encryption_option,omitempty"`
	KmsKeyID         string `json:"kms_key_id,omitempty"`
}

S3Configuration holds S3 location config for rejected-record delivery.

type Schema 

type Schema struct {
	CompositePartitionKey []PartitionKey `json:"composite_partition_key,omitempty"`
}

Schema defines the composite partition key configuration for a table.

type StorageBackend 

type StorageBackend interface {
	// Database operations.
	CreateDatabase(name, kmsKeyID string, tags map[string]string) (*Database, error)
	DescribeDatabase(name string) (*Database, error)
	ListDatabases() []Database
	DeleteDatabase(name string) error
	UpdateDatabase(name, kmsKeyID string) (*Database, error)

	// Table operations.
	CreateTable(dbName, tblName string, tags map[string]string, inp *CreateTableInput) (*Table, error)
	DescribeTable(dbName, tblName string) (*Table, error)
	ListTables(dbName string) ([]Table, error)
	DeleteTable(dbName, tblName string) error
	UpdateTable(dbName, tblName string, inp *UpdateTableInput) (*Table, error)

	// Record operations.
	WriteRecords(dbName, tblName string, records []Record) (*WriteRecordsOutput, error)

	// Tag operations.
	TagResource(arn string, tags map[string]string) error
	UntagResource(arn string, tagKeys []string) error
	ListTagsForResource(arn string) map[string]string

	// Batch load task operations.
	CreateBatchLoadTask(
		targetDatabase, targetTable string,
		dataSourceCfg *DataSourceConfiguration,
		reportCfg *ReportConfiguration,
	) (*BatchLoadTask, error)
	DescribeBatchLoadTask(taskID string) (*BatchLoadTask, error)
	ListBatchLoadTasks(statusFilter string) []BatchLoadTask
	ResumeBatchLoadTask(taskID string) error

	// Lifecycle operations.
	Reset()
	AccountID() string
	Region() string
}

StorageBackend defines the interface for Timestream Write backend implementations. All mutating methods must be safe for concurrent use.

type Table 

type Table struct {
	CreationTime                 time.Time                     `json:"creation_time"`
	LastUpdatedTime              time.Time                     `json:"last_updated_time"`
	RetentionProperties          *RetentionProperties          `json:"retention_properties,omitempty"`
	MagneticStoreWriteProperties *MagneticStoreWriteProperties `json:"magnetic_store_write_properties,omitempty"`
	Schema                       *Schema                       `json:"schema,omitempty"`
	DatabaseName                 string                        `json:"database_name"`
	TableName                    string                        `json:"table_name"`
	ARN                          string                        `json:"arn"`
	TableStatus                  string                        `json:"table_status"`
}

Table represents a Timestream table within a database.

type UpdateTableInput 

type UpdateTableInput struct {
	RetentionProperties          *RetentionProperties
	MagneticStoreWriteProperties *MagneticStoreWriteProperties
	Schema                       *Schema
}

UpdateTableInput holds the parameters for updating a table.

type WriteRecordsOutput 

type WriteRecordsOutput struct {
	RejectedRecords []RejectedRecord
	// Total is the total number of records successfully ingested.
	Total int32
	// MemoryStore is the count of records written to the memory store
	// (records whose timestamp falls within the memory retention window).
	MemoryStore int32
	// MagneticStore is the count of records written to the magnetic store
	// (records whose timestamp is outside the memory retention window and the
	// table has magnetic store writes enabled).
	MagneticStore int32
}

WriteRecordsOutput summarises the results of a WriteRecords call.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.