Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

helixddb

package module

Go to main page

Versions in this module

v0

v0.5.0

Sep 23, 2023

v0.4.0

Aug 8, 2023

v0.3.0

Jun 14, 2023

Changes in this version

type ConditionCheck

+ func (check *ConditionCheck) SortKey(rangeKey string, value interface{}) *ConditionCheck

type Delete

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

type Keyed

+ PartitionKey func() interface{}

+ SortKey func() interface{}

type Keys

+ func (k Keys) PartitionKey() interface{}

+ func (k Keys) SortKey() interface{}

type Query

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

type Update

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

v0.2.0

Mar 28, 2023

v0.1.0

Mar 28, 2023

Changes in this version

+ var AllProjection = IndexProjection(types.ProjectionTypeAll)

+ var ErrNoInput = errors.New("dynamo: no input items")

+ var ErrNotFound = errors.New("dynamo: no item found")

+ var ErrTooMany = errors.New("dynamo: too many items")

+ var IncludeProjection = IndexProjection(types.ProjectionTypeInclude)

+ var KeysOnlyProjection = IndexProjection(types.ProjectionTypeKeysOnly)

+ var KeysOnlyView = StreamView(types.StreamViewTypeKeysOnly)

+ var NewAndOldImagesView = StreamView(types.StreamViewTypeNewAndOldImages)

+ var NewImageView = StreamView(types.StreamViewTypeNewImage)

+ var OldImageView = StreamView(types.StreamViewTypeOldImage)

+ var RetryTimeout = 1 * time.Minute

+ func IsCondCheckFailed(err error) bool

+ func Marshal(v interface{}) (types.AttributeValue, error)

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

+ func Unmarshal(av types.AttributeValue, out interface{}) error

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

+ type Batch struct

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

+ func (b Batch) Write() *BatchWrite

+ type BatchGet struct

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

+ func (bg *BatchGet) AllWithContext(ctx context.Context, out interface{}) error

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

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

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

+ func (bg *BatchGet) Iter() Iter

+ func (bg *BatchGet) Project(paths ...string) *BatchGet

+ type BatchWrite struct

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

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

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

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

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

+ type Coder interface

+ func AWSEncoding(v interface{}) Coder

+ type ConditionCheck struct

+ func (check *ConditionCheck) If(expr string, args ...interface{}) *ConditionCheck

+ func (check *ConditionCheck) IfExists() *ConditionCheck

+ func (check *ConditionCheck) IfNotExists() *ConditionCheck

+ func (check *ConditionCheck) Range(rangeKey string, value interface{}) *ConditionCheck

+ type ConsumedCapacity struct

+ GSI map[string]float64

+ GSIRead map[string]float64

+ GSIWrite map[string]float64

+ LSI map[string]float64

+ LSIRead map[string]float64

+ LSIWrite map[string]float64

+ Read float64

+ Table float64

+ TableName string

+ TableRead float64

+ TableWrite float64

+ Total float64

+ Write float64

+ type CreateTable struct

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

+ func (ct *CreateTable) OnDemand(enabled bool) *CreateTable

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

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

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

+ func (ct *CreateTable) Run() error

+ func (ct *CreateTable) RunWithContext(ctx context.Context) error

+ func (ct *CreateTable) SSEEncryption(enabled bool, keyID string, sseType SSEType) *CreateTable

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

+ func (ct *CreateTable) Tag(key, value string) *CreateTable

+ func (ct *CreateTable) Wait() error

+ func (ct *CreateTable) WaitWithContext(ctx context.Context) error

+ type DB struct

+ func New(cfg aws.Config) *DB

+ func NewFromIface(client helixddbdbiface.DynamoDBAPI) *DB

+ func (db *DB) Client() helixddbdbiface.DynamoDBAPI

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

+ func (db *DB) GetTx() *GetTx

+ func (db *DB) ListTables() *ListTables

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

+ func (db *DB) WriteTx() *WriteTx

+ type Delete struct

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

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

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

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

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

+ func (d *Delete) Run() error

+ func (d *Delete) RunWithContext(ctx context.Context) error

+ type DeleteTable struct

+ func (dt *DeleteTable) Run() error

+ func (dt *DeleteTable) RunWithContext(ctx context.Context) error

+ func (dt *DeleteTable) Wait() error

+ func (dt *DeleteTable) WaitWithContext(ctx context.Context) error

+ type DescribeTTL struct

+ func (d *DescribeTTL) Run() (TTLDescription, error)

+ func (d *DescribeTTL) RunWithContext(ctx context.Context) (TTLDescription, error)

+ type DescribeTable struct

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

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

+ type Description struct

+ ARN string

+ Created time.Time

+ GSI []Index

+ HashKey string

+ HashKeyType KeyType

+ Items int64

+ LSI []Index

+ LatestStreamARN string

+ LatestStreamLabel string

+ Name string

+ OnDemand bool

+ RangeKey string

+ RangeKeyType KeyType

+ SSEDescription SSEDescription

+ Size int64

+ Status Status

+ StreamEnabled bool

+ StreamView StreamView

+ Throughput Throughput

+ func (d Description) Active() bool

+ type ExpressionLiteral struct

+ AttributeNames map[string]*string

+ AttributeValues map[string]types.AttributeValue

+ Expression string

+ type GetTx struct

+ func (tx *GetTx) All(out interface{}) error

+ func (tx *GetTx) AllWithContext(ctx context.Context, out interface{}) error

+ func (tx *GetTx) ConsumedCapacity(cc *ConsumedCapacity) *GetTx

+ func (tx *GetTx) Get(q *Query) *GetTx

+ func (tx *GetTx) GetOne(q *Query, out interface{}) *GetTx

+ func (tx *GetTx) Run() error

+ func (tx *GetTx) RunWithContext(ctx context.Context) error

+ type Index struct

+ ARN string

+ Backfilling bool

+ HashKey string

+ HashKeyType KeyType

+ Items int64

+ Local bool

+ Name string

+ ProjectionAttribs []string

+ ProjectionType IndexProjection

+ RangeKey string

+ RangeKeyType KeyType

+ Size int64

+ Status Status

+ Throughput Throughput

+ type IndexProjection string

+ type ItemMarshaler interface

+ MarshalDynamoItem func() (map[string]types.AttributeValue, error)

+ type ItemUnmarshaler interface

+ UnmarshalDynamoItem func(item map[string]types.AttributeValue) error

+ type Iter interface

+ Err func() error

+ Next func(out interface{}) bool

+ NextWithContext func(ctx context.Context, out interface{}) bool

+ type KeyType string

+ const BinaryType

+ const NoneType

+ const NumberType

+ const StringType

+ type Keyed interface

+ HashKey func() interface{}

+ RangeKey func() interface{}

+ type Keys [2]interface

+ func (k Keys) HashKey() interface{}

+ func (k Keys) RangeKey() interface{}

+ type ListTables struct

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

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

+ func (lt *ListTables) Iter() Iter

+ type Marshaler interface

+ MarshalDynamo func() (types.AttributeValue, error)

+ type Operator string

+ const BeginsWith

+ const Between

+ const Equal

+ const Greater

+ const GreaterOrEqual

+ const Less

+ const LessOrEqual

+ const NotEqual

+ type Order bool

+ const Ascending

+ const Descending

+ type PagingIter interface

+ LastEvaluatedKey func() PagingKey

+ type PagingKey map[string]types.AttributeValue

+ type Put struct

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

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

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

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

+ func (p *Put) Run() error

+ func (p *Put) RunWithContext(ctx context.Context) error

+ type Query struct

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

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

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

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

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

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

+ func (q *Query) Count() (int32, error)

+ func (q *Query) CountWithContext(ctx context.Context) (int32, error)

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

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

+ func (q *Query) Iter() PagingIter

+ func (q *Query) Limit(limit int32) *Query

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

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

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

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

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

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

+ func (q *Query) SearchLimit(limit int32) *Query

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

+ type SSEDescription struct

+ InaccessibleEncryptionDateTime time.Time

+ KMSMasterKeyArn string

+ SSEType types.SSEType

+ Status types.SSEStatus

+ type SSEType string

+ const SSETypeAES256

+ const SSETypeKMS

+ type Scan struct

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

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

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

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

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

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

+ func (s *Scan) Count() (int32, error)

+ func (s *Scan) CountWithContext(ctx context.Context) (int32, error)

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

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

+ func (s *Scan) Iter() PagingIter

+ func (s *Scan) Limit(limit int32) *Scan

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

+ func (s *Scan) SearchLimit(limit int32) *Scan

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

+ type Status string

+ const ActiveStatus

+ const CreatingStatus

+ const DeletingStatus

+ const NotExistsStatus

+ const UpdatingStatus

+ type StreamView string

+ type TTLDescription struct

+ Attribute string

+ Status TTLStatus

+ func (td TTLDescription) Enabled() bool

+ type TTLStatus string

+ const TTLDisabled

+ const TTLDisabling

+ const TTLEnabled

+ const TTLEnabling

+ type Table struct

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

+ func (table Table) Check(hashKey string, value interface{}) *ConditionCheck

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

+ func (table Table) DeleteTable() *DeleteTable

+ func (table Table) Describe() *DescribeTable

+ func (table Table) DescribeTTL() *DescribeTTL

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

+ func (table Table) Name() string

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

+ func (table Table) Scan() *Scan

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

+ func (table Table) UpdateTTL(attribute string, enabled bool) *UpdateTTL

+ func (table Table) UpdateTable() *UpdateTable

+ func (table Table) Wait(want ...Status) error

+ func (table Table) WaitWithContext(ctx context.Context, want ...Status) error

+ type Throughput struct

+ DecsToday int64

+ LastDec time.Time

+ LastInc time.Time

+ Read int64

+ Write int64

+ type Unmarshaler interface

+ UnmarshalDynamo func(av types.AttributeValue) error

+ type Update struct

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (u *Update) OnlyUpdatedOldValue(out interface{}) error

+ func (u *Update) OnlyUpdatedOldValueWithContext(ctx context.Context, out interface{}) error

+ func (u *Update) OnlyUpdatedValue(out interface{}) error

+ func (u *Update) OnlyUpdatedValueWithContext(ctx context.Context, out interface{}) error

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

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

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

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

+ func (u *Update) Run() error

+ func (u *Update) RunWithContext(ctx context.Context) error

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

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

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

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

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

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

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

+ type UpdateTTL struct

+ func (ttl *UpdateTTL) Run() error

+ func (ttl *UpdateTTL) RunWithContext(ctx context.Context) error

+ type UpdateTable struct

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

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

+ func (ut *UpdateTable) DisableStream() *UpdateTable

+ func (ut *UpdateTable) OnDemand(enabled bool) *UpdateTable

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

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

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

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

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

+ type WriteTx struct

+ func (tx *WriteTx) Check(check *ConditionCheck) *WriteTx

+ func (tx *WriteTx) ConsumedCapacity(cc *ConsumedCapacity) *WriteTx

+ func (tx *WriteTx) Delete(d *Delete) *WriteTx

+ func (tx *WriteTx) Idempotent(enabled bool) *WriteTx

+ func (tx *WriteTx) IdempotentWithToken(token string) *WriteTx

+ func (tx *WriteTx) Put(p *Put) *WriteTx

+ func (tx *WriteTx) Run() error

+ func (tx *WriteTx) RunWithContext(ctx context.Context) error

+ func (tx *WriteTx) Update(u *Update) *WriteTx