backends

Oct 30, 2020

Changes in this version

+ const ClientUserAgent

+ var ElasticsearchAnalyzers = map[string]interface

+ var ElasticsearchDefaultCompositeJoiner = `--`

+ var ElasticsearchDefaultHost = `localhost:9200`

+ var ElasticsearchDefaultRefresh = `false`

+ var ElasticsearchDefaultReplicas = 2

+ var ElasticsearchDefaultScheme = `http`

+ var ElasticsearchDefaultShards = 3

+ var ElasticsearchDefaultType = `_doc`

+ var ElasticsearchNormalizers = map[string]interface

+ var ElasticsearchScrollLifetime = `1m`

type Backend

+ func NewElasticsearchBackend(connection dal.ConnectionString) Backend

+ type ElasticsearchBackend struct

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

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

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

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

+ func (self *ElasticsearchBackend) Flush() error

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

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

+ func (self *ElasticsearchBackend) Initialize() error

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

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

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

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

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

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

+ func (self *ElasticsearchBackend) String() string

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

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

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

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

Oct 20, 2020

Changes in this version

+ var DyanmoListFieldsLimit = 8192

+ var FilesystemKeyJoiner = `--`

Sep 13, 2019

Changes in this version

type EmbeddedRecordBackend

+ func (self *EmbeddedRecordBackend) Migrate() error

Aug 29, 2019

Changes in this version

+ func RegisterSqlInitFunc(scheme string, fn SqlInitFunc)

+ func RegisterSqlPreInitFunc(scheme string, fn SqlPreInitFunc)

type SqlBackend

+ func (self *SqlBackend) Migrate(diff []dal.SchemaDelta) error

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

+ type SqlPreInitFunc func(*SqlBackend)

May 17, 2019

Changes in this version

+ var SqlArrayFieldHintLength = 131069

+ var SqlObjectFieldHintLength = 131071

type BackendFeature

+ const Constraints

Apr 17, 2019

Changes in this version

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

+ var DefaultSharedCredentialsProfile = `default`

Mar 13, 2019

Changes in this version

type ConnectOptions

+ AutocreateCollections bool

Mar 6, 2019

Changes in this version

type Backend

+ func NewFileBackend(connection dal.ConnectionString) Backend

+ 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

Nov 30, 2018

Changes in this version

type DeferredRecord

+ IdentityFieldName string

Nov 10, 2018

Changes in this version

type Mapper

+ DeleteQuery func(flt interface{}) error

Nov 7, 2018

Changes in this version

+ 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

+ 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)

+ NewInstance func(inits ...dal.InitializerFunc) interface{}

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

+ Update func(from interface{}) error

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

Oct 30, 2018

Changes in this version

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

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

+ type DeferredRecord struct

+ AllowMissing bool

+ Backend Backend

+ CollectionName string

+ ID interface{}

+ Keys []string

+ Original interface{}

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

+ func (self *DeferredRecord) Resolve() (map[string]interface{}, error)

+ func (self *DeferredRecord) String() string

type EmbeddedRecordBackend

+ 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) FlushIndex() error

+ func (self *EmbeddedRecordBackend) GetBackend() Backend

+ 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) ListValues(collection *dal.Collection, fields []string, filter *filter.Filter) (map[string][]interface{}, 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

Oct 23, 2018

Changes in this version

type EmbeddedRecordBackend

+ SkipKeys []string

Oct 16, 2018

Changes in this version

+ var AutopingTimeout = 5 * time.Second

Oct 1, 2018

Changes in this version

type Backend

+ Supports func(feature ...BackendFeature) bool

+ type BackendFeature int

+ const CompositeKeys

+ const PartialSearch

type CachingBackend

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

type DynamoBackend

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

type EmbeddedRecordBackend

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

type FilesystemBackend

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

type MongoBackend

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

type RedisBackend

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

type SqlBackend

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

Sep 28, 2018

Changes in this version

type RedisBackend

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

+ func (self *RedisBackend) FlushIndex() error

+ func (self *RedisBackend) GetBackend() Backend

+ 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) ListValues(collection *dal.Collection, fields []string, flt *filter.Filter) (map[string][]interface{}, 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

Sep 22, 2018

Changes in this version

+ const DefaultFilesystemRecordSubdirectory

+ const FormatCSV

+ const FormatJSON

+ const FormatYAML

+ 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 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 WriteLockFormat = `%s.lock`

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

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

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

+ func RegisterBackend(name string, fn BackendFunc)

+ 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

+ 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 NewFilesystemBackend(connection dal.ConnectionString) Backend

+ func NewMongoBackend(connection dal.ConnectionString) Backend

+ func NewRedisBackend(connection dal.ConnectionString) Backend

+ func NewSqlBackend(connection dal.ConnectionString) Backend

+ 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) 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

+ Indexer string

+ SkipInitialize bool

+ 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) 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

+ func NewEmbeddedRecordBackend(parent Backend) *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) Exists(collection string, id interface{}) bool

+ func (self *EmbeddedRecordBackend) Flush() error

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

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

+ func (self *EmbeddedRecordBackend) Inflate(collection *dal.Collection, record *dal.Record) (*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) Ping(d time.Duration) 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) 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 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) 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 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 Migratable interface

+ Migrate func(diff []dal.SchemaDelta) 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) 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) Exists(name string, id interface{}) bool

+ func (self *RedisBackend) Flush() error

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

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

+ func (self *RedisBackend) Initialize() error

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

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

+ func (self *RedisBackend) Ping(timeout time.Duration) 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) 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 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) 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) 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 WrappedIndexer struct

+ RecordFunc func(*dal.Collection, *dal.Record) (*dal.Record, error)

+ func NewWrappedIndexer(indexer Indexer, parent Backend) *WrappedIndexer

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

+ func (self *WrappedIndexer) FlushIndex() error

+ func (self *WrappedIndexer) GetBackend() Backend

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

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

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

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

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

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

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

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

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