lungo: github.com/256dpi/lungo Index | Examples | Files | Directories

package lungo

import "github.com/256dpi/lungo"

Code:

type post struct {
    Title string `bson:"title"`
}

// prepare options
opts := Options{
    Store: NewMemoryStore(),
}

// open database
client, engine, err := Open(nil, opts)
if err != nil {
    panic(err)
}

// ensure engine is closed
defer engine.Close()

// get db
foo := client.Database("foo")

// get collection
bar := foo.Collection("bar")

// insert post
_, err = bar.InsertOne(nil, &post{
    Title: "Hello World!",
})
if err != nil {
    panic(err)
}

// query posts
csr, err := bar.Find(nil, bson.M{})
if err != nil {
    panic(err)
}

// decode posts
var posts []post
err = csr.All(nil, &posts)
if err != nil {
    panic(err)
}

// print documents
pretty.Println(posts)

Output:

[]lungo.post{
    {Title:"Hello World!"},
}

Index

Examples

Package Files

catalog.go client.go collection.go cursor.go database.go engine.go indexes.go lungo.go mongo.go result.go session.go store.go stream.go transaction.go utils.go

Variables

var ErrEngineClosed = errors.New("engine closed")

ErrEngineClosed is returned if the engine has been closed.

var ErrSessionEnded = errors.New("session ended")

ErrSessionEnded is returned if the session has been ended.

var Oplog = Handle{"local", "oplog"}

Oplog is the handle for the local oplog namespace.

func Open Uses

func Open(_ context.Context, opts Options) (IClient, *Engine, error)

Open will open a lungo database using the provided store.

func WithSession Uses

func WithSession(ctx context.Context, session ISession, fn func(ISessionContext) error) error

WithSession will yield a session context to the provided callback that uses the specified session.

type Catalog Uses

type Catalog struct {
    Namespaces map[Handle]*mongokit.Collection
}

Catalog is the top level object per database that contains all data.

func NewCatalog Uses

func NewCatalog() *Catalog

NewCatalog creates and returns a new catalog.

func (*Catalog) Clone Uses

func (d *Catalog) Clone() *Catalog

Clone will clone the catalog. Namespaces need to be cloned separately.

type Client Uses

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

Client wraps an Engine to be mongo compatible.

func (*Client) Connect Uses

func (c *Client) Connect(context.Context) error

Connect implements the IClient.Connect method.

func (*Client) Database Uses

func (c *Client) Database(name string, opts ...*options.DatabaseOptions) IDatabase

Database implements the IClient.Database method.

func (*Client) Disconnect Uses

func (c *Client) Disconnect(context.Context) error

Disconnect implements the IClient.Disconnect method.

func (*Client) ListDatabaseNames Uses

func (c *Client) ListDatabaseNames(ctx context.Context, filter interface{}, opts ...*options.ListDatabasesOptions) ([]string, error)

ListDatabaseNames implements the IClient.ListDatabaseNames method.

func (*Client) ListDatabases Uses

func (c *Client) ListDatabases(ctx context.Context, filter interface{}, opts ...*options.ListDatabasesOptions) (mongo.ListDatabasesResult, error)

ListDatabases implements the IClient.ListDatabases method.

func (*Client) Ping Uses

func (c *Client) Ping(context.Context, *readpref.ReadPref) error

Ping implements the IClient.Ping method.

func (*Client) StartSession Uses

func (c *Client) StartSession(opts ...*options.SessionOptions) (ISession, error)

StartSession implements the IClient.StartSession method.

func (*Client) UseSession Uses

func (c *Client) UseSession(ctx context.Context, fn func(ISessionContext) error) error

UseSession implements the IClient.UseSession method.

func (*Client) UseSessionWithOptions Uses

func (c *Client) UseSessionWithOptions(ctx context.Context, opt *options.SessionOptions, fn func(ISessionContext) error) error

UseSessionWithOptions implements the IClient.UseSessionWithOptions method.

func (*Client) Watch Uses

func (c *Client) Watch(_ context.Context, pipeline interface{}, opts ...*options.ChangeStreamOptions) (IChangeStream, error)

Watch implements the IClient.Watch method.

type Collection Uses

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

Collection wraps an Engine to be mongo compatible.

func (*Collection) Aggregate Uses

func (c *Collection) Aggregate(context.Context, interface{}, ...*options.AggregateOptions) (ICursor, error)

Aggregate implements the ICollection.Aggregate method.

func (*Collection) BulkWrite Uses

func (c *Collection) BulkWrite(ctx context.Context, models []mongo.WriteModel, opts ...*options.BulkWriteOptions) (*mongo.BulkWriteResult, error)

BulkWrite implements the ICollection.BulkWrite method.

func (*Collection) Clone Uses

func (c *Collection) Clone(opts ...*options.CollectionOptions) (ICollection, error)

Clone implements the ICollection.Clone method.

func (*Collection) CountDocuments Uses

func (c *Collection) CountDocuments(ctx context.Context, filter interface{}, opts ...*options.CountOptions) (int64, error)

CountDocuments implements the ICollection.CountDocuments method.

func (*Collection) Database Uses

func (c *Collection) Database() IDatabase

Database implements the ICollection.Database method.

func (*Collection) DeleteMany Uses

func (c *Collection) DeleteMany(ctx context.Context, filter interface{}, opts ...*options.DeleteOptions) (*mongo.DeleteResult, error)

DeleteMany implements the ICollection.DeleteMany method.

func (*Collection) DeleteOne Uses

func (c *Collection) DeleteOne(ctx context.Context, filter interface{}, opts ...*options.DeleteOptions) (*mongo.DeleteResult, error)

DeleteOne implements the ICollection.DeleteOne method.

func (*Collection) Distinct Uses

func (c *Collection) Distinct(ctx context.Context, field string, filter interface{}, opts ...*options.DistinctOptions) ([]interface{}, error)

Distinct implements the ICollection.Distinct method.

func (*Collection) Drop Uses

func (c *Collection) Drop(ctx context.Context) error

Drop implements the ICollection.Drop method.

func (*Collection) EstimatedDocumentCount Uses

func (c *Collection) EstimatedDocumentCount(ctx context.Context, opts ...*options.EstimatedDocumentCountOptions) (int64, error)

EstimatedDocumentCount implements the ICollection.EstimatedDocumentCount method.

func (*Collection) Find Uses

func (c *Collection) Find(ctx context.Context, filter interface{}, opts ...*options.FindOptions) (ICursor, error)

Find implements the ICollection.Find method.

func (*Collection) FindOne Uses

func (c *Collection) FindOne(ctx context.Context, filter interface{}, opts ...*options.FindOneOptions) ISingleResult

FindOne implements the ICollection.FindOne method.

func (*Collection) FindOneAndDelete Uses

func (c *Collection) FindOneAndDelete(ctx context.Context, filter interface{}, opts ...*options.FindOneAndDeleteOptions) ISingleResult

FindOneAndDelete implements the ICollection.FindOneAndDelete method.

func (*Collection) FindOneAndReplace Uses

func (c *Collection) FindOneAndReplace(ctx context.Context, filter, replacement interface{}, opts ...*options.FindOneAndReplaceOptions) ISingleResult

FindOneAndReplace implements the ICollection.FindOneAndReplace method.

func (*Collection) FindOneAndUpdate Uses

func (c *Collection) FindOneAndUpdate(ctx context.Context, filter, update interface{}, opts ...*options.FindOneAndUpdateOptions) ISingleResult

FindOneAndUpdate implements the ICollection.FindOneAndUpdate method.

func (*Collection) Indexes Uses

func (c *Collection) Indexes() IIndexView

Indexes implements the ICollection.Indexes method.

func (*Collection) InsertMany Uses

func (c *Collection) InsertMany(ctx context.Context, documents []interface{}, opts ...*options.InsertManyOptions) (*mongo.InsertManyResult, error)

InsertMany implements the ICollection.InsertMany method.

func (*Collection) InsertOne Uses

func (c *Collection) InsertOne(ctx context.Context, document interface{}, opts ...*options.InsertOneOptions) (*mongo.InsertOneResult, error)

InsertOne implements the ICollection.InsertOne method.

func (*Collection) Name Uses

func (c *Collection) Name() string

Name implements the ICollection.Name method.

func (*Collection) ReplaceOne Uses

func (c *Collection) ReplaceOne(ctx context.Context, filter, replacement interface{}, opts ...*options.ReplaceOptions) (*mongo.UpdateResult, error)

ReplaceOne implements the ICollection.ReplaceOne method.

func (*Collection) UpdateMany Uses

func (c *Collection) UpdateMany(ctx context.Context, filter, update interface{}, opts ...*options.UpdateOptions) (*mongo.UpdateResult, error)

UpdateMany implements the ICollection.UpdateMany method.

func (*Collection) UpdateOne Uses

func (c *Collection) UpdateOne(ctx context.Context, filter, update interface{}, opts ...*options.UpdateOptions) (*mongo.UpdateResult, error)

UpdateOne implements the ICollection.UpdateOne method.

func (*Collection) Watch Uses

func (c *Collection) Watch(_ context.Context, pipeline interface{}, opts ...*options.ChangeStreamOptions) (IChangeStream, error)

Watch implements the ICollection.Watch method.

type Cursor Uses

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

Cursor wraps a list to be mongo compatible.

func (*Cursor) All Uses

func (c *Cursor) All(_ context.Context, out interface{}) error

All implements the ICursor.All method.

func (*Cursor) Close Uses

func (c *Cursor) Close(context.Context) error

Close implements the ICursor.Close method.

func (*Cursor) Decode Uses

func (c *Cursor) Decode(out interface{}) error

Decode implements the ICursor.Decode method.

func (*Cursor) Err Uses

func (c *Cursor) Err() error

Err implements the ICursor.Err method.

func (*Cursor) ID Uses

func (c *Cursor) ID() int64

ID implements the ICursor.ID method.

func (*Cursor) Next Uses

func (c *Cursor) Next(context.Context) bool

Next implements the ICursor.Next method.

type Database Uses

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

Database wraps an Engine to be mongo compatible.

func (*Database) Aggregate Uses

func (d *Database) Aggregate(context.Context, interface{}, ...*options.AggregateOptions) (ICursor, error)

Aggregate implements the IDatabase.Aggregate method.

func (*Database) Client Uses

func (d *Database) Client() IClient

Client implements the IDatabase.Client method.

func (*Database) Collection Uses

func (d *Database) Collection(name string, opts ...*options.CollectionOptions) ICollection

Collection implements the IDatabase.Collection method.

func (*Database) Drop Uses

func (d *Database) Drop(ctx context.Context) error

Drop implements the IDatabase.Drop method.

func (*Database) ListCollectionNames Uses

func (d *Database) ListCollectionNames(ctx context.Context, filter interface{}, opts ...*options.ListCollectionsOptions) ([]string, error)

ListCollectionNames implements the IDatabase.ListCollectionNames method.

func (*Database) ListCollections Uses

func (d *Database) ListCollections(ctx context.Context, filter interface{}, opts ...*options.ListCollectionsOptions) (ICursor, error)

ListCollections implements the IDatabase.ListCollections method.

func (*Database) Name Uses

func (d *Database) Name() string

Name implements the IDatabase.Name method.

func (*Database) ReadConcern Uses

func (d *Database) ReadConcern() *readconcern.ReadConcern

ReadConcern implements the IDatabase.ReadConcern method.

func (*Database) ReadPreference Uses

func (d *Database) ReadPreference() *readpref.ReadPref

ReadPreference implements the IDatabase.ReadPreference method.

func (*Database) RunCommand Uses

func (d *Database) RunCommand(context.Context, interface{}, ...*options.RunCmdOptions) ISingleResult

RunCommand implements the IDatabase.RunCommand method.

func (*Database) RunCommandCursor Uses

func (d *Database) RunCommandCursor(context.Context, interface{}, ...*options.RunCmdOptions) (ICursor, error)

RunCommandCursor implements the IDatabase.RunCommandCursor method.

func (*Database) Watch Uses

func (d *Database) Watch(_ context.Context, pipeline interface{}, opts ...*options.ChangeStreamOptions) (IChangeStream, error)

Watch implements the IDatabase.Watch method.

func (*Database) WriteConcern Uses

func (d *Database) WriteConcern() *writeconcern.WriteConcern

WriteConcern implements the IDatabase.WriteConcern method.

type Engine Uses

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

Engine manages the catalog loaded from a store and provides access to it through transactions. Additionally, it also manages streams that subscribe to changes to the catalog.

func CreateEngine Uses

func CreateEngine(opts Options) (*Engine, error)

CreateEngine will create and return an engine with a loaded catalog from the store.

func (*Engine) Abort Uses

func (e *Engine) Abort(txn *Transaction)

Abort will abort the specified transaction. To ensure a transaction is always released, Abort should be called after finishing any transaction.

func (*Engine) Begin Uses

func (e *Engine) Begin(ctx context.Context, lock bool) (*Transaction, error)

Begin will create a new transaction from the current catalog. A locked transaction must be committed or aborted before another transaction can be started. Unlocked transactions serve as a point in time snapshots and can be just be discarded when not being used further.

func (*Engine) Close Uses

func (e *Engine) Close()

Close will close the engine.

func (*Engine) Commit Uses

func (e *Engine) Commit(txn *Transaction) error

Commit will attempt to store the modified catalog and on success replace the current catalog. If an error is returned the transaction has been aborted and become invalid.

func (*Engine) Watch Uses

func (e *Engine) Watch(handle Handle, pipeline bsonkit.List, resumeAfter, startAfter bsonkit.Doc, startAt *primitive.Timestamp) (*Stream, error)

Watch will return a stream that is able to consume events from the oplog.

type File Uses

type File struct {
    Namespaces map[string]FileNamespace `bson:"namespaces"`
}

File is the format of the file stored by the file store.

type FileIndex Uses

type FileIndex struct {
    Key     bsonkit.Doc   `bson:"key"`
    Unique  bool          `bson:"unique"`
    Partial bsonkit.Doc   `bson:"partial"`
    Expiry  time.Duration `bson:"expiry"`
}

FileIndex is a single index stored in a file by the file store.

type FileNamespace Uses

type FileNamespace struct {
    Documents bsonkit.List         `bson:"documents"`
    Indexes   map[string]FileIndex `bson:"indexes"`
}

FileNamespace is a single namespace stored in a file by the file store.

type FileStore Uses

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

FileStore writes the catalog to a single file on disk.

func NewFileStore Uses

func NewFileStore(path string, mode os.FileMode) *FileStore

NewFileStore creates and returns a new file store.

func (*FileStore) Load Uses

func (s *FileStore) Load() (*Catalog, error)

Load will read the catalog from disk and return it.

func (*FileStore) Store Uses

func (s *FileStore) Store(data *Catalog) error

Store will atomically write the catalog to disk.

type Handle Uses

type Handle [2]string

Handle is a two component identifier for namespaces where the first part is the database and the second the collection.

func (Handle) String Uses

func (h Handle) String() string

String will return the string form of the handle.

func (Handle) Validate Uses

func (h Handle) Validate(needCollection bool) error

Validate will validate the handle.

type IChangeStream Uses

type IChangeStream interface {
    Close(context.Context) error
    Decode(interface{}) error
    Err() error
    ID() int64
    Next(context.Context) bool
    ResumeToken() bson.Raw
}

IChangeStream defines a generic change stream.

type IClient Uses

type IClient interface {
    Connect(context.Context) error
    Database(string, ...*options.DatabaseOptions) IDatabase
    Disconnect(context.Context) error
    ListDatabaseNames(context.Context, interface{}, ...*options.ListDatabasesOptions) ([]string, error)
    ListDatabases(context.Context, interface{}, ...*options.ListDatabasesOptions) (mongo.ListDatabasesResult, error)
    Ping(context.Context, *readpref.ReadPref) error
    StartSession(...*options.SessionOptions) (ISession, error)
    UseSession(context.Context, func(ISessionContext) error) error
    UseSessionWithOptions(context.Context, *options.SessionOptions, func(ISessionContext) error) error
    Watch(context.Context, interface{}, ...*options.ChangeStreamOptions) (IChangeStream, error)
}

IClient defines a generic client.

func Connect Uses

func Connect(ctx context.Context, opts ...*options.ClientOptions) (IClient, error)

Connect will connect to a MongoDB database and return a lungo compatible client.

func NewClient Uses

func NewClient(engine *Engine) IClient

NewClient will create and return a new client.

type ICollection Uses

type ICollection interface {
    Aggregate(context.Context, interface{}, ...*options.AggregateOptions) (ICursor, error)
    BulkWrite(context.Context, []mongo.WriteModel, ...*options.BulkWriteOptions) (*mongo.BulkWriteResult, error)
    Clone(...*options.CollectionOptions) (ICollection, error)
    CountDocuments(context.Context, interface{}, ...*options.CountOptions) (int64, error)
    Database() IDatabase
    DeleteMany(context.Context, interface{}, ...*options.DeleteOptions) (*mongo.DeleteResult, error)
    DeleteOne(context.Context, interface{}, ...*options.DeleteOptions) (*mongo.DeleteResult, error)
    Distinct(context.Context, string, interface{}, ...*options.DistinctOptions) ([]interface{}, error)
    Drop(context.Context) error
    EstimatedDocumentCount(context.Context, ...*options.EstimatedDocumentCountOptions) (int64, error)
    Find(context.Context, interface{}, ...*options.FindOptions) (ICursor, error)
    FindOne(context.Context, interface{}, ...*options.FindOneOptions) ISingleResult
    FindOneAndDelete(context.Context, interface{}, ...*options.FindOneAndDeleteOptions) ISingleResult
    FindOneAndReplace(context.Context, interface{}, interface{}, ...*options.FindOneAndReplaceOptions) ISingleResult
    FindOneAndUpdate(context.Context, interface{}, interface{}, ...*options.FindOneAndUpdateOptions) ISingleResult
    Indexes() IIndexView
    InsertMany(context.Context, []interface{}, ...*options.InsertManyOptions) (*mongo.InsertManyResult, error)
    InsertOne(context.Context, interface{}, ...*options.InsertOneOptions) (*mongo.InsertOneResult, error)
    Name() string
    ReplaceOne(context.Context, interface{}, interface{}, ...*options.ReplaceOptions) (*mongo.UpdateResult, error)
    UpdateMany(context.Context, interface{}, interface{}, ...*options.UpdateOptions) (*mongo.UpdateResult, error)
    UpdateOne(context.Context, interface{}, interface{}, ...*options.UpdateOptions) (*mongo.UpdateResult, error)
    Watch(context.Context, interface{}, ...*options.ChangeStreamOptions) (IChangeStream, error)
}

ICollection defines a generic collection.

type ICursor Uses

type ICursor interface {
    All(context.Context, interface{}) error
    Close(context.Context) error
    Decode(interface{}) error
    Err() error
    ID() int64
    Next(context.Context) bool
}

ICursor defines a generic cursor.

type IDatabase Uses

type IDatabase interface {
    Aggregate(context.Context, interface{}, ...*options.AggregateOptions) (ICursor, error)
    Client() IClient
    Collection(string, ...*options.CollectionOptions) ICollection
    Drop(context.Context) error
    ListCollectionNames(context.Context, interface{}, ...*options.ListCollectionsOptions) ([]string, error)
    ListCollections(context.Context, interface{}, ...*options.ListCollectionsOptions) (ICursor, error)
    Name() string
    ReadConcern() *readconcern.ReadConcern
    ReadPreference() *readpref.ReadPref
    RunCommand(context.Context, interface{}, ...*options.RunCmdOptions) ISingleResult
    RunCommandCursor(context.Context, interface{}, ...*options.RunCmdOptions) (ICursor, error)
    Watch(context.Context, interface{}, ...*options.ChangeStreamOptions) (IChangeStream, error)
    WriteConcern() *writeconcern.WriteConcern
}

IDatabase defines a generic database.

type IIndexView Uses

type IIndexView interface {
    CreateMany(context.Context, []mongo.IndexModel, ...*options.CreateIndexesOptions) ([]string, error)
    CreateOne(context.Context, mongo.IndexModel, ...*options.CreateIndexesOptions) (string, error)
    DropAll(context.Context, ...*options.DropIndexesOptions) (bson.Raw, error)
    DropOne(context.Context, string, ...*options.DropIndexesOptions) (bson.Raw, error)
    List(context.Context, ...*options.ListIndexesOptions) (ICursor, error)
}

IIndexView defines a generic index view.

type ISession Uses

type ISession interface {
    AbortTransaction(context.Context) error
    AdvanceClusterTime(bson.Raw) error
    AdvanceOperationTime(*primitive.Timestamp) error
    Client() IClient
    ClusterTime() bson.Raw
    CommitTransaction(context.Context) error
    EndSession(context.Context)
    OperationTime() *primitive.Timestamp
    StartTransaction(...*options.TransactionOptions) error
    WithTransaction(context.Context, func(ISessionContext) (interface{}, error), ...*options.TransactionOptions) (interface{}, error)
}

ISession defines a generic session.

type ISessionContext Uses

type ISessionContext interface {
    context.Context
    ISession
}

ISessionContext defines a generic session context.

type ISingleResult Uses

type ISingleResult interface {
    Decode(interface{}) error
    DecodeBytes() (bson.Raw, error)
    Err() error
}

ISingleResult defines a generic single result

type IndexView Uses

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

IndexView wraps an Engine to be mongo compatible.

func (*IndexView) CreateMany Uses

func (v *IndexView) CreateMany(ctx context.Context, indexes []mongo.IndexModel, opts ...*options.CreateIndexesOptions) ([]string, error)

CreateMany implements the IIndexView.CreateMany method.

func (*IndexView) CreateOne Uses

func (v *IndexView) CreateOne(ctx context.Context, index mongo.IndexModel, opts ...*options.CreateIndexesOptions) (string, error)

CreateOne implements the IIndexView.CreateOne method.

func (*IndexView) DropAll Uses

func (v *IndexView) DropAll(ctx context.Context, opts ...*options.DropIndexesOptions) (bson.Raw, error)

DropAll implements the IIndexView.DropAll method.

func (*IndexView) DropOne Uses

func (v *IndexView) DropOne(ctx context.Context, name string, opts ...*options.DropIndexesOptions) (bson.Raw, error)

DropOne implements the IIndexView.DropOne method.

func (*IndexView) List Uses

func (v *IndexView) List(ctx context.Context, opts ...*options.ListIndexesOptions) (ICursor, error)

List implements the IIndexView.List method.

type MemoryStore Uses

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

MemoryStore holds the catalog in memory.

func NewMemoryStore Uses

func NewMemoryStore() *MemoryStore

NewMemoryStore creates and returns a new memory store.

func (MemoryStore) Load Uses

func (m MemoryStore) Load() (*Catalog, error)

Load will return the catalog.

func (MemoryStore) Store Uses

func (m MemoryStore) Store(data *Catalog) error

Store will store the catalog.

type MongoClient Uses

type MongoClient struct {
    *mongo.Client
}

MongoClient wraps a mongo.Client to be lungo compatible.

func (*MongoClient) Database Uses

func (c *MongoClient) Database(name string, opts ...*options.DatabaseOptions) IDatabase

Database implements the IClient.Database method.

func (*MongoClient) StartSession Uses

func (c *MongoClient) StartSession(opts ...*options.SessionOptions) (ISession, error)

StartSession implements the IClient.StartSession method.

func (*MongoClient) UseSession Uses

func (c *MongoClient) UseSession(ctx context.Context, fn func(ISessionContext) error) error

UseSession implements the IClient.UseSession method.

func (*MongoClient) UseSessionWithOptions Uses

func (c *MongoClient) UseSessionWithOptions(ctx context.Context, opt *options.SessionOptions, fn func(ISessionContext) error) error

UseSessionWithOptions implements the IClient.UseSessionWithOptions method.

func (*MongoClient) Watch Uses

func (c *MongoClient) Watch(ctx context.Context, pipeline interface{}, opts ...*options.ChangeStreamOptions) (IChangeStream, error)

Watch implements the IClient.Watch method.

type MongoCollection Uses

type MongoCollection struct {
    *mongo.Collection
    // contains filtered or unexported fields
}

MongoCollection wraps a mongo.Collection to be lungo compatible.

func (*MongoCollection) Aggregate Uses

func (c *MongoCollection) Aggregate(ctx context.Context, pipeline interface{}, opts ...*options.AggregateOptions) (ICursor, error)

Aggregate implements the ICollection.Aggregate method.

func (*MongoCollection) Clone Uses

func (c *MongoCollection) Clone(opts ...*options.CollectionOptions) (ICollection, error)

Clone implements the ICollection.Clone method.

func (*MongoCollection) Database Uses

func (c *MongoCollection) Database() IDatabase

Database implements the ICollection.Database method.

func (*MongoCollection) Find Uses

func (c *MongoCollection) Find(ctx context.Context, filter interface{}, opts ...*options.FindOptions) (ICursor, error)

Find implements the ICollection.Find method.

func (*MongoCollection) FindOne Uses

func (c *MongoCollection) FindOne(ctx context.Context, filter interface{}, opts ...*options.FindOneOptions) ISingleResult

FindOne implements the ICollection.FindOne method.

func (*MongoCollection) FindOneAndDelete Uses

func (c *MongoCollection) FindOneAndDelete(ctx context.Context, filter interface{}, opts ...*options.FindOneAndDeleteOptions) ISingleResult

FindOneAndDelete implements the ICollection.FindOneAndDelete method.

func (*MongoCollection) FindOneAndReplace Uses

func (c *MongoCollection) FindOneAndReplace(ctx context.Context, filter, replacement interface{}, opts ...*options.FindOneAndReplaceOptions) ISingleResult

FindOneAndReplace implements the ICollection.FindOneAndReplace method.

func (*MongoCollection) FindOneAndUpdate Uses

func (c *MongoCollection) FindOneAndUpdate(ctx context.Context, filter, update interface{}, opts ...*options.FindOneAndUpdateOptions) ISingleResult

FindOneAndUpdate implements the ICollection.FindOneAndUpdate method.

func (*MongoCollection) Indexes Uses

func (c *MongoCollection) Indexes() IIndexView

Indexes implements the ICollection.Indexes method.

func (*MongoCollection) Watch Uses

func (c *MongoCollection) Watch(ctx context.Context, pipeline interface{}, opts ...*options.ChangeStreamOptions) (IChangeStream, error)

Watch implements the ICollection.Watch method.

type MongoDatabase Uses

type MongoDatabase struct {
    *mongo.Database
    // contains filtered or unexported fields
}

MongoDatabase wraps a mongo.Database to be lungo compatible.

func (*MongoDatabase) Aggregate Uses

func (d *MongoDatabase) Aggregate(ctx context.Context, pipeline interface{}, opts ...*options.AggregateOptions) (ICursor, error)

Aggregate implements the IDatabase.Aggregate method.

func (*MongoDatabase) Client Uses

func (d *MongoDatabase) Client() IClient

Client implements the IDatabase.Client method.

func (*MongoDatabase) Collection Uses

func (d *MongoDatabase) Collection(name string, opts ...*options.CollectionOptions) ICollection

Collection implements the IDatabase.Collection method.

func (*MongoDatabase) ListCollections Uses

func (d *MongoDatabase) ListCollections(ctx context.Context, filter interface{}, opts ...*options.ListCollectionsOptions) (ICursor, error)

ListCollections implements the IDatabase.ListCollections method.

func (*MongoDatabase) RunCommand Uses

func (d *MongoDatabase) RunCommand(ctx context.Context, runCommand interface{}, opts ...*options.RunCmdOptions) ISingleResult

RunCommand implements the IDatabase.RunCommand method.

func (*MongoDatabase) RunCommandCursor Uses

func (d *MongoDatabase) RunCommandCursor(ctx context.Context, filter interface{}, opts ...*options.RunCmdOptions) (ICursor, error)

RunCommandCursor implements the IDatabase.RunCommandCursor method.

func (*MongoDatabase) Watch Uses

func (d *MongoDatabase) Watch(ctx context.Context, pipeline interface{}, opts ...*options.ChangeStreamOptions) (IChangeStream, error)

Watch implements the IDatabase.Watch method.

type MongoIndexView Uses

type MongoIndexView struct {
    *mongo.IndexView
}

MongoIndexView wraps a mongo.IndexView to be lungo compatible.

func (*MongoIndexView) List Uses

func (m *MongoIndexView) List(ctx context.Context, opts ...*options.ListIndexesOptions) (ICursor, error)

List implements the IIndexView.List method.

type MongoSession Uses

type MongoSession struct {
    mongo.Session
    // contains filtered or unexported fields
}

MongoSession wraps a mongo.Session to be lungo compatible.

func (*MongoSession) Client Uses

func (s *MongoSession) Client() IClient

Client implements the ISession.Client method.

func (*MongoSession) WithTransaction Uses

func (s *MongoSession) WithTransaction(ctx context.Context, fn func(ISessionContext) (interface{}, error), opts ...*options.TransactionOptions) (interface{}, error)

WithTransaction implements the ISession.WithTransaction method.

type MongoSessionContext Uses

type MongoSessionContext struct {
    context.Context
    *MongoSession
}

MongoSessionContext wraps a mongo.SessionContext to be lungo compatible.

type Opcode Uses

type Opcode int

Opcode defines the type of an operation.

const (
    Insert Opcode = iota
    Replace
    Update
    Delete
)

The available opcodes.

func (Opcode) String Uses

func (c Opcode) String() string

Strings returns the opcode name.

type Operation Uses

type Operation struct {
    // The opcode.
    Opcode Opcode

    // The filter document (replace, update, delete).
    Filter bsonkit.Doc

    // The insert, update or replacement document.
    Document bsonkit.Doc

    // Whether an upsert should be performed (replace, update).
    Upsert bool

    // The limit (one, many).
    Limit int
}

Operation defines a single operation.

type Options Uses

type Options struct {
    // The store used by the engine to load and store the catalog.
    Store Store

    // The interval at which expired documents are removed.
    //
    // Default: 60s.
    ExpireInterval time.Duration

    // The function that is called with errors from the expiry goroutine.
    ExpireErrors func(error)
}

Options is used to configure an engine.

type Result Uses

type Result struct {
    // The list of matched documents.
    Matched bsonkit.List

    // The list of inserted, replace or updated documents.
    Modified bsonkit.List

    // The upserted document.
    Upserted bsonkit.Doc

    // The error that occurred during the operation.
    Error error
}

Result describes the outcome of an operation.

type Session Uses

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

Session provides a mongo compatible way to handle transactions.

func (*Session) AbortTransaction Uses

func (s *Session) AbortTransaction(context.Context) error

AbortTransaction implements the ISession.AbortTransaction method.

func (*Session) AdvanceClusterTime Uses

func (s *Session) AdvanceClusterTime(bson.Raw) error

AdvanceClusterTime implements the ISession.AdvanceClusterTime method.

func (*Session) AdvanceOperationTime Uses

func (s *Session) AdvanceOperationTime(*primitive.Timestamp) error

AdvanceOperationTime implements the ISession.AdvanceOperationTime method.

func (*Session) Client Uses

func (s *Session) Client() IClient

Client implements the ISession.Client method.

func (*Session) ClusterTime Uses

func (s *Session) ClusterTime() bson.Raw

ClusterTime implements the ISession.ClusterTime method.

func (*Session) CommitTransaction Uses

func (s *Session) CommitTransaction(context.Context) error

CommitTransaction implements the ISession.CommitTransaction method.

func (*Session) EndSession Uses

func (s *Session) EndSession(context.Context)

EndSession implements the ISession.EndSession method.

func (*Session) OperationTime Uses

func (s *Session) OperationTime() *primitive.Timestamp

OperationTime implements the ISession.OperationTime method.

func (*Session) StartTransaction Uses

func (s *Session) StartTransaction(opts ...*options.TransactionOptions) error

StartTransaction implements the ISession.StartTransaction method.

func (*Session) Transaction Uses

func (s *Session) Transaction() *Transaction

Transaction will return the active transaction or nil if no transaction has been started.

func (*Session) WithTransaction Uses

func (s *Session) WithTransaction(ctx context.Context, fn func(ISessionContext) (interface{}, error), opts ...*options.TransactionOptions) (interface{}, error)

WithTransaction implements the ISession.WithTransaction method.

type SessionContext Uses

type SessionContext struct {
    context.Context
    *Session
}

SessionContext provides a mongo compatible session context.

type SingleResult Uses

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

SingleResult wraps a result to be mongo compatible.

func (*SingleResult) Decode Uses

func (r *SingleResult) Decode(out interface{}) error

Decode implements the ISingleResult.Decode method.

func (*SingleResult) DecodeBytes Uses

func (r *SingleResult) DecodeBytes() (bson.Raw, error)

DecodeBytes implements the ISingleResult.DecodeBytes method.

func (*SingleResult) Err Uses

func (r *SingleResult) Err() error

Err implements the ISingleResult.Err method.

type Store Uses

type Store interface {
    Load() (*Catalog, error)
    Store(*Catalog) error
}

Store is the interface that describes storage adapters.

type Stream Uses

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

Stream provides a mongo compatible way to read oplog events.

func (*Stream) Close Uses

func (s *Stream) Close(context.Context) error

Close implements the IChangeStream.Close method.

func (*Stream) Decode Uses

func (s *Stream) Decode(out interface{}) error

Decode implements the IChangeStream.Decode method.

func (*Stream) Err Uses

func (s *Stream) Err() error

Err implements the IChangeStream.Err method.

func (*Stream) ID Uses

func (s *Stream) ID() int64

ID implements the IChangeStream.ID method.

func (*Stream) Next Uses

func (s *Stream) Next(ctx context.Context) bool

Next implements the IChangeStream.Next method.

func (*Stream) ResumeToken Uses

func (s *Stream) ResumeToken() bson.Raw

ResumeToken implements the IChangeStream.ResumeToken method.

type Transaction Uses

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

Transaction buffers multiple changes to a catalog.

func NewTransaction Uses

func NewTransaction(catalog *Catalog) *Transaction

NewTransaction creates and returns a new transaction.

func (*Transaction) Bulk Uses

func (t *Transaction) Bulk(handle Handle, ops []Operation, ordered bool) ([]Result, error)

Bulk performs the specified operations in one go. If ordered is true the process is aborted on the first error.

func (*Transaction) Catalog Uses

func (t *Transaction) Catalog() *Catalog

Catalog will return the modified catalog by the transaction.

func (*Transaction) CountDocuments Uses

func (t *Transaction) CountDocuments(handle Handle) (int, error)

CountDocuments will return the number of documents in the specified namespace.

func (*Transaction) CreateIndex Uses

func (t *Transaction) CreateIndex(handle Handle, name string, config mongokit.IndexConfig) (string, error)

CreateIndex will create the specified index in the specified namespace. It is a no-op if an index with the same name and configuration already exists.

func (*Transaction) Delete Uses

func (t *Transaction) Delete(handle Handle, query, sort bsonkit.Doc, limit int) (*Result, error)

Delete will remove all matching documents from the namespace. Sort, skip and limit may be supplied to modify the result. The returned result will contain the matched documents.

func (*Transaction) Dirty Uses

func (t *Transaction) Dirty() bool

Dirty will return whether the transaction contains changes.

func (*Transaction) Drop Uses

func (t *Transaction) Drop(handle Handle) error

Drop will return the namespace with the specified handle from the catalog. If the second part of the handle is empty, it will drop all namespaces matching the first part.

func (*Transaction) DropIndex Uses

func (t *Transaction) DropIndex(handle Handle, name string) error

DropIndex will drop the specified index in the specified namespace.

func (*Transaction) Expire Uses

func (t *Transaction) Expire() error

Expire will remove documents that are expired due to a TTL index.

func (*Transaction) Find Uses

func (t *Transaction) Find(handle Handle, query, sort bsonkit.Doc, skip, limit int) (*Result, error)

Find will query documents from a namespace. Sort, skip and limit may be supplied to modify the result. The returned results will contain the matched list of documents.

func (*Transaction) Insert Uses

func (t *Transaction) Insert(handle Handle, list bsonkit.List, ordered bool) (*Result, error)

Insert will insert the specified documents into the namespace. The engine will automatically generate an object id per document if it is missing. If ordered is enabled the operation is aborted on the first error and the result returned. Otherwise, the engine will try to insert all documents. The returned results will contain the inserted documents and potential errors.

func (*Transaction) ListCollections Uses

func (t *Transaction) ListCollections(handle Handle, query bsonkit.Doc) (bsonkit.List, error)

ListCollections will return a list of all collections in the specified db.

func (*Transaction) ListDatabases Uses

func (t *Transaction) ListDatabases(query bsonkit.Doc) (bsonkit.List, error)

ListDatabases will return a list of all databases in the catalog.

func (*Transaction) ListIndexes Uses

func (t *Transaction) ListIndexes(handle Handle) (bsonkit.List, error)

ListIndexes will return a list of indexes in the specified namespace.

func (*Transaction) Replace Uses

func (t *Transaction) Replace(handle Handle, query, sort, repl bsonkit.Doc, upsert bool) (*Result, error)

Replace will replace the first matching document with the specified replacement document. If upsert is enabled, it will insert the replacement document if it is missing. The returned result will contain the matched and modified or upserted document.

func (*Transaction) Update Uses

func (t *Transaction) Update(handle Handle, query, sort, update bsonkit.Doc, limit int, upsert bool) (*Result, error)

Update will apply the update to all matching document. Sort, skip and limit may be supplied to modify the result. If upsert is enabled, it will extract constant parts of the query and apply the update and insert the document if it is missing. The returned result will contain the matched and modified or upserted document.

Directories

PathSynopsis
bsonkit
dbkit
mongokit

Package lungo imports 21 packages (graph) and is imported by 1 packages. Updated 2019-12-02. Refresh now. Tools for package owners.