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

backends

package

Go to main page

Versions in this module

v3

v3.7.8

Feb 25, 2022

v3.7.7

Feb 25, 2022

v3.7.6

Feb 23, 2022

v3.7.5

Jan 25, 2022

v3.7.4

Jan 25, 2022

v3.7.3

Jan 25, 2022

v3.7.2

Jan 25, 2022

v3.7.1

Jan 25, 2022

v3.7.0

Jan 24, 2022

v3.6.0

Jan 11, 2022

v3.5.7

Sep 1, 2021

v3.5.6

Sep 1, 2021

v3.5.5

Sep 1, 2021

v3.5.4

Sep 1, 2021

v3.5.3

Sep 1, 2021

v3.5.2

Sep 1, 2021

v3.5.1

Sep 1, 2021

v3.5.0

Sep 1, 2021

v3.4.1

Aug 30, 2021

v3.4.0

Aug 30, 2021

Changes in this version

+ const DefaultFilesystemRecordSubdirectory

+ const FormatCSV

+ const FormatJSON

+ const FormatYAML

+ var AutopingTimeout = 5 * time.Second

+ var BleveBatchFlushCount = 1

+ var BleveBatchFlushInterval = 10 * time.Second

+ var BleveIdentityField = `_id`

+ var DefaultAmazonRegion = `us-east-1`

+ var DefaultAutoregister = false

+ var DefaultCompoundJoiner = `:`

+ var DefaultConnectTimeout = 10 * time.Second

+ var DefaultSharedCredentialsFile = `~/.aws/credentials`

+ var DefaultSharedCredentialsProfile = `default`

+ var ElasticsearchBatchFlushCount = 1

+ var ElasticsearchBatchFlushInterval = 10 * time.Second

+ var ElasticsearchConnectTimeout = 3 * time.Second

+ var ElasticsearchDocumentType = `document`

+ var ElasticsearchIdentityField = `_id`

+ var ElasticsearchRequestTimeout = 30 * time.Second

+ var ElasticsearchResponseHeaderTimeout = 10 * time.Second

+ var ElasticsearchTLSTimeout = 10 * time.Second

+ var FilesystemRecordCacheSize = 1024

+ var IndexerPageSize int = 100

+ var IndexerResultsStop = fmt.Errorf(`stop indexer results`)

+ var InitialPingTimeout = time.Duration(10) * time.Second

+ var MaxFacetCardinality int = 10000

+ var MongoIdentityField = `_id`

+ var NotImplementedError = fmt.Errorf("Not Implemented")

+ var RecordCacheEnabled = false

+ var RedisDefaultAddress = `localhost:6379`

+ var RedisDefaultProtocol = `tcp`

+ var SqlArrayFieldHintLength = 131069

+ var SqlObjectFieldHintLength = 131071

+ var WriteLockFormat = `%s.lock`

+ func DefaultQueryImplementation(indexer Indexer, collection *dal.Collection, f *filter.Filter, ...) (*dal.RecordSet, error)

+ func PopulateRecordSetPageDetails(recordset *dal.RecordSet, f *filter.Filter, page IndexPage)

+ func PopulateRelationships(backend Backend, parent *dal.Collection, record *dal.Record, ...) error

+ func RegisterBackend(name string, fn BackendFunc)

+ func RegisterSqlInitFunc(scheme string, fn SqlInitFunc)

+ func RegisterSqlPreInitFunc(scheme string, fn SqlPreInitFunc)

+ func ResolveDeferredRecords(cache map[string]interface{}, records ...*dal.Record) error

+ type Aggregator interface

+ AggregatorConnectionString func() *dal.ConnectionString

+ AggregatorInitialize func(Backend) error

+ Average func(collection *dal.Collection, field string, f ...*filter.Filter) (float64, error)

+ Count func(collection *dal.Collection, f ...*filter.Filter) (uint64, error)

+ GroupBy func(collection *dal.Collection, fields []string, aggregates []filter.Aggregate, ...) (*dal.RecordSet, error)

+ Maximum func(collection *dal.Collection, field string, f ...*filter.Filter) (float64, error)

+ Minimum func(collection *dal.Collection, field string, f ...*filter.Filter) (float64, error)

+ Sum func(collection *dal.Collection, field string, f ...*filter.Filter) (float64, error)

+ type Backend interface

+ CreateCollection func(definition *dal.Collection) error

+ Delete func(collection string, ids ...interface{}) error

+ DeleteCollection func(collection string) error

+ Exists func(collection string, id interface{}) bool

+ Flush func() error

+ GetCollection func(collection string) (*dal.Collection, error)

+ GetConnectionString func() *dal.ConnectionString

+ Initialize func() error

+ Insert func(collection string, records *dal.RecordSet) error

+ ListCollections func() ([]string, error)

+ Ping func(time.Duration) error

+ RegisterCollection func(*dal.Collection)

+ Retrieve func(collection string, id interface{}, fields ...string) (*dal.Record, error)

+ SetIndexer func(dal.ConnectionString) error

+ String func() string

+ Supports func(feature ...BackendFeature) bool

+ Update func(collection string, records *dal.RecordSet, target ...string) error

+ WithAggregator func(collection *dal.Collection) Aggregator

+ WithSearch func(collection *dal.Collection, filters ...*filter.Filter) Indexer

+ func MakeBackend(connection dal.ConnectionString) (Backend, error)

+ func NewDynamoBackend(connection dal.ConnectionString) Backend

+ func NewFileBackend(connection dal.ConnectionString) Backend

+ func NewFilesystemBackend(connection dal.ConnectionString) Backend

+ func NewMongoBackend(connection dal.ConnectionString) Backend

+ func NewRedisBackend(connection dal.ConnectionString) Backend

+ func NewSqlBackend(connection dal.ConnectionString) Backend

+ type BackendFeature int

+ const CompositeKeys

+ const Constraints

+ const PartialSearch

+ type BackendFunc func(dal.ConnectionString) Backend

+ type BleveIndexer struct

+ func NewBleveIndexer(connection dal.ConnectionString) *BleveIndexer

+ func (self *BleveIndexer) DeleteQuery(collection *dal.Collection, f *filter.Filter) error

+ func (self *BleveIndexer) FlushIndex() error

+ func (self *BleveIndexer) GetBackend() Backend

+ func (self *BleveIndexer) Index(collection *dal.Collection, records *dal.RecordSet) error

+ func (self *BleveIndexer) IndexConnectionString() *dal.ConnectionString

+ func (self *BleveIndexer) IndexExists(collection *dal.Collection, id interface{}) bool

+ func (self *BleveIndexer) IndexInitialize(parent Backend) error

+ func (self *BleveIndexer) IndexRemove(collection *dal.Collection, ids []interface{}) error

+ func (self *BleveIndexer) IndexRetrieve(collection *dal.Collection, id interface{}) (*dal.Record, error)

+ func (self *BleveIndexer) ListValues(collection *dal.Collection, fields []string, f *filter.Filter) (map[string][]interface{}, error)

+ func (self *BleveIndexer) Query(collection *dal.Collection, f *filter.Filter, resultFns ...IndexResultFunc) (*dal.RecordSet, error)

+ func (self *BleveIndexer) QueryFunc(collection *dal.Collection, f *filter.Filter, resultFn IndexResultFunc) error

+ type CachingBackend struct

+ func NewCachingBackend(parent Backend) *CachingBackend

+ func (self *CachingBackend) CreateCollection(definition *dal.Collection) error

+ func (self *CachingBackend) Delete(collection string, ids ...interface{}) error

+ func (self *CachingBackend) DeleteCollection(collection string) error

+ func (self *CachingBackend) Exists(collection string, id interface{}) bool

+ func (self *CachingBackend) Flush() error

+ func (self *CachingBackend) GetCollection(collection string) (*dal.Collection, error)

+ func (self *CachingBackend) GetConnectionString() *dal.ConnectionString

+ func (self *CachingBackend) Initialize() error

+ func (self *CachingBackend) Insert(collection string, records *dal.RecordSet) error

+ func (self *CachingBackend) ListCollections() ([]string, error)

+ func (self *CachingBackend) Ping(d time.Duration) error

+ func (self *CachingBackend) RegisterCollection(c *dal.Collection)

+ func (self *CachingBackend) ResetCache()

+ func (self *CachingBackend) Retrieve(collection string, id interface{}, fields ...string) (*dal.Record, error)

+ func (self *CachingBackend) SetIndexer(cs dal.ConnectionString) error

+ func (self *CachingBackend) String() string

+ func (self *CachingBackend) Supports(feature ...BackendFeature) bool

+ func (self *CachingBackend) Update(collection string, records *dal.RecordSet, target ...string) error

+ func (self *CachingBackend) WithAggregator(collection *dal.Collection) Aggregator

+ func (self *CachingBackend) WithSearch(collection *dal.Collection, filters ...*filter.Filter) Indexer

+ type ConnectOptions struct

+ AdditionalIndexers []string

+ AutocreateCollections bool

+ Indexer string

+ SkipInitialize bool

+ type DeferredRecord struct

+ Backend Backend

+ CollectionName string

+ ID interface{}

+ IdentityFieldName string

+ Keys []string

+ Original interface{}

+ func (self *DeferredRecord) GroupKey(id ...interface{}) string

+ func (self *DeferredRecord) String() string

+ type DynamoBackend struct

+ func (self *DynamoBackend) CreateCollection(definition *dal.Collection) error

+ func (self *DynamoBackend) Delete(name string, ids ...interface{}) error

+ func (self *DynamoBackend) DeleteCollection(name string) error

+ func (self *DynamoBackend) DeleteQuery(collection *dal.Collection, flt *filter.Filter) error

+ func (self *DynamoBackend) Exists(name string, id interface{}) bool

+ func (self *DynamoBackend) Flush() error

+ func (self *DynamoBackend) FlushIndex() error

+ func (self *DynamoBackend) GetBackend() Backend

+ func (self *DynamoBackend) GetCollection(name string) (*dal.Collection, error)

+ func (self *DynamoBackend) GetConnectionString() *dal.ConnectionString

+ func (self *DynamoBackend) Index(collection *dal.Collection, records *dal.RecordSet) error

+ func (self *DynamoBackend) IndexConnectionString() *dal.ConnectionString

+ func (self *DynamoBackend) IndexExists(collection *dal.Collection, id interface{}) bool

+ func (self *DynamoBackend) IndexInitialize(Backend) error

+ func (self *DynamoBackend) IndexRemove(collection *dal.Collection, ids []interface{}) error

+ func (self *DynamoBackend) IndexRetrieve(collection *dal.Collection, id interface{}) (*dal.Record, error)

+ func (self *DynamoBackend) Initialize() error

+ func (self *DynamoBackend) Insert(name string, records *dal.RecordSet) error

+ func (self *DynamoBackend) ListCollections() ([]string, error)

+ func (self *DynamoBackend) ListValues(collection *dal.Collection, fields []string, flt *filter.Filter) (map[string][]interface{}, error)

+ func (self *DynamoBackend) Ping(timeout time.Duration) error

+ func (self *DynamoBackend) Query(collection *dal.Collection, f *filter.Filter, resultFns ...IndexResultFunc) (*dal.RecordSet, error)

+ func (self *DynamoBackend) QueryFunc(collection *dal.Collection, flt *filter.Filter, resultFn IndexResultFunc) error

+ func (self *DynamoBackend) RegisterCollection(definition *dal.Collection)

+ func (self *DynamoBackend) Retrieve(name string, id interface{}, fields ...string) (*dal.Record, error)

+ func (self *DynamoBackend) SetIndexer(indexConnString dal.ConnectionString) error

+ func (self *DynamoBackend) String() string

+ func (self *DynamoBackend) Supports(features ...BackendFeature) bool

+ func (self *DynamoBackend) Update(name string, records *dal.RecordSet, target ...string) error

+ func (self *DynamoBackend) WithAggregator(collection *dal.Collection) Aggregator

+ func (self *DynamoBackend) WithSearch(collection *dal.Collection, filters ...*filter.Filter) Indexer

+ type ElasticsearchIndexer struct

+ func NewElasticsearchIndexer(connection dal.ConnectionString) *ElasticsearchIndexer

+ func (self *ElasticsearchIndexer) AggregatorConnectionString() *dal.ConnectionString

+ func (self *ElasticsearchIndexer) AggregatorInitialize(parent Backend) error

+ func (self *ElasticsearchIndexer) Average(collection *dal.Collection, field string, f ...*filter.Filter) (float64, error)

+ func (self *ElasticsearchIndexer) Count(collection *dal.Collection, flt ...*filter.Filter) (uint64, error)

+ func (self *ElasticsearchIndexer) DeleteQuery(collection *dal.Collection, f *filter.Filter) error

+ func (self *ElasticsearchIndexer) FlushIndex() error

+ func (self *ElasticsearchIndexer) GetBackend() Backend

+ func (self *ElasticsearchIndexer) GroupBy(collection *dal.Collection, groupBy []string, aggregates []filter.Aggregate, ...) (*dal.RecordSet, error)

+ func (self *ElasticsearchIndexer) Index(collection *dal.Collection, records *dal.RecordSet) error

+ func (self *ElasticsearchIndexer) IndexConnectionString() *dal.ConnectionString

+ func (self *ElasticsearchIndexer) IndexExists(collection *dal.Collection, id interface{}) bool

+ func (self *ElasticsearchIndexer) IndexInitialize(parent Backend) error

+ func (self *ElasticsearchIndexer) IndexRemove(collection *dal.Collection, ids []interface{}) error

+ func (self *ElasticsearchIndexer) IndexRetrieve(collection *dal.Collection, id interface{}) (*dal.Record, error)

+ func (self *ElasticsearchIndexer) ListValues(collection *dal.Collection, fields []string, f *filter.Filter) (map[string][]interface{}, error)

+ func (self *ElasticsearchIndexer) Maximum(collection *dal.Collection, field string, f ...*filter.Filter) (float64, error)

+ func (self *ElasticsearchIndexer) Minimum(collection *dal.Collection, field string, f ...*filter.Filter) (float64, error)

+ func (self *ElasticsearchIndexer) Query(collection *dal.Collection, f *filter.Filter, resultFns ...IndexResultFunc) (*dal.RecordSet, error)

+ func (self *ElasticsearchIndexer) QueryFunc(collection *dal.Collection, f *filter.Filter, resultFn IndexResultFunc) error

+ func (self *ElasticsearchIndexer) Sum(collection *dal.Collection, field string, f ...*filter.Filter) (float64, error)

+ type EmbeddedRecordBackend struct

+ SkipKeys []string

+ func NewEmbeddedRecordBackend(parent Backend, skipKeys ...string) *EmbeddedRecordBackend

+ func (self *EmbeddedRecordBackend) CreateCollection(definition *dal.Collection) error

+ func (self *EmbeddedRecordBackend) Delete(collection string, ids ...interface{}) error

+ func (self *EmbeddedRecordBackend) DeleteCollection(collection string) error

+ func (self *EmbeddedRecordBackend) DeleteQuery(collection *dal.Collection, f *filter.Filter) error

+ func (self *EmbeddedRecordBackend) EmbedRelationships(collection *dal.Collection, record *dal.Record, fields ...string) (*dal.Record, error)

+ func (self *EmbeddedRecordBackend) Exists(collection string, id interface{}) bool

+ func (self *EmbeddedRecordBackend) Flush() error

+ func (self *EmbeddedRecordBackend) FlushIndex() error

+ func (self *EmbeddedRecordBackend) GetBackend() Backend

+ func (self *EmbeddedRecordBackend) GetCollection(collection string) (*dal.Collection, error)

+ func (self *EmbeddedRecordBackend) GetConnectionString() *dal.ConnectionString

+ func (self *EmbeddedRecordBackend) Index(collection *dal.Collection, records *dal.RecordSet) error

+ func (self *EmbeddedRecordBackend) IndexConnectionString() *dal.ConnectionString

+ func (self *EmbeddedRecordBackend) IndexExists(collection *dal.Collection, id interface{}) bool

+ func (self *EmbeddedRecordBackend) IndexInitialize(b Backend) error

+ func (self *EmbeddedRecordBackend) IndexRemove(collection *dal.Collection, ids []interface{}) error

+ func (self *EmbeddedRecordBackend) IndexRetrieve(collection *dal.Collection, id interface{}) (*dal.Record, error)

+ func (self *EmbeddedRecordBackend) Initialize() error

+ func (self *EmbeddedRecordBackend) Insert(collection string, records *dal.RecordSet) error

+ func (self *EmbeddedRecordBackend) ListCollections() ([]string, error)

+ func (self *EmbeddedRecordBackend) ListValues(collection *dal.Collection, fields []string, filter *filter.Filter) (map[string][]interface{}, error)

+ func (self *EmbeddedRecordBackend) Migrate() error

+ func (self *EmbeddedRecordBackend) Ping(d time.Duration) error

+ func (self *EmbeddedRecordBackend) Query(collection *dal.Collection, filter *filter.Filter, ...) (*dal.RecordSet, error)

+ func (self *EmbeddedRecordBackend) QueryFunc(collection *dal.Collection, filter *filter.Filter, resultFn IndexResultFunc) error

+ func (self *EmbeddedRecordBackend) RegisterCollection(c *dal.Collection)

+ func (self *EmbeddedRecordBackend) Retrieve(name string, id interface{}, fields ...string) (*dal.Record, error)

+ func (self *EmbeddedRecordBackend) SetIndexer(cs dal.ConnectionString) error

+ func (self *EmbeddedRecordBackend) String() string

+ func (self *EmbeddedRecordBackend) Supports(feature ...BackendFeature) bool

+ func (self *EmbeddedRecordBackend) Update(collection string, records *dal.RecordSet, target ...string) error

+ func (self *EmbeddedRecordBackend) WithAggregator(collection *dal.Collection) Aggregator

+ func (self *EmbeddedRecordBackend) WithSearch(collection *dal.Collection, filters ...*filter.Filter) Indexer

+ type FileBackend struct

+ func (self *FileBackend) CreateCollection(definition *dal.Collection) error

+ func (self *FileBackend) Delete(collection string, ids ...interface{}) error

+ func (self *FileBackend) DeleteCollection(collection string) error

+ func (self *FileBackend) Exists(name string, id interface{}) bool

+ func (self *FileBackend) Flush() error

+ func (self *FileBackend) GetCollection(collection string) (*dal.Collection, error)

+ func (self *FileBackend) GetConnectionString() *dal.ConnectionString

+ func (self *FileBackend) Initialize() error

+ func (self *FileBackend) Insert(collection string, records *dal.RecordSet) error

+ func (self *FileBackend) ListCollections() ([]string, error)

+ func (self *FileBackend) Ping(_ time.Duration) error

+ func (self *FileBackend) RegisterCollection(collection *dal.Collection)

+ func (self *FileBackend) Retrieve(name string, id interface{}, fields ...string) (*dal.Record, error)

+ func (self *FileBackend) SetIndexer(dal.ConnectionString) error

+ func (self *FileBackend) String() string

+ func (self *FileBackend) Supports(features ...BackendFeature) bool

+ func (self *FileBackend) Update(collection string, records *dal.RecordSet, target ...string) error

+ func (self *FileBackend) WithAggregator(collection *dal.Collection) Aggregator

+ func (self *FileBackend) WithSearch(collection *dal.Collection, filters ...*filter.Filter) Indexer

+ type FilesystemBackend struct

+ func (self *FilesystemBackend) CreateCollection(definition *dal.Collection) error

+ func (self *FilesystemBackend) Delete(name string, ids ...interface{}) error

+ func (self *FilesystemBackend) DeleteCollection(name string) error

+ func (self *FilesystemBackend) DeleteQuery(collection *dal.Collection, f *filter.Filter) error

+ func (self *FilesystemBackend) Exists(name string, id interface{}) bool

+ func (self *FilesystemBackend) Flush() error

+ func (self *FilesystemBackend) FlushIndex() error

+ func (self *FilesystemBackend) GetBackend() Backend

+ func (self *FilesystemBackend) GetCollection(name string) (*dal.Collection, error)

+ func (self *FilesystemBackend) GetConnectionString() *dal.ConnectionString

+ func (self *FilesystemBackend) Index(collection *dal.Collection, records *dal.RecordSet) error

+ func (self *FilesystemBackend) IndexConnectionString() *dal.ConnectionString

+ func (self *FilesystemBackend) IndexExists(collection *dal.Collection, id interface{}) bool

+ func (self *FilesystemBackend) IndexInitialize(_ Backend) error

+ func (self *FilesystemBackend) IndexRemove(collection *dal.Collection, ids []interface{}) error

+ func (self *FilesystemBackend) IndexRetrieve(collection *dal.Collection, id interface{}) (*dal.Record, error)

+ func (self *FilesystemBackend) Initialize() error

+ func (self *FilesystemBackend) Insert(collectionName string, recordset *dal.RecordSet) error

+ func (self *FilesystemBackend) ListCollections() ([]string, error)

+ func (self *FilesystemBackend) ListValues(collection *dal.Collection, fields []string, f *filter.Filter) (map[string][]interface{}, error)

+ func (self *FilesystemBackend) Ping(timeout time.Duration) error

+ func (self *FilesystemBackend) Query(collection *dal.Collection, f *filter.Filter, resultFns ...IndexResultFunc) (*dal.RecordSet, error)

+ func (self *FilesystemBackend) QueryFunc(collection *dal.Collection, filter *filter.Filter, resultFn IndexResultFunc) error

+ func (self *FilesystemBackend) RegisterCollection(collection *dal.Collection)

+ func (self *FilesystemBackend) Retrieve(name string, id interface{}, fields ...string) (*dal.Record, error)

+ func (self *FilesystemBackend) SetIndexer(indexConnString dal.ConnectionString) error

+ func (self *FilesystemBackend) String() string

+ func (self *FilesystemBackend) Supports(features ...BackendFeature) bool

+ func (self *FilesystemBackend) Update(name string, recordset *dal.RecordSet, target ...string) error

+ func (self *FilesystemBackend) WithAggregator(collection *dal.Collection) Aggregator

+ func (self *FilesystemBackend) WithSearch(collection *dal.Collection, filters ...*filter.Filter) Indexer

+ type IndexOperation int

+ const DeleteOperation

+ const InspectionOperation

+ const PersistOperation

+ const RetrieveOperation

+ type IndexPage struct

+ Limit int

+ Offset int

+ Page int

+ TotalPages int

+ TotalResults int64

+ type IndexResultFunc func(record *dal.Record, err error, page IndexPage) error

+ type IndexSelectionStrategy int

+ const All

+ const AllExceptFirst

+ const First

+ const Random

+ const Sequential

+ func (self IndexSelectionStrategy) IsCompoundable() bool

+ type Indexer interface

+ DeleteQuery func(collection *dal.Collection, f *filter.Filter) error

+ FlushIndex func() error

+ GetBackend func() Backend

+ Index func(collection *dal.Collection, records *dal.RecordSet) error

+ IndexConnectionString func() *dal.ConnectionString

+ IndexExists func(collection *dal.Collection, id interface{}) bool

+ IndexInitialize func(Backend) error

+ IndexRemove func(collection *dal.Collection, ids []interface{}) error

+ IndexRetrieve func(collection *dal.Collection, id interface{}) (*dal.Record, error)

+ ListValues func(collection *dal.Collection, fields []string, filter *filter.Filter) (map[string][]interface{}, error)

+ Query func(collection *dal.Collection, filter *filter.Filter, ...) (*dal.RecordSet, error)

+ QueryFunc func(collection *dal.Collection, filter *filter.Filter, resultFn IndexResultFunc) error

+ func MakeIndexer(connection dal.ConnectionString) (Indexer, error)

+ type IndexerResult struct

+ Index int

+ Indexer Indexer

+ type IndexerResultFunc func(indexer Indexer, current int, last int) error

+ type Mapper interface

+ All func(into interface{}) error

+ Average func(field string, flt interface{}) (float64, error)

+ Count func(flt interface{}) (uint64, error)

+ Create func(from interface{}) error

+ CreateOrUpdate func(id interface{}, from interface{}) error

+ Delete func(ids ...interface{}) error

+ DeleteQuery func(flt interface{}) error

+ Drop func() error

+ Each func(destZeroValue interface{}, resultFn ResultFunc) error

+ Exists func(id interface{}) bool

+ Find func(flt interface{}, into interface{}) error

+ FindFunc func(flt interface{}, destZeroValue interface{}, resultFn ResultFunc) error

+ Get func(id interface{}, into interface{}) error

+ GetBackend func() Backend

+ GetCollection func() *dal.Collection

+ GroupBy func(fields []string, aggregates []filter.Aggregate, flt interface{}) (*dal.RecordSet, error)

+ List func(fields []string) (map[string][]interface{}, error)

+ ListWithFilter func(fields []string, flt interface{}) (map[string][]interface{}, error)

+ Maximum func(field string, flt interface{}) (float64, error)

+ Migrate func() error

+ Minimum func(field string, flt interface{}) (float64, error)

+ Sum func(field string, flt interface{}) (float64, error)

+ Update func(from interface{}) error

+ type MetaIndex struct

+ func NewMetaIndex(leftIndexer Indexer, leftCollection *dal.Collection, leftField string, ...) *MetaIndex

+ func (self *MetaIndex) DeleteQuery(collection *dal.Collection, f *filter.Filter) error

+ func (self *MetaIndex) FlushIndex() error

+ func (self *MetaIndex) GetBackend() Backend

+ func (self *MetaIndex) Index(collection *dal.Collection, records *dal.RecordSet) error

+ func (self *MetaIndex) IndexConnectionString() *dal.ConnectionString

+ func (self *MetaIndex) IndexExists(collection *dal.Collection, id interface{}) bool

+ func (self *MetaIndex) IndexInitialize(_ Backend) error

+ func (self *MetaIndex) IndexRemove(collection *dal.Collection, ids []interface{}) error

+ func (self *MetaIndex) IndexRetrieve(collection *dal.Collection, id interface{}) (*dal.Record, error)

+ func (self *MetaIndex) ListValues(collection *dal.Collection, fields []string, filter *filter.Filter) (map[string][]interface{}, error)

+ func (self *MetaIndex) Query(collection *dal.Collection, f *filter.Filter, resultFns ...IndexResultFunc) (*dal.RecordSet, error)

+ func (self *MetaIndex) QueryFunc(collection *dal.Collection, f *filter.Filter, resultFn IndexResultFunc) error

+ type MongoBackend struct

+ func (self *MongoBackend) AggregatorConnectionString() *dal.ConnectionString

+ func (self *MongoBackend) AggregatorInitialize(parent Backend) error

+ func (self *MongoBackend) Average(collection *dal.Collection, field string, f ...*filter.Filter) (float64, error)

+ func (self *MongoBackend) Count(collection *dal.Collection, flt ...*filter.Filter) (uint64, error)

+ func (self *MongoBackend) CreateCollection(definition *dal.Collection) error

+ func (self *MongoBackend) Delete(name string, ids ...interface{}) error

+ func (self *MongoBackend) DeleteCollection(name string) error

+ func (self *MongoBackend) DeleteQuery(collection *dal.Collection, flt *filter.Filter) error

+ func (self *MongoBackend) Exists(name string, id interface{}) bool

+ func (self *MongoBackend) Flush() error

+ func (self *MongoBackend) FlushIndex() error

+ func (self *MongoBackend) GetBackend() Backend

+ func (self *MongoBackend) GetCollection(name string) (*dal.Collection, error)

+ func (self *MongoBackend) GetConnectionString() *dal.ConnectionString

+ func (self *MongoBackend) GroupBy(collection *dal.Collection, groupBy []string, aggregates []filter.Aggregate, ...) (*dal.RecordSet, error)

+ func (self *MongoBackend) Index(collection *dal.Collection, records *dal.RecordSet) error

+ func (self *MongoBackend) IndexConnectionString() *dal.ConnectionString

+ func (self *MongoBackend) IndexExists(collection *dal.Collection, id interface{}) bool

+ func (self *MongoBackend) IndexInitialize(Backend) error

+ func (self *MongoBackend) IndexRemove(collection *dal.Collection, ids []interface{}) error

+ func (self *MongoBackend) IndexRetrieve(collection *dal.Collection, id interface{}) (*dal.Record, error)

+ func (self *MongoBackend) Initialize() error

+ func (self *MongoBackend) Insert(name string, records *dal.RecordSet) error

+ func (self *MongoBackend) ListCollections() ([]string, error)

+ func (self *MongoBackend) ListValues(collection *dal.Collection, fields []string, flt *filter.Filter) (map[string][]interface{}, error)

+ func (self *MongoBackend) Maximum(collection *dal.Collection, field string, f ...*filter.Filter) (float64, error)

+ func (self *MongoBackend) Minimum(collection *dal.Collection, field string, f ...*filter.Filter) (float64, error)

+ func (self *MongoBackend) Ping(timeout time.Duration) error

+ func (self *MongoBackend) Query(collection *dal.Collection, f *filter.Filter, resultFns ...IndexResultFunc) (*dal.RecordSet, error)

+ func (self *MongoBackend) QueryFunc(collection *dal.Collection, flt *filter.Filter, resultFn IndexResultFunc) error

+ func (self *MongoBackend) RegisterCollection(collection *dal.Collection)

+ func (self *MongoBackend) Retrieve(name string, id interface{}, fields ...string) (*dal.Record, error)

+ func (self *MongoBackend) SetIndexer(indexConnString dal.ConnectionString) error

+ func (self *MongoBackend) String() string

+ func (self *MongoBackend) Sum(collection *dal.Collection, field string, f ...*filter.Filter) (float64, error)

+ func (self *MongoBackend) Supports(features ...BackendFeature) bool

+ func (self *MongoBackend) Update(name string, records *dal.RecordSet, target ...string) error

+ func (self *MongoBackend) WithAggregator(collection *dal.Collection) Aggregator

+ func (self *MongoBackend) WithSearch(collection *dal.Collection, filters ...*filter.Filter) Indexer

+ type MultiIndex struct

+ DeleteStrategy IndexSelectionStrategy

+ InspectionStrategy IndexSelectionStrategy

+ PersistStrategy IndexSelectionStrategy

+ RetrievalStrategy IndexSelectionStrategy

+ func NewMultiIndex(connectionStrings ...string) *MultiIndex

+ func (self *MultiIndex) AddIndexer(indexer Indexer) error

+ func (self *MultiIndex) AddIndexerByConnectionString(cs string) error

+ func (self *MultiIndex) DeleteQuery(collection *dal.Collection, f *filter.Filter) error

+ func (self *MultiIndex) EachSelectedIndex(collection *dal.Collection, operation IndexOperation, ...) error

+ func (self *MultiIndex) FlushIndex() error

+ func (self *MultiIndex) GetBackend() Backend

+ func (self *MultiIndex) Index(collection *dal.Collection, records *dal.RecordSet) error

+ func (self *MultiIndex) IndexConnectionString() *dal.ConnectionString

+ func (self *MultiIndex) IndexExists(collection *dal.Collection, id interface{}) bool

+ func (self *MultiIndex) IndexInitialize(backend Backend) error

+ func (self *MultiIndex) IndexRemove(collection *dal.Collection, ids []interface{}) error

+ func (self *MultiIndex) IndexRetrieve(collection *dal.Collection, id interface{}) (*dal.Record, error)

+ func (self *MultiIndex) ListValues(collection *dal.Collection, fields []string, filter *filter.Filter) (map[string][]interface{}, error)

+ func (self *MultiIndex) Query(collection *dal.Collection, filter *filter.Filter, ...) (*dal.RecordSet, error)

+ func (self *MultiIndex) QueryFunc(collection *dal.Collection, filter *filter.Filter, resultFn IndexResultFunc) error

+ func (self *MultiIndex) SelectIndex(collection *dal.Collection, operation IndexOperation, lastIndexer int) ([]IndexerResult, error)

+ type NullIndexer struct

+ func (self *NullIndexer) DeleteQuery(collection *dal.Collection, f filter.Filter) error

+ func (self *NullIndexer) FlushIndex() error

+ func (self *NullIndexer) GetBackend() Backend

+ func (self *NullIndexer) Index(collection *dal.Collection, records *dal.RecordSet) error

+ func (self *NullIndexer) IndexConnectionString() *dal.ConnectionString

+ func (self *NullIndexer) IndexExists(collection *dal.Collection, id interface{}) bool

+ func (self *NullIndexer) IndexInitialize(Backend) error

+ func (self *NullIndexer) IndexRemove(collection *dal.Collection, ids []interface{}) error

+ func (self *NullIndexer) IndexRetrieve(collection *dal.Collection, id interface{}) (*dal.Record, error)

+ func (self *NullIndexer) ListValues(collection *dal.Collection, fields []string, filter filter.Filter) (map[string][]interface{}, error)

+ func (self *NullIndexer) Query(collection *dal.Collection, filter filter.Filter, resultFns ...IndexResultFunc) (*dal.RecordSet, error)

+ func (self *NullIndexer) QueryFunc(collection *dal.Collection, filter filter.Filter, resultFn IndexResultFunc) error

+ type RedisBackend struct

+ func (self *RedisBackend) CreateCollection(definition *dal.Collection) error

+ func (self *RedisBackend) Delete(name string, ids ...interface{}) error

+ func (self *RedisBackend) DeleteCollection(name string) error

+ func (self *RedisBackend) DeleteQuery(collection *dal.Collection, flt *filter.Filter) error

+ func (self *RedisBackend) Exists(name string, id interface{}) bool

+ func (self *RedisBackend) Flush() error

+ func (self *RedisBackend) FlushIndex() error

+ func (self *RedisBackend) GetBackend() Backend

+ func (self *RedisBackend) GetCollection(name string) (*dal.Collection, error)

+ func (self *RedisBackend) GetConnectionString() *dal.ConnectionString

+ func (self *RedisBackend) Index(collection *dal.Collection, records *dal.RecordSet) error

+ func (self *RedisBackend) IndexConnectionString() *dal.ConnectionString

+ func (self *RedisBackend) IndexExists(collection *dal.Collection, id interface{}) bool

+ func (self *RedisBackend) IndexInitialize(Backend) error

+ func (self *RedisBackend) IndexRemove(collection *dal.Collection, ids []interface{}) error

+ func (self *RedisBackend) IndexRetrieve(collection *dal.Collection, id interface{}) (*dal.Record, error)

+ func (self *RedisBackend) Initialize() error

+ func (self *RedisBackend) Insert(name string, recordset *dal.RecordSet) error

+ func (self *RedisBackend) ListCollections() ([]string, error)

+ func (self *RedisBackend) ListValues(collection *dal.Collection, fields []string, flt *filter.Filter) (map[string][]interface{}, error)

+ func (self *RedisBackend) Ping(timeout time.Duration) error

+ func (self *RedisBackend) Query(collection *dal.Collection, f *filter.Filter, resultFns ...IndexResultFunc) (*dal.RecordSet, error)

+ func (self *RedisBackend) QueryFunc(collection *dal.Collection, flt *filter.Filter, resultFn IndexResultFunc) error

+ func (self *RedisBackend) RegisterCollection(collection *dal.Collection)

+ func (self *RedisBackend) Retrieve(name string, id interface{}, fields ...string) (*dal.Record, error)

+ func (self *RedisBackend) SetIndexer(indexConnString dal.ConnectionString) error

+ func (self *RedisBackend) String() string

+ func (self *RedisBackend) Supports(features ...BackendFeature) bool

+ func (self *RedisBackend) Update(name string, recordset *dal.RecordSet, target ...string) error

+ func (self *RedisBackend) WithAggregator(collection *dal.Collection) Aggregator

+ func (self *RedisBackend) WithSearch(collection *dal.Collection, filters ...*filter.Filter) Indexer

+ type ResultFunc func(ptrToInstance interface{}, err error)

+ type SerializationFormat string

+ type SqlBackend struct

+ func (self *SqlBackend) AggregatorConnectionString() *dal.ConnectionString

+ func (self *SqlBackend) AggregatorInitialize(parent Backend) error

+ func (self *SqlBackend) Average(collection *dal.Collection, field string, f ...*filter.Filter) (float64, error)

+ func (self *SqlBackend) Count(collection *dal.Collection, f ...*filter.Filter) (uint64, error)

+ func (self *SqlBackend) CreateCollection(definition *dal.Collection) error

+ func (self *SqlBackend) Delete(name string, ids ...interface{}) error

+ func (self *SqlBackend) DeleteCollection(collectionName string) error

+ func (self *SqlBackend) DeleteQuery(collection *dal.Collection, f *filter.Filter) error

+ func (self *SqlBackend) Exists(name string, id interface{}) bool

+ func (self *SqlBackend) Flush() error

+ func (self *SqlBackend) FlushIndex() error

+ func (self *SqlBackend) GetBackend() Backend

+ func (self *SqlBackend) GetCollection(name string) (*dal.Collection, error)

+ func (self *SqlBackend) GetConnectionString() *dal.ConnectionString

+ func (self *SqlBackend) GroupBy(collection *dal.Collection, groupBy []string, aggregates []filter.Aggregate, ...) (*dal.RecordSet, error)

+ func (self *SqlBackend) Index(collection *dal.Collection, records *dal.RecordSet) error

+ func (self *SqlBackend) IndexConnectionString() *dal.ConnectionString

+ func (self *SqlBackend) IndexExists(collection *dal.Collection, id interface{}) bool

+ func (self *SqlBackend) IndexInitialize(parent Backend) error

+ func (self *SqlBackend) IndexRemove(collection *dal.Collection, ids []interface{}) error

+ func (self *SqlBackend) IndexRetrieve(collection *dal.Collection, id interface{}) (*dal.Record, error)

+ func (self *SqlBackend) Initialize() error

+ func (self *SqlBackend) Insert(name string, recordset *dal.RecordSet) error

+ func (self *SqlBackend) ListCollections() ([]string, error)

+ func (self *SqlBackend) ListValues(collection *dal.Collection, fields []string, f *filter.Filter) (map[string][]interface{}, error)

+ func (self *SqlBackend) Maximum(collection *dal.Collection, field string, f ...*filter.Filter) (float64, error)

+ func (self *SqlBackend) Migrate() error

+ func (self *SqlBackend) Minimum(collection *dal.Collection, field string, f ...*filter.Filter) (float64, error)

+ func (self *SqlBackend) Ping(timeout time.Duration) error

+ func (self *SqlBackend) Query(collection *dal.Collection, f *filter.Filter, resultFns ...IndexResultFunc) (*dal.RecordSet, error)

+ func (self *SqlBackend) QueryFunc(collection *dal.Collection, f *filter.Filter, resultFn IndexResultFunc) error

+ func (self *SqlBackend) RegisterCollection(collection *dal.Collection)

+ func (self *SqlBackend) Retrieve(name string, id interface{}, fields ...string) (*dal.Record, error)

+ func (self *SqlBackend) SetIndexer(indexConnString dal.ConnectionString) error

+ func (self *SqlBackend) String() string

+ func (self *SqlBackend) Sum(collection *dal.Collection, field string, f ...*filter.Filter) (float64, error)

+ func (self *SqlBackend) Supports(features ...BackendFeature) bool

+ func (self *SqlBackend) Update(name string, recordset *dal.RecordSet, target ...string) error

+ func (self *SqlBackend) WithAggregator(collection *dal.Collection) Aggregator

+ func (self *SqlBackend) WithSearch(collection *dal.Collection, filters ...*filter.Filter) Indexer

+ type SqlInitFunc func(*SqlBackend) (string, string, error)

+ type SqlPreInitFunc func(*SqlBackend)

Other modules containing this package

github.com/PerformLine/pivot/v4