# goriak [![Build Status](https://circleci.com/gh/zegl/goriak.svg?style=shield)](https://circleci.com/gh/zegl/goriak) [![codecov](https://codecov.io/gh/zegl/goriak/branch/v3/graph/badge.svg)](https://codecov.io/gh/zegl/goriak/branch/v3) [![Go Report Card](https://goreportcard.com/badge/gopkg.in/zegl/goriak.v3)](https://goreportcard.com/report/gopkg.in/zegl/goriak.v3)

Current version: `v3.2.1`.  
Riak KV version: 2.0 or higher, the latest version of Riak KV is always recommended. 

![](https://i.imgur.com/0RmZ9E5.png)

# What is goriak?

goriak is a wrapper around [riak-go-client](https://github.com/basho/riak-go-client) (version `1.9.0` or newer is required) to make it easier and more friendly for developers to use Riak KV.

* [Documentation](https://godoc.org/gopkg.in/zegl/goriak.v3)

# Installation

As a Go module (requires Go 1.11 or later):

```bash
go get github.com/zegl/goriak/v3@v3.2.3
```

As a Go package:

```bash
go get -u gopkg.in/zegl/goriak.v3
```

# Maps (Riak Data Types)

The main feature of goriak is that goriak automatically can marshal/unmarshal your Go types into [Riak data types](http://docs.basho.com/riak/kv/2.1.4/developing/data-types/).

## Set (Riak Data Types)

In the example below `Name` will be saved as a register, and `Aliases` will be a set.

```go
type User struct {
    Name    string
    Aliases []string
}

user := User {
    Name:   "Foo",
    Alises: []string{"Foo", "Bar"},
}

goriak.Bucket("bucket-name", "bucket-type").Set(user).Key("key").Run(c)
```

### Tags

Struct tags can be used to change the name of the item, or to ignore it.

```go
type User struct {
    Name    string   `goriak:"-"`       // Ignore field
    Aliases []string `goriak:"aliases"` // Save as "aliases" in Riak KV
}
```


## Get (Riak Data Types)

The map can later be retreived as a whole:

```go
var res User
goriak.Bucket("bucket-name", "bucket-type").Get("key", &res).Run(c)
```

## Supported Go types


|  Go Type    | Riak Type |
|-------------|-----------|
| `struct`    | map       |
| `string`    | register  |
| `[n]byte`   | register  |
| `[]byte`    | register  |
| `[]slice`   | set       |
| `[]slice`   | set       |
| `[][]byte`  | set       |
| `map`       | map       |
| `time.Time` | register  |
| int [1]     | register  |

1: All signed and unsigned integer types are supported.

### Golang map types

Supported key types: all integer types, `string`.  
Supported value types: `string`, `[]byte`.

## Helper types

Some actions are more complicated then necessary with the use of the default Go types and `MapOperations`.

This is why goriak contains the types `Counter`, `Set`, `Flag` and `Register`. All of these types will help you performing actions such as incrementing a value, or adding/removing items.

### Counters

Riak Counters is supported with the special `goriak.Counter` type.

Example:

```go
type Article struct {
    Title string
    Views *goriak.Counter
}

// Get our object
var article Article
goriak.Bucket("articles", "map").Get("1-hello-world", &article).Run(con)

// Increase views by 1
err := article.Views.Increase(1).Exec(con)

// check err
```

`Counter.Exec(con)` will make a lightweight request to Riak, and the counter is the only object that will be updated.

You can also save the changes to your counter with `SetMap()`, this is useful if you want to change multiple counters at the same time.

Check [godoc](https://godoc.org/github.com/zegl/goriak) for more information.

### Sets

You can chose to use `goriak.Set` to help you with Set related actions, such as adding and removing items. `goriak.Set` also has support for sending incremental actions to Riak so that you don't have to build that functionality yourself.

Example:

```go
type Article struct {
    Title string
    Tags *goriak.Set
}

// Get our object
var article Article
goriak.Bucket("articles", "map").Get("1-hello-world", &article).Run(con)

// Add the tag "animals"
err := article.Tags.AddString("animals").Exec(con)

// check err
```

Check [godoc](https://godoc.org/github.com/zegl/goriak#Set) for more information.

# Values

Values can be automatically JSON Marshalled/Unmarshalled by using `SetJSON()` and `GetJSON()`.
There is also `SetRaw()` and `GetRaw()` that works directly on `[]byte`s.

## JSON

```go
// Set object
goriak.Bucket("bucket-name", "bucket-type").SetJSON(obj).Key("key").Run(con)

// Get object
goriak.Bucket("bucket-name", "bucket-type").GetJSON("key", &obj).Run(con)
```

## MapOperation

There is a time in everyones life where you need to perform raw MapOperations on your Riak Data Values.

Some operations, such as `RemoveFromSet` requires a Context to perform the operation.
A Context can be retreived from `Get` by setting a special context type.


```go
type ourType struct {
    Aliases []string

    // The context from Riak will be added if the tag goriakcontext is provided
    Context []byte `goriak:"goriakcontext"`
}

// ... GetMap()

// Works with MapOperation from github.com/basho/riak-go-client
operation := goriak.NewMapOperation()
operation.AddToSet("Aliases", []byte("Baz"))

goriak.MapOperation("bucket-name", "bucket-type", "key", operation, val.Context)
```


# Secondary Indexes

You can set secondary indexes automatically with `SetJSON()` by using struct tags.

Strings and all signed integer types are supported. Both as-is and in slices.

```go
type User struct {
    Name    string `goriakindex:"nameindex_bin"`
    Aliases []string
}
```

Indexes can also be used in slices. If you are using a slice every value in the slice will be added to the index.

```go
type User struct {
    Aliases []string `goriakindex:"aliasesindex_bin"`
}
```


When saved the next time the index will be updated.

## KeysInIndex

Keys in a particular index can be retreived with `KeysInIndex`.

```go
callback := func(item goriak.SecondaryIndexQueryResult) {
    // use item
}

goriak.Bucket("bucket-name", "bucket-type").
    KeysInIndex("nameindex_bin", "Value", callback).
    Run(con)
```

## AddToIndex

An alternative way of setting Secondary Indexes is by using `AddToIndex()`.

```go
goriak.Bucket("bucket-name", "bucket-type").
    SetRaw(data).
    AddToIndex("indexname_bin", "value").
    Run(con)
```


goriak

Kivik provides a common Go and GopherJS client library for CouchDB, PouchDB, and similar databases

[![Build Status](https://github.com/go-kivik/kivik/actions/workflows/tests.yaml/badge.svg?branch=main)](https://github.com/go-kivik/kivik/actions/workflows/tests.yaml)
 [![Codecov](https://img.shields.io/codecov/c/github/go-kivik/kivik.svg?style=flat)](https://codecov.io/gh/go-kivik/kivik) [![Go Report Card](https://goreportcard.com/badge/github.com/go-kivik/kivik)](https://goreportcard.com/report/github.com/go-kivik/kivik) [![Go Reference](https://pkg.go.dev/badge/github.com/go-kivik/kivik/v4.svg)](https://pkg.go.dev/github.com/go-kivik/kivik/v4) [![Website](https://img.shields.io/website-up-down-green-red/http/kivik.io.svg?label=website&colorB=007fff)](http://kivik.io)

# Kivik

Package kivik provides a common interface to CouchDB or CouchDB-like databases.

The kivik package must be used in conjunction with a database driver.

The kivik driver system is modeled after the standard library's [database/sql](https://golang.org/pkg/database/sql/)
and [sql/driver](https://golang.org/pkg/database/sql/driver/) packages, although
the client API is completely different due to the different database models
implemented by SQL and NoSQL databases such as CouchDB.

# Versions

You are browsing the current **stable** branch of Kivik, v4. The current version requires Go 1.20 or newer.

Example configuration for common dependency managers follow.

# Installation

Install Kivik as you normally would for any Go package:

    go get -u github.com/go-kivik/kivik/v4

This will install the main Kivik package and the CouchDB database driver. Three officially supported drivers are shipped with this Go module:

- CouchDB: [github.com/go-kivik/kivik/v4/couchdb](https://pkg.go.dev/github.com/go-kivik/kivik/v4/couchdb)
- PouchDB: [github.com/go-kivik/kivik/v4/pouchdb](https://pkg.go.dev/github.com/go-kivik/kivik/v4/pouchdb) (requires GopherJS)
- MockDB: [github.com/go-kivik/kivik/v4/mockdb](https://pkg.go.dev/github.com/go-kivik/kivik/v4/mockdb)

In addition, there are partial/experimental drivers available:

- FilesystemDB: [github.com/go-kivik/kivik/v4/x/fsdb](https://pkg.go.dev/github.com/go-kivik/kivik/v4/x/fsdb)
- MemoryDB: [github.com/go-kivik/kivik/v4/x/memorydb](https://pkg.go.dev/github.com/go-kivik/kivik/v4/x/memorydb)
- SQLite: [github.com/go-kivik/kivik/x/sqlite/v4](https://pkg.go.dev/github.com/go-kivik/kivik/x/sqlite/v4)

# CLI

Consult the [CLI README](https://github.com/go-kivik/kivik/blob/main/cmd/kivik/README.md) for full details on the `kivik` CLI tool.

# Example Usage

Please consult the the [package documentation](https://pkg.go.dev/github.com/go-kivik/kivik/v4)
for all available API methods, and a complete usage documentation, and usage examples.

```go
package main

import (
    "context"
    "fmt"

    kivik "github.com/go-kivik/kivik/v4"
    _ "github.com/go-kivik/kivik/v4/couchdb" // The CouchDB driver
)

func main() {
    client, err := kivik.New("couch", "http://localhost:5984/")
    if err != nil {
        panic(err)
    }

    db := client.DB("animals")

    doc := map[string]interface{}{
        "_id":      "cow",
        "feet":     4,
        "greeting": "moo",
    }

    rev, err := db.Put(context.TODO(), "cow", doc)
    if err != nil {
        panic(err)
    }
    fmt.Printf("Cow inserted with revision %s\n", rev)
}
```

# Frequently Asked Questions

Nobody has ever asked me any of these questions, so they're probably better called
"Never Asked Questions" or possibly "Imagined Questions."

## Why another CouchDB client API?

I had a number of specific design goals when creating this package:

- Provide a generic database API for a variety of CouchDB-like databases. The previously existing drivers for CouchDB had patchy support for different versions of CouchDB, and different subsets of functionality.
- Work equally well with CouchDB 1.6, 2.x, 3.x, and any future versions, as well as PouchDB.
- Be as Go-idiomatic as possible.
- Be unambiguously open-source. Kivik is released under the Apache license, same as CouchDB and PouchDB.
- Separate out the basic implementation of a database driver (implementing the `kivik/driver` interfaces) vs the implementation of all the user-level types and convenience methods. It ought to be reasonably easy to create a new driver, for testing, mocking, implementing a new backend data storage system, or talking to other CouchDB-like databases.

## What are Kivik's requirements?

Kivik's test suite is automatically run on Linux for every pull request, but
should work on all supported Go architectures. If you find it not working for
your OS/architecture, please submit a bug report.

Below are the compatibility targets for specific runtime and database versions.
If you discover a bug affecting any of these supported environments, please let
me know by submitting a bug report via GitHub.

- **Go** Kivik 4.x aims for full compatibility with all stable releases of Go
  from 1.13. For Go 1.7 or 1.8 you can use [Kivik 1.x](https://github.com/go-kivik/kivik/tree/v1).
  For Go 1.9 through 1.12, you can use [Kivik 3.x](https://github.com/go-kivik/kivik/tree/v3).
- **CouchDB** The Kivik 4.x CouchDB driver aims for compatibility with all
  stable releases of CouchDB from 2.x.
- **GopherJS** GopherJS always requires the latest stable version of Go, so
  building Kivik with GopherJS has this same requirement.
- **PouchDB** The Kivik 4.x PouchDB driver aims for compatibility with all
  stable releases of PouchDB from 8.0.0.

## What is the development status?

Kivik 4.x is stable, and suitable for production use.

## Why the name "Kivik"?

[Kivik](http://www.ikea.com/us/en/catalog/categories/series/18329/) is a line
of sofas (couches) from IKEA. And in the spirit of IKEA, and build-your-own
furniture, Kivik aims to allow you to "build your own" CouchDB client, server,
and proxy applications.

## What license is Kivik released under?

Kivik is Copyright 2017-2023 by the Kivik contributors, and is released under the
terms of the Apache 2.0 license. See [LICENCE](LICENSE) for the full text of the
license.

### Changes from 3.x to 4.x

This is a partial list of breaking changes between 3.x and 4.x

- Options are no longer a simple `map[string]interface{}`, but are rather functional parameters. In most cases, you can just use `kivik.Param(key, value)`, or `kivik.Params(map[string]interface{}{key: value})` as a replacement. Some shortcuts for common params now exist, and driver-specific options may work differently. Consult the GoDoc.
- The `Authenticate` method has been removed. Authentication is now handled via option parameters.
- The CouchDB, PouchDB, and MockDB drivers, and the experimental FilesystemDB and MemoryDB drivers, have been merged with this repo, rather than being hosted in separate repos. For v3 you would have imported `github.com/go-kivik/couchdb/v3`, for example. With v4, you instead use `github.com/go-kivik/kivik/v4/couchdb` for CouchDB, or `github.com/go-kivik/kivik/v4/x/fsdb` for the experimental FilesystemDB driver.
- The return type for queries has been significantly changed.
  - In 3.x, queries returned a `*Rows` struct. Now they return a `*ResultSet`.
  - The `Offset()`, `TotalRows()`, `UpdateSeq()`, `Warning()` and `Bookmark()` methods have been removed, and replaced with the `ResultMetadata` type which is accessed via the `Metadata()` method. See [issue #552](https://github.com/go-kivik/kivik/issues/552).
  - Calling most methods on `ResultSet` will now work after closing the iterator.
  - The new `ResultSet` type supports multi-query mode, which is triggered by calling `NextResultSet` before `Next`.
  - `Key`, `ID`, `Rev`, `Attachments` all now return row-specific errors, and `ScanKey` may successfully decode while also returning a row-specific error.
- The `Changes` type has been changed to semantically match the `ResultSet` type. Specifically, the `LastSeq()` and `Pending()` methods have been replaced by the `Metadata()` method.
- The `DBUpdates()` and `Changes()` methods now defer errors to the iterator, for easier chaining and consistency with other iterators.
- `DB.BulkDocs()` no longer returns an iterator, but rather an array of all results.
- `Get` now returns a simpler `*Result` type than before.
- `GetMeta` has been replaced with `GetRev`, and no longer claims to return the document size. The document size was never _really_ the document size, rather it is the `Content-Length` field of the HTTP response, which can vary depending on query parameters, making its use for determining document size dubious at best.
- The `StatusCode() int` method on errors has been renamed to `HTTPStatus() int`, to be more descriptive. The related package function `StatusCode(error) int` has also been renamed to `HTTPStatus(error) int` to match.
- `Client.Close()` and `DB.Close()` now block until any relevant calls have returned.
- `Client.Close()` and `DB.Close()` no longer take a `context.Context` value. These operations cannot actually be canceled anyway, by the one driver that uses them (PouchDB); it only stops waiting. It makes more senes to make these functions blocking indefinitely, especially now that they wait for client requests to finish, and let the caller stop waiting if it wants to.

#### CouchDB specific changes

- The `SetTransport` authentication method has been removed, as a duplicate of [couchdb.OptionHTTPClient](https://pkg.go.dev/github.com/go-kivik/kivik/v4/couchdb#OptionHTTPClient).
- Options passed to Kivik functions are now functional options, rather than a map of string to empty interface. As such, many of the options have changed. Consult the relevant GoDoc.

#### New features and additions

- Kivik now ships with the `kivik` command line tool (previously part of the `github.com/go-kivik/xkivik` repository).
- The new [Replicate](https://pkg.go.dev/github.com/go-kivik/kivik/v4#Replicate) function allows replication between arbitrary databases, such as between CouchDB and a directory structure using the FilesystemDB.

## What projects currently use Kivik?

If your project uses Kivik, and you'd like to be added to this list, create an
issue or submit a pull request.

- [Cayley](https://github.com/cayleygraph/cayley) is an open-source graph
  database. It uses Kivik for the CouchDB and PouchDB storage backends.


Kivik

MongoDB model-based ODM for Go (based on official MongoDB driver)

<img width="250" src="https://user-images.githubusercontent.com/22454054/71487214-759cb680-282f-11ea-9bcf-caa663b3e348.png" />




 <a href="https://goreportcard.com/report/github.com/Kamva/mgm">
 <img src="https://goreportcard.com/badge/github.com/Kamva/mgm">
 </a>
 <a href="https://godoc.org/github.com/Kamva/mgm">
 <img src="https://godoc.org/github.com/Kamva/mgm?status.svg" alt="GoDoc">
 </a>
 <a href="https://travis-ci.com/Kamva/mgm">
 <img src="https://travis-ci.com/Kamva/mgm.svg?branch=master" alt="Build Status">
 </a>
 <a href="https://codecov.io/gh/Kamva/mgm">
 <img src="https://codecov.io/gh/Kamva/mgm/branch/master/graph/badge.svg" />
 </a>

 

# Mongo Go Models 

The Mongo ODM for Go

- [Features](#features)
- [Requirements](#requirements)
- [Installation](#installation)
- [Usage](#usage)
- [Bugs / Feature Requests](#bugs--feature-request)
- [Communicate With Us](#communicate-with-us)
- [Contributing](#contributing)
- [License](#license)

## Features
- Define your models and perform CRUD operations with hooks before/after each operation.
- `mgm` makes Mongo search and aggregation super easy to do in Golang.
- Just set up your configs once and get collections anywhere you need them.
- `mgm` predefines all Mongo operators and keys, so you don't have to hardcode them yourself.
- `mgm` wraps the official Mongo Go Driver.

## Requirements
- Go 1.17 or higher.
- MongoDB 3.6 and higher.

## Installation

```bash
go get github.com/kamva/mgm/v3
```


## Usage
To get started, import the `mgm` package and setup the default config:
```go
import (
 "github.com/kamva/mgm/v3"
 "go.mongodb.org/mongo-driver/mongo/options"
)

func init() {
 // Setup the mgm default config
 err := mgm.SetDefaultConfig(nil, "mgm_lab", options.Client().ApplyURI("mongodb://root:12345@localhost:27017"))
}
```

Define your model:
```go
type Book struct {
 // DefaultModel adds _id, created_at and updated_at fields to the Model.
 mgm.DefaultModel `bson:",inline"`
 Name string `json:"name" bson:"name"`
 Pages int `json:"pages" bson:"pages"`
}

func NewBook(name string, pages int) *Book {
 return &Book{
 Name: name,
 Pages: pages,
 }
}
```

Insert new document:
```go
book := NewBook("Pride and Prejudice", 345)

// Make sure to pass the model by reference (to update the model's "updated_at", "created_at" and "id" fields by mgm).
err := mgm.Coll(book).Create(book)
```

Find one document 
```go
// Get the document's collection
book := &Book{}
coll := mgm.Coll(book)

// Find and decode the doc to a book model.
_ = coll.FindByID("5e0518aa8f1a52b0b9410ee3", book)

// Get the first doc of the collection 
_ = coll.First(bson.M{}, book)

// Get the first doc of a collection using a filter
_ = coll.First(bson.M{"pages":400}, book)
```

Update a document
```go
// Find your book
book := findMyFavoriteBook()

// and update it
book.Name = "Moulin Rouge!"
err := mgm.Coll(book).Update(book)
```

Delete a document
```go
// Just find and delete your document
err := mgm.Coll(book).Delete(book)
```

Find and decode a result:
```go
result := []Book{}

err := mgm.Coll(&Book{}).SimpleFind(&result, bson.M{"pages": bson.M{operator.Gt: 24}})
```

### A Model's Default Fields
Each model by default (by using `DefaultModel` struct) has
the following fields: 
- `_id` : The document ID.

- `created_at`: The creation date of a doc. When saving a new doc, this is automatically populated by the `Creating` hook.
- `updated_at`: The last updated date of a doc. When saving a doc, this is automatically populated by the `Saving` hook.

You can even implement your own default model to customize its fields.

### A Model's Hooks

Each model has the following hooks:
- `Creating`: Called when creating a new model.
Signature : `Creating(context.Context) error`

- `Created`: Called after a new model is created.
Signature : `Created(context.Context) error`

- `Updating`: Called when updating model.
Signature : `Updating(context.Context) error`

- `Updated` : Called after a model is updated.
Signature : `Updated(ctx context.Context, result *mongo.UpdateResult) error`

- `Saving`: Called when creating or updating a model.
Signature : `Saving(context.Context) error`

- `Saved`: Called after a model is created or updated.
Signature: `Saved(context.Context) error`

- `Deleting`: Called when deleting a model.
Signature: `Deleting(context.Context) error`

- `Deleted`: Called after a model is deleted.
Signature: `Deleted(ctx context.Context, result *mongo.DeleteResult) error`

**Notes about hooks**: 
- Each model by default uses the `Creating` and `Saving` hooks, so if you want to define those hooks yourself, remember to invoke the `DefaultModel` hooks from your own hooks.
- Collection methods that call these hooks:
	- `Create` & `CreateWithCtx`
	- `Update` & `UpdateWithCtx`
	- `Delete` & `DeleteWithCtx`

Example:
```go
func (model *Book) Creating(ctx context.Context) error {
 // Call the DefaultModel Creating hook
 if err := model.DefaultModel.Creating(ctx); err!=nil {
 return err
 }

 // We can validate the fields of a model and return an error to prevent a document's insertion.
 if model.Pages < 1 {
 return errors.New("book must have at least one page")
 }

 return nil
}
```
### Configuration
The `mgm` default configuration has a context timeout:
```go
func init() {
 _ = mgm.SetDefaultConfig(&mgm.Config{CtxTimeout:12 * time.Second}, "mgm_lab", options.Client().ApplyURI("mongodb://root:12345@localhost:27017"))
}

// To get the context, just call the Ctx() method, assign it to a variable
ctx := mgm.Ctx()

// and use it
coll := mgm.Coll(&Book{})
coll.FindOne(ctx, bson.M{})

// Or invoke Ctx() and use it directly
coll.FindOne(mgm.Ctx(), bson.M{})
``` 


### Collections
Get a model's collection:
```go
coll := mgm.Coll(&Book{})

// Do something with the collection
```

`mgm` automatically detects the name of a model's collection:
```go
book := Book{}

// Print your model's collection name.
collName := mgm.CollName(&book)
fmt.Println(collName) // output: books
```

You can also set a custom collection name for your model by implementing the `CollectionNameGetter` interface:
```go
func (model *Book) CollectionName() string {
 return "my_books"
}

// mgm returns the "my_books" collection
coll := mgm.Coll(&Book{})
```

Get a collection by its name (without needing to define a model for it):
```go
coll := mgm.CollectionByName("my_coll")
 
// Do Aggregation, etc. with the collection
```

Customize the model db by implementing the `CollectionGetter`
interface:
```go
func (model *Book) Collection() *mgm.Collection {
 // Get default connection client
 _, client, _, err := mgm.DefaultConfigs()

 if err != nil {
 panic(err)
 }

 db := client.Database("another_db")
 return mgm.NewCollection(db, "my_collection")
}
```

Or return a model's collection from another connection:

```go
func (model *Book) Collection() *mgm.Collection {
 // Create new client
 client, err := mgm.NewClient(options.Client().ApplyURI("mongodb://root:12345@localhost:27017"))

 if err != nil {
 panic(err)
 }

 // Get the model's db
 db := client.Database("my_second_db")

 // return the model's custom collection
 return mgm.NewCollection(db, "my_collection")
}
```
### Aggregation
While we can use Mongo Go Driver Aggregate features, `mgm` also 
provides simpler methods to perform aggregations:

Run an aggregation and decode the result:
```go
authorCollName := mgm.Coll(&Author{}).Name()
result := []Book{}

// Lookup with just a single line of code
_ := mgm.Coll(&Book{}).SimpleAggregate(&result, builder.Lookup(authorCollName, "auth_id", "_id", "author"))

// Multi stage (mix of mgm builders and raw stages)
_ := mgm.Coll(&Book{}).SimpleAggregate(&result,
		builder.Lookup(authorCollName, "auth_id", "_id", "author"),
		M{operator.Project: M{"pages": 0}},
)

// Do something with result...
```

Do aggregations using the mongo Aggregation method:
```go
import (
 "github.com/kamva/mgm/v3"
 "github.com/kamva/mgm/v3/builder"
 "github.com/kamva/mgm/v3/field"
 . "go.mongodb.org/mongo-driver/bson"
 "go.mongodb.org/mongo-driver/bson/primitive"
)

// The Author model collection
authorColl := mgm.Coll(&Author{})

cur, err := mgm.Coll(&Book{}).Aggregate(mgm.Ctx(), A{
 // The S function accepts operators as parameters and returns a bson.M type.
 builder.S(builder.Lookup(authorColl.Name(), "author_id", field.Id, "author")),
})
```

A more complex example and mixes with mongo raw pipelines:
```go
import (
 "github.com/kamva/mgm/v3"
 "github.com/kamva/mgm/v3/builder"
 "github.com/kamva/mgm/v3/field"
 "github.com/kamva/mgm/v3/operator"
 . "go.mongodb.org/mongo-driver/bson"
 "go.mongodb.org/mongo-driver/bson/primitive"
)

// Author model collection
authorColl := mgm.Coll(&Author{})

_, err := mgm.Coll(&Book{}).Aggregate(mgm.Ctx(), A{
 // S function get operators and return bson.M type.
 builder.S(builder.Lookup(authorColl.Name(), "author_id", field.Id, "author")),
 builder.S(builder.Group("pages", M{"books": M{operator.Push: M{"name": "$name", "author": "$author"}}})),
 M{operator.Unwind: "$books"},
})

if err != nil {
 panic(err)
}
```

### Transactions

- To run a transaction on the default connection use the `mgm.Transaction()` function, e.g:
```go
d := &Doc{Name: "Mehran", Age: 10}

err := mgm.Transaction(func(session mongo.Session, sc mongo.SessionContext) error {

 // do not forget to pass the session's context to the collection methods.
	err := mgm.Coll(d).CreateWithCtx(sc, d)

	if err != nil {
		return err
	}

	return session.CommitTransaction(sc)
})
```

- To run a transaction with your own context, use the `mgm.TransactionWithCtx()` method.
- To run a transaction on another connection, use the `mgm.TransactionWithClient()` method.

-----------------
## Other Mongo Go Models Packages

**We implemented these packages to simplify queries and aggregations in mongo**

`builder`: simplify mongo queries and aggregations. 

`operator` : contains mongo operators as predefined variables. 
(e.g `Eq = "$eq"` , `Gt = "$gt"`) 

`field` : contains mongo fields used in aggregations and ... as predefined variable.
(e.g `LocalField = "localField"`, `ForeignField = "foreignField"`) 
 
Example:
 ```go
import (
 "github.com/kamva/mgm/v3"
 f "github.com/kamva/mgm/v3/field"
 o "github.com/kamva/mgm/v3/operator"
 "go.mongodb.org/mongo-driver/bson"
)

// Instead of hard-coding mongo operators and fields
_, _ = mgm.Coll(&Book{}).Aggregate(mgm.Ctx(), bson.A{
 bson.M{"$count": ""},
 bson.M{"$project": bson.M{"_id": 0}},
})

// Use the predefined operators and pipeline fields.
_, _ = mgm.Coll(&Book{}).Aggregate(mgm.Ctx(), bson.A{
 bson.M{o.Count: ""},
 bson.M{o.Project: bson.M{f.Id: 0}},
})
 ```
 
## Bugs / Feature request
New features can be requested and bugs can be reported on [Github issue tracker](https://github.com/Kamva/mgm/issues).

## Communicate With Us

* Create new topic at [mongo-go-models Google Group](https://groups.google.com/forum/#!forum/mongo-go-models) 
* Ask your question or request new feature by creating an issue at [Github issue tracker](https://github.com/Kamva/mgm/issues) 

## Contributing 

[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/kamva/mgm)
[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FKamva%2Fmgm.svg?type=shield)](https://app.fossa.com/projects/git%2Bgithub.com%2FKamva%2Fmgm?ref=badge_shield)

1. Fork the repository
1. Clone your fork (`git clone https://github.com/<your_username>/mgm && cd mgm`)
1. Create your feature branch (`git checkout -b my-new-feature`)
1. Make changes and add them (`git add .`)
1. Commit your changes (`git commit -m 'Add some feature'`)
1. Push to the branch (`git push origin my-new-feature`)
1. Create new pull request

## License

Mongo Go Models is released under the [Apache License](https://github.com/Kamva/mgm/blob/master/LICENSE)


[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FKamva%2Fmgm.svg?type=large)](https://app.fossa.com/projects/git%2Bgithub.com%2FKamva%2Fmgm?ref=badge_large)

Official MongoDB driver for the Go language

<img src="etc/assets/mongo-gopher.png" width="250">

 <a href="https://goreportcard.com/report/go.mongodb.org/mongo-driver/v2"><img src="https://goreportcard.com/badge/go.mongodb.org/mongo-driver/v2"></a>
 <a href="https://pkg.go.dev/go.mongodb.org/mongo-driver/v2/mongo"><img src="etc/assets/godev-mongo-blue.svg" alt="docs"></a>
 <a href="https://pkg.go.dev/go.mongodb.org/mongo-driver/v2/bson"><img src="etc/assets/godev-bson-blue.svg" alt="docs"></a>
 <a href="https://www.mongodb.com/docs/drivers/go/current/"><img src="etc/assets/docs-mongodb-green.svg"></a>
 <a href="https://securityscorecards.dev/viewer/?uri=github.com/mongodb/mongo-go-driver">
 <img src="https://api.securityscorecards.dev/projects/github.com/mongodb/mongo-go-driver/badge" alt="OpenSSF Scorecard" />
 </a>


# MongoDB Go Driver

The MongoDB supported driver for Go.

See the following resources to learn more about upgrading from version 1.x to 2.0.:

- [v2.0 Migration Guide](docs/migration-2.0.md)
- [v2.0 What's New](https://www.mongodb.com/docs/drivers/go/upcoming/whats-new/#what-s-new-in-2.0)

The MongoDB Go driver follows [semantic versioning](https://semver.org/) for its releases.

## Requirements

- Go 1.19 or higher. We aim to support the latest versions of Go.
- Go 1.25 or higher is required to run the driver test suite.
- MongoDB 4.2 and higher.

## Installation

The recommended way to get started using the MongoDB Go driver is by using Go modules to install the dependency in
your project. This can be done either by importing packages from `go.mongodb.org/mongo-driver` and having the build
step install the dependency or by explicitly running

```bash
go get go.mongodb.org/mongo-driver/v2/mongo
```

When using a version of Go that does not support modules, the driver can be installed using `dep` by running

```bash
dep ensure -add "go.mongodb.org/mongo-driver/v2/mongo"
```

## Usage

To get started with the driver, import the `mongo` package and create a `mongo.Client` with the `Connect` function:

```go
import (
 "context"
 "time"

 "go.mongodb.org/mongo-driver/v2/mongo"
 "go.mongodb.org/mongo-driver/v2/mongo/options"
 "go.mongodb.org/mongo-driver/v2/mongo/readpref"
)

client, _ := mongo.Connect(options.Client().ApplyURI("mongodb://localhost:27017"))
```

Make sure to defer a call to `Disconnect` after instantiating your client:

```go
defer func() {
 if err := client.Disconnect(ctx); err != nil {
 panic(err)
 }
}()
```

For more advanced configuration and authentication, see the [documentation for mongo.Connect](https://pkg.go.dev/go.mongodb.org/mongo-driver/v2/mongo#Connect).

Calling `Connect` does not block for server discovery. If you wish to know if a MongoDB server has been found and connected to,
use the `Ping` method:

```go
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()

_ = client.Ping(ctx, readpref.Primary())
```

To insert a document into a collection, first retrieve a `Database` and then `Collection` instance from the `Client`:

```go
collection := client.Database("testing").Collection("numbers")
```

The `Collection` instance can then be used to insert documents:

```go
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

res, _ := collection.InsertOne(ctx, bson.D{{"name", "pi"}, {"value", 3.14159}})
id := res.InsertedID
```

To use `bson.D`, you will need to add `"go.mongodb.org/mongo-driver/v2/bson"` to your imports.

Your import statement should now look like this:

```go
import (
 "context"
 "log"
 "time"

 "go.mongodb.org/mongo-driver/v2/bson"
 "go.mongodb.org/mongo-driver/v2/mongo"
 "go.mongodb.org/mongo-driver/v2/mongo/options"
 "go.mongodb.org/mongo-driver/v2/mongo/readpref"
)
```

Several query methods return a cursor, which can be used like this:

```go
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()

cur, err := collection.Find(ctx, bson.D{})
if err != nil {
 log.Fatal(err)
}

defer cur.Close(ctx)
for cur.Next(ctx) {
 var result bson.D
 if err := cur.Decode(&result); err != nil {
 log.Fatal(err)
 }

 // do something with result....
}

if err := cur.Err(); err != nil {
 log.Fatal(err)
}
```

For methods that return a single item, a `SingleResult` instance is returned:

```go
var result struct {
 Value float64
}

filter := bson.D{{"name", "pi"}}
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

err := collection.FindOne(ctx, filter).Decode(&result)
if errors.Is(err, mongo.ErrNoDocuments) {
 // Do something when no record was found
} else if err != nil {
 log.Fatal(err)
}

// Do something with result...
```

Additional examples and documentation can be found under the examples directory and [on the MongoDB Documentation website](https://www.mongodb.com/docs/drivers/go/current/).

### Network Compression

Network compression will reduce bandwidth requirements between MongoDB and the application.

The Go Driver supports the following compression algorithms:

1. [Snappy](https://google.github.io/snappy/) (`snappy`): available in MongoDB 3.4 and later.
1. [Zlib](https://zlib.net/) (`zlib`): available in MongoDB 3.6 and later.
1. [Zstandard](https://github.com/facebook/zstd/) (`zstd`): available in MongoDB 4.2 and later.

#### Specify Compression Algorithms

Compression can be enabled using the `compressors` parameter on the connection string or by using [`ClientOptions.SetCompressors`](https://pkg.go.dev/go.mongodb.org/mongo-driver/mongo/options#ClientOptions.SetCompressors):

```go
opts := options.Client().ApplyURI("mongodb://localhost:27017/?compressors=snappy,zlib,zstd")
client, _ := mongo.Connect(opts)
```

```go
opts := options.Client().SetCompressors([]string{"snappy", "zlib", "zstd"})
client, _ := mongo.Connect(opts)
```

If compressors are set, the Go Driver negotiates with the server to select the first common compressor. For server configuration and defaults, refer to [`networkMessageCompressors`](https://www.mongodb.com/docs/manual/reference/program/mongod/#std-option-mongod.--networkMessageCompressors).

Messages compress when both parties enable network compression; otherwise, messages remain uncompressed

## Support / Feedback

For issues with, questions about, or feedback for the Go Driver, please look into our [support channels](https://www.mongodb.com/docs/manual/support/), including [StackOverflow](https://stackoverflow.com/questions/tagged/mongodb%20go?sort=Newest).

New features and bugs can be reported on the [GODRIVER Jira project](https://jira.mongodb.org/browse/GODRIVER).

## Contribution

Check out the [GODRIVER Jira project](https://jira.mongodb.org/browse/GODRIVER) for tickets that need completing. See our [contribution guidelines](docs/CONTRIBUTING.md) for details.

## Continuous Integration

Commits to master are run automatically on [evergreen](https://evergreen.mongodb.com/waterfall/mongo-go-driver).

## Frequently Encountered Issues

See our [common issues](docs/common-issues.md) documentation for troubleshooting frequently encountered issues.

## Thanks and Acknowledgement

- The Go Gopher artwork by [@ashleymcnamara](https://github.com/ashleymcnamara)
- The original Go Gopher was designed by [Renee French](http://reneefrench.blogspot.com/)

## License

The MongoDB Go Driver is licensed under the [Apache License](LICENSE).

mongo-go-driver

# Aerospike Go Client v8

[![Aerospike Client Go](https://goreportcard.com/badge/github.com/aerospike/aerospike-client-go/v8)](https://goreportcard.com/report/github.com/aerospike/aerospike-client-go/v8)
[![Godoc](https://godoc.org/github.com/aerospike/aerospike-client-go/v8?status.svg)](https://pkg.go.dev/github.com/aerospike/aerospike-client-go/v8)
[![Tests](https://github.com/aerospike/aerospike-client-go/actions/workflows/build.yml/badge.svg?branch=v8&event=push)](github.com/aerospike/aerospike-client-go/actions)

An Aerospike library for Go.

This library is compatible with Go 1.23+ and supports the following operating systems: Linux, Mac OS X (Windows builds are possible, but untested).

Up-to-date documentation is available in the [![Godoc](https://godoc.org/github.com/aerospike/aerospike-client-go/v8?status.svg)](https://pkg.go.dev/github.com/aerospike/aerospike-client-go/v8).

You can refer to the test files for idiomatic use cases.

Please refer to [`CHANGELOG.md`](CHANGELOG.md) for release notes, or if you encounter breaking changes.

- [Aerospike Go Client v8](#aerospike-go-client-v8)
 - [Usage](#usage)
 - [Prerequisites](#prerequisites)
 - [Installation](#installation)
 - [Some Tips](#some-tips)
 - [Performance Tweaking](#performance-tweaking)
 - [Tests](#tests)
 - [Examples](#examples)
 - [Tools](#tools)
 - [Benchmarks](#benchmarks)
 - [API Documentation](#api-documentation)
 - [Google App Engine](#google-app-engine)
 - [Reflection, and Object API](#reflection-and-object-api)
 - [License](#license)

## Usage

The following is a very simple example of CRUD operations in an Aerospike database.

```go
package main

import (
 "fmt"

 aero "github.com/aerospike/aerospike-client-go/v8"
)

// This is only for this example.
// Please handle errors properly.
func panicOnError(err error) {
 if err != nil {
 panic(err)
 }
}

func main() {
 // define a client to connect to
 client, err := aero.NewClient("127.0.0.1", 3000)
 panicOnError(err)

 key, err := aero.NewKey("test", "aerospike", "key")
 panicOnError(err)

 // define some bins with data
 bins := aero.BinMap{
 "bin1": 42,
 "bin2": "An elephant is a mouse with an operating system",
 "bin3": []any{"Go", 2009},
 }

 // write the bins
 err = client.Put(nil, key, bins)
 panicOnError(err)

 // read it back!
 rec, err := client.Get(nil, key)
 panicOnError(err)

 // delete the key, and check if key exists
 existed, err := client.Delete(nil, key)
 panicOnError(err)
 fmt.Printf("Record existed before delete? %v\n", existed)
}
```

More examples illustrating the use of the API are located in the
[`examples`](examples) directory.

Details about the API are available in the [`docs`](docs) directory.

<a name="Prerequisites"></a>
## Prerequisites

[Go](http://golang.org) version v1.23+ is required.

To install the latest stable version of Go, visit
[http://golang.org/dl/](http://golang.org/dl/)

Aerospike Go client implements the wire protocol, and does not depend on the C client.
It is goroutine friendly, and works asynchronously.

Supported operating systems:

- Major Linux distributions (Ubuntu, Debian, Red Hat)
- Mac OS X
- Windows (untested)

<a name="Installation"></a>
## Installation

1. Install Go 1.21+ and setup your environment as [Documented](http://golang.org/doc/code.html#GOPATH) here.
2. Get the client in your ```GOPATH``` : ```go get github.com/aerospike/aerospike-client-go/v8```
 - To update the client library: ```go get -u github.com/aerospike/aerospike-client-go/v8```

### Some Tips

- To run a go program directly: ```go run <filename.go>```
- to build: ```go build -o <output> <filename.go>```
- example: ```go build -tags as_performance -o benchmark tools/benchmark/benchmark.go```

<a name="Performance"></a>
## Performance Tweaking

We are bending all efforts to improve the client's performance. In our reference benchmarks, Go client performs almost as good as the C client.

To read about performance variables, please refer to [`docs/performance.md`](docs/performance.md)

<a name="Tests"></a>
## Tests

This library is packaged with a number of tests. Tests require Ginkgo and Gomega library.

Before running the tests, you need to update the dependencies:

 $ go get .

To run all the test cases with race detection:

 $ ginkgo -r -race


<a name="examples"></a>
## Examples

A variety of example applications are provided in the [`examples`](examples) directory.

<a name="tools"></a>
### Tools

A variety of clones of original tools are provided in the [`tools`](tools) directory.
They show how to use more advanced features of the library to re-implement the same functionality in a more concise way.

<a name="benchmarks"></a>
## Benchmarks

Benchmark utility is provided in the [`tools/benchmark`](tools/benchmark) directory.
See the [`tools/benchmark/README.md`](tools/benchmark/README.md) for details.

<a name="api-documentation"></a>
## API Documentation

A simple API documentation is available in the [`docs`](docs/README.md) directory. The latest up-to-date docs can be found in [![Godoc](https://godoc.org/github.com/aerospike/aerospike-client-go?status.svg)](https://pkg.go.dev/github.com/aerospike/aerospike-client-go/v8).

<a name="google-app-engine"></a>
## Google App Engine

To build the library for App Engine, build it with the build tag `app_engine`. Aggregation functionality is not available in this build.


<a name="reflection-and-object-api"></a>
## Reflection, and Object API

To make the library both flexible and fast, we had to integrate the reflection API (methods with `[Get/Put/...]Object` names) tightly in the library. In case you wanted to avoid mixing those API in your app inadvertently, you can use the build tag `as_performance` to remove those APIs from the build.


<a name="license"></a>
## License

The Aerospike Go Client is made available under the terms of the Apache License, Version 2, as stated in the file `LICENSE`.

Individual files may be made available under their own specific license,
all compatible with Apache License, Version 2. Please see individual files for details.

aerospike-client-go

# Arangolite [![Build Status](https://travis-ci.org/solher/arangolite.svg?branch=master)](https://travis-ci.org/solher/arangolite) [![Coverage Status](https://coveralls.io/repos/solher/arangolite/badge.svg?branch=master&service=github)](https://coveralls.io/github/solher/arangolite?branch=master) [![Code Climate](https://codeclimate.com/github/solher/arangolite/badges/gpa.svg)](https://codeclimate.com/github/solher/arangolite) [![GoDoc](https://godoc.org/github.com/solher/arangolite?status.svg)](https://godoc.org/github.com/solher/arangolite)

Arangolite is a lightweight ArangoDB driver for Go.

It focuses on pure AQL querying. See [AranGO](https://github.com/diegogub/aranGO) for a more ORM-like experience.

## IMPORTANT: Looking for maintainers

I don't have as much time as I used to have and I am not as a frequent user of ArangoDB as I used to be. This project would definitely benefit from some new maintainers. Any PR is greatly appreciated.

## Installation

To install Arangolite:

    go get -u github.com/solher/arangolite/v2

## Basic Usage

```go
package main

import (
  "context"
  "fmt"
  "log"

  "github.com/solher/arangolite/v2"
  "github.com/solher/arangolite/v2/requests"
)

type Node struct {
  arangolite.Document
}

func main() {
  ctx := context.Background()

  // We declare the database definition.
  db := arangolite.NewDatabase(
    arangolite.OptEndpoint("http://localhost:8529"),
    arangolite.OptBasicAuth("root", "rootPassword"),
    arangolite.OptDatabaseName("_system"),
  )

  // The Connect method does two things:
  // - Initializes the connection if needed (JWT authentication).
  // - Checks the database connectivity.
  if err := db.Connect(ctx); err != nil {
    log.Fatal(err)
  }

  // We create a new database.
  err := db.Run(ctx, nil, &requests.CreateDatabase{
    Name: "testDB",
    Users: []map[string]interface{}{
      {"username": "root", "passwd": "rootPassword"},
      {"username": "user", "passwd": "password"},
    },
  })
  if err != nil {
    log.Fatal(err)
  }

  // We sign in as the new created user on the new database.
  // We could eventually rerun a "db.Connect()" to confirm the connectivity.
  db.Options(
    arangolite.OptBasicAuth("user", "password"),
    arangolite.OptDatabaseName("testDB"),
  )

  // We create a new "nodes" collection.
  if err := db.Run(ctx, nil, &requests.CreateCollection{Name: "nodes"}); err != nil {
    log.Fatal(err)
  }

  // We declare a new AQL query with options and bind parameters.
  key := "48765564346"
  r := requests.NewAQL(`
    FOR n
    IN nodes
    FILTER n._key == @key
    RETURN n
  `, key).
    Bind("key", key).
    Cache(true).
    BatchSize(500) // The caching feature is unavailable prior to ArangoDB 2.7

  // The Run method returns all the query results of every pages
  // available in the cursor and unmarshal it into the given struct.
  // Cancelling the context cancels every running request. 
  nodes := []Node{}
  if err := db.Run(ctx, &nodes, r); err != nil {
    log.Fatal(err)
  }

  // The Send method gives more control to the user and doesn't follow an eventual cursor.
  // It returns a raw result object.
  result, err := db.Send(ctx, r)
  if err != nil {
    log.Fatal(err)
  }
  nodes = []Node{}
  result.UnmarshalResult(&nodes)

  for result.HasMore() {
    result, err = db.Send(ctx, &requests.FollowCursor{Cursor: result.Cursor()})
    if err != nil {
      log.Fatal(err)
    }
    tmp := []Node{}
    result.UnmarshalResult(&tmp)

    nodes = append(nodes, tmp...)
  }

  fmt.Println(nodes)
}
```

## Document and Edge

```go
// Document represents a basic ArangoDB document
type Document struct {
  // The document handle. Format: ':collection/:key'
  ID string `json:"_id,omitempty"`
  // The document's revision token. Changes at each update.
  Rev string `json:"_rev,omitempty"`
  // The document's unique key.
  Key string `json:"_key,omitempty"`
}

// Edge represents a basic ArangoDB edge
type Edge struct {
  Document
  // Reference to another document. Format: ':collection/:key'
  From string `json:"_from,omitempty"`
  // Reference to another document. Format: ':collection/:key'
  To string `json:"_to,omitempty"`
}
```

## Transactions
### Overview

Arangolite provides an abstraction layer to the Javascript ArangoDB transactions.

The only limitation is that no Javascript processing can be manually added inside the transaction. The queries can be connected using the Go templating conventions.

### Usage

```go
t := requests.NewTransaction([]string{"nodes"}, nil).
  AddAQL("nodes", `
    FOR n
    IN nodes
    RETURN n
`).
  AddAQL("ids", `
    FOR n
    IN {{.nodes}}
    RETURN n._id
`).
  Return("ids")

ids := []string{}
if err := db.Run(ctx, ids, t); err != nil {
  log.Fatal(err)
}
```

## Graphs
### Overview

AQL may be used for querying graph data. But to manage graphs, Arangolite offers a few specific requests:

- `CreateGraph` to create a graph.
- `ListGraphs` to list available graphs.
- `GetGraph` to get an existing graph.
- `DropGraph` to delete a graph.

### Usage

```go
// Check graph existence.
if err := db.Run(ctx, nil, &requests.GetGraph{Name: "graphName"}); err != nil {
  switch {
  case arangolite.IsErrNotFound(err):
    // If graph does not exist, create a new one.
    edgeDefinitions := []requests.EdgeDefinition{
      {
        Collection: "edgeCollectionName",
        From:       []string{"firstCollectionName"},
        To:         []string{"secondCollectionName"},
      },
    }
    db.Run(ctx, nil, &requests.CreateGraph{Name: "graphName", EdgeDefinitions: edgeDefinitions})
  default:
    log.Fatal(err)
  }
}

// List existing graphs.
list := &requests.GraphList{}
db.Run(ctx, list, &requests.ListGraphs{})
fmt.Printf("Graph list: %v\n", list)

// Destroy the graph we just created, and the related collections.
db.Run(ctx, nil, &requests.DropGraph{Name: "graphName", DropCollections: true})
```

## Error Handling

Errors can be handled using the provided basic testers:

```go
// IsErrInvalidRequest returns true when the database returns a 400.
func IsErrInvalidRequest(err error) bool {
  return HasStatusCode(err, 400)
}

// IsErrUnauthorized returns true when the database returns a 401.
func IsErrUnauthorized(err error) bool {
  return HasStatusCode(err, 401)
}

// IsErrForbidden returns true when the database returns a 403.
func IsErrForbidden(err error) bool {
  return HasStatusCode(err, 403)
}

// IsErrUnique returns true when the error num is a 1210 - ERROR_ARANGO_UNIQUE_CONSTRAINT_VIOLATED.
func IsErrUnique(err error) bool {
  return HasErrorNum(err, 1210)
}

// IsErrNotFound returns true when the database returns a 404 or when the error num is:
// 1202 - ERROR_ARANGO_DOCUMENT_NOT_FOUND
// 1203 - ERROR_ARANGO_COLLECTION_NOT_FOUND
func IsErrNotFound(err error) bool {
  return HasStatusCode(err, 404) || HasErrorNum(err, 1202, 1203)
}

```

Or manually via the `HasStatusCode` and `HasErrorNum` methods.

## Contributing

Currently, very few methods of the ArangoDB HTTP API are implemented in Arangolite.
Fortunately, it is really easy to add your own by implementing the `Runnable` interface.
You can then use the regular `Run` and `Send` methods.

```go
// Runnable defines requests runnable by the Run and Send methods.
// A Runnable library is located in the 'requests' package.
type Runnable interface {
  // The body of the request.
  Generate() []byte
  // The path where to send the request.
  Path() string
  // The HTTP method to use.
  Method() string
}
```

**Please pull request when you implement some new features so everybody can use it.**

## License

MIT


arangolite

Datastore Connectivity for Aerospike for go

# Datastore Connectivity for Aerospike (asc)


[![Datastore Connectivity library for Aerospike in Go.](https://goreportcard.com/badge/github.com/viant/asc)](https://goreportcard.com/report/github.com/viant/asc)
[![GoDoc](https://godoc.org/github.com/viant/asc?status.svg)](https://godoc.org/github.com/viant/asc)

This library is compatible with Go 1.11+


Please refer to [`CHANGELOG.md`](CHANGELOG.md) if you encounter breaking changes.

- [Usage](#Usage)
- [License](#License)
- [Credits and Acknowledgements](#Credits-and-Acknowledgements)


#### Configuration parameters

###### aerospike client/policy config params
 - timeoutMs
 - connectionTimeout
 - serverSocketTimeout
 - scanPct
 - host
 - port
 - namespace
 - sleepBetweenRetries
 - batchSize
 
 
###### keyColumn, keyColumnName
 
Defines name of column used as record key ('id' by default)

It can be specified per table i.e

 events.keyColumn = code
 

###### excludedColumns

List of columns to be excluded from record (i.e: id - in case we need it only as record key)


###### dateFormat

ISO date format used to time.Time conversion


###### optimizeLargeScan

Experimental feature that first scan all keys and write then to disk
and then separate go routines scan data using the dumped keys

You can only specify _scanBaseDirectory_


## Usage:


The following is a very simple example of CRUD operations with dsc

config.yaml
```yaml
driverName: aerospike
parameters:
 namespace: test
 host: 127.0.0.1
 dateFormat: yyyy-MM-dd hh:mm:ss
```

```go
package main

import (
 _ "github.com/aerospike/aerospike-client-go"
 _ "github.com/viant/asc"
 "github.com/viant/dsc"
 "log"
)


type Interest struct {
	Id int	`autoincrement:"true"`
	Name string
	ExpiryTimeInSecond int `column:"expiry"`
	Category string
}


func main() {


	config, err := dsc.NewConfigFromURL("config.yaml")
	if err != nil {
		log.Fatal(err)
	}
	factory := dsc.NewManagerFactory()
	manager, err := factory.Create(config)
	if err != nil {
		log.Fatal(err)
	}



 	// manager := factory.CreateFromURL("file:///etc/myapp/datastore.json")
 
 interest := &Interest{}
 
 success, err:= manager.ReadSingle(interest, "SELECT id, name, expiry, category FROM interests WHERE id = ?", []interface{}{id},nil)
	if err != nil {
 panic(err.Error())
	}

 var intersts = make([]*Interest, 0)
 err = manager.ReadAll(&intersts, "SELECT id, name, expiry, category FROM interests", nil ,nil)
 if err != nil {
 panic(err.Error())
 }

 
 intersts = []*Interest {
 Interest{Name:"Abc", ExpiryTimeInSecond:3600, Category:"xyz"},
 Interest{Name:"Def", ExpiryTimeInSecond:3600, Category:"xyz"},
 Interest{Id:"20, Name:"Ghi", ExpiryTimeInSecond:3600, Category:"xyz"},
 }


	_, _, err = manager.PersistAll(&intersts, "intersts", nil)
	if err != nil {
 panic(err.Error())
 	}
 	fmt.Printf("Inserted %v, updated: %v\n", inserted, updated)
 
 deleted, err := manager.DeleteAll(&intersts, "intersts", nil)
 if err != nil {
 panic(err.Error())
 	}
 	fmt.Printf("Inserted %v, updated: %v\n", deleted)


 	
 	var records = []map[string]interface{}{}
 	 err = manager.ReadAll(&records, "SELECT id, name, expiry, category FROM interests", nil ,nil)
 if err != nil {
 panic(err.Error())
 }
}
```


### Query level UDF support

- **ARRAY** converts supplied source column into collection of map entry defined as (key, value) 

```sql
SELECT 
 id, 
 username, 
ARRAY(city_visited) AS visited
FROM users
```


- **JSON** convert supplied source column to JSON
```sql
SELECT 
 id, 
 username, 
JSON(city_visited) AS visited
FROM users
```

## GoCover

[![GoCover](https://gocover.io/github.com/viant/asc)](https://gocover.io/github.com/viant/asc)


<a name="License"></a>
## License

The source code is made available under the terms of the Apache License, Version 2, as stated in the file `LICENSE`.

Individual files may be made available under their own specific license,
all compatible with Apache License, Version 2. Please see individual files for details.


<a name="Credits-and-Acknowledgements"></a>

## Credits and Acknowledgements

**Library Author:** Adrian Witas

**Contributors:**

# goforestdb

Go bindings for ForestDB

## Building

1. Obtain and build forestdb: https://github.com/couchbaselabs/forestdb (run `make install` to install the library)
1. Install header files to system location
 1. On Ubuntu 14.04: `cd <forestdb_project_dir> && mkdir /usr/local/include/libforestdb && cp include/libforestdb/* /usr/local/include/libforestdb`
1. `go get -u -v -t github.com/couchbase/goforestdb`

## Documentation

See [godocs](http://godoc.org/github.com/couchbase/goforestdb)

## Sample usage (without proper error handling):

	// Open a database
	db, _ := Open("test", nil)

	// Close it properly when we're done
	defer db.Close()

	// Store the document
	doc, _ := NewDoc([]byte("key"), nil, []byte("value"))
	defer doc.Close()
	db.Set(doc)

	// Lookup the document
	doc2, _ := NewDoc([]byte("key"), nil, nil)
	defer doc2.Close()
	db.Get(doc2)

	// Delete the document
	doc3, _ := NewDoc([]byte("key"), nil, nil)
	defer doc3.Close()
	db.Delete(doc3)

forestdb

A Go Mongo library based on the official driver, featuring streamlined document operations, generic binding of structs to collections, built-in CRUD, aggregation, automated field updates, struct validation, hooks, and plugin-based programming

<img src="https://raw.githubusercontent.com/chenmingyong0423/go-mongox-doc/main/docs/public/go-mongox-logo.png" width="200" height="200" akt="go mongox"></img>


[![GitHub Repo stars](https://img.shields.io/github/stars/chenmingyong0423/go-mongox)](https://github.com/chenmingyong0423/go-mongox/stargazers)
[![GitHub issues](https://img.shields.io/github/issues/chenmingyong0423/go-mongox)](https://github.com/chenmingyong0423/go-mongox/issues)
[![GitHub License](https://img.shields.io/github/license/chenmingyong0423/go-mongox)](https://github.com/chenmingyong0423/go-mongox/blob/main/LICENSE)
[![GitHub release (with filter)](https://img.shields.io/github/v/release/chenmingyong0423/go-mongox)](https://github.com/chenmingyong0423/go-mongox)
[![codecov](https://codecov.io/gh/chenmingyong0423/go-mongox/graph/badge.svg?token=H3CROTTDZ1)](https://codecov.io/gh/chenmingyong0423/go-mongox)
[![Go Report Card](https://goreportcard.com/badge/github.com/chenmingyong0423/go-mongox)](https://goreportcard.com/report/github.com/chenmingyong0423/go-mongox)
[![go.dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/github.com/chenmingyong0423/go-mongox)
[![All Contributors](https://img.shields.io/badge/all_contributors-4-orange.svg?style=flat-square)](#contributors-)

English | [中文简体](./README-zh_CN.md)

# go mongox
`go mongox` is a generic-based library that extends the official MongoDB framework. By using generics, it binds structs to MongoDB collections, aiming to provide type safety and simplified data operations. `go mongox` also introduces method chaining for smoother document operations and offers a rich set of BSON builders and built-in functions to simplify the construction of BSON data. Additionally, it supports plugin-based programming and provides various built-in hook functions, offering flexibility for custom logic before and after database operations, thus enhancing the scalability and maintainability of applications.

# Feature Highlights
- Generic MongoDB Collections
- CRUD operations for documents
- Aggregation operations
- Built-in basic `Model` struct with automatic updates to default `field` values
- BSON data construction support
- Built-in Hooks
- Plugin-based programming support

# Install
```go
go get github.com/chenmingyong0423/go-mongox/v2
```

# Getting Started
- `go mongox` Guides: [https://go-mongox.dev](https://go-mongox.dev/en)

# Contributing
[With your participation, go-mongox will become even more powerful!](https://go-mongox.dev/en/contribute.html)

# Contributors
[Thank you](https://github.com/chenmingyong0423/go-mongox/graphs/contributors) for contributing to the `go mongox` framework!

# Community

Join our community to get support, share ideas, and collaborate with others!

[![Join Discord](https://img.shields.io/badge/Discord-Join%20Chat-5865F2?logo=discord&logoColor=white)](https://discord.gg/Cx8CMcRurb)

# Contributors

A heartfelt thank you to all the developers who have contributed to this project! 
[![Contributors](https://contrib.rocks/image?repo=chenmingyong0423/go-mongox)](https://github.com/chenmingyong0423/go-mongox/graphs/contributors)

Your support and efforts make this project.

# Acknowledgements

[![JetBrains logo.](https://resources.jetbrains.com/storage/products/company/brand/logos/jetbrains.svg)](https://jb.gg/OpenSourceSupport)

Thanks to JetBrains for supporting this project through their [Open Source Licenses](https://www.jetbrains.com/community/opensource/) program.

# License
© [Mingyong Chen](https://github.com/chenmingyong0423)，2024-now

This project is licensed under the [Apache License](https://github.com/chenmingyong0423/go-mongox/blob/main/LICENSE).

go-mongox

Golang client for redislabs' ReJSON module using Redigo golang client. Store and manipulate structs as JSON objects in redis with ease

> _Note: Currently, go-ReJSON only support redislabs/rejson with version <=1.0.8. If you are using higher versions, some commands might not work as expected_

# Go-ReJSON - a golang client for ReJSON (a JSON data type for Redis)

Go-ReJSON is a [Go](https://golang.org/) client for [ReJSON](https://github.com/RedisLabsModules/rejson) Redis Module.

[![Go Reference](https://pkg.go.dev/badge/github.com/nitishm/go-rejson.svg)](https://pkg.go.dev/github.com/nitishm/go-rejson/v4)
![test](https://github.com/nitishm/go-rejson/workflows/test/badge.svg)
![code-analysis](https://github.com/nitishm/go-rejson/workflows/code-analysis/badge.svg)
[![codecov](https://coveralls.io/repos/github/nitishm/go-rejson/badge.svg?branch=master)](https://coveralls.io/github/nitishm/go-rejson?branch=master)
[![Go Report Card](https://goreportcard.com/badge/github.com/nitishm/go-rejson)](https://goreportcard.com/report/github.com/nitishm/go-rejson)
[![GitHub release](https://img.shields.io/github/release/nitishm/go-rejson.svg)](https://github.com/nitishm/go-rejson/releases)

> ReJSON is a Redis module that implements ECMA-404 The JSON Data Interchange Standard as a native data type. It allows storing, updating and fetching JSON values from Redis keys (documents).

Primary features of ReJSON Module:

 * Full support of the JSON standard
 * JSONPath-like syntax for selecting element inside documents
 * Documents are stored as binary data in a tree structure, allowing fast access to sub-elements
 * Typed atomic operations for all JSON values types

Each and every feature of ReJSON Module is fully incorporated in the project.

Enjoy ReJSON with the type-safe Redis client, [`Go-Redis/Redis`](https://github.com/go-redis/redis) or use the
print-like Redis-api client [`GoModule/Redigo`](https://github.com/gomodule/redigo). Go-ReJSON supports both the
clients. Use any of the above two client you want, Go-ReJSON helps you out with all its features and functionalities in
a more generic and standard way.

Support for `mediocregopher/radix` and other Redis clients is in our RoadMap. Any contributions to the support for other
clients is hearty welcome.

## Installation

 go get github.com/nitishm/go-rejson/v4

## Example usage

```golang
package main

import (
	"context"
	"encoding/json"
	"flag"
	"fmt"
	"log"

	"github.com/nitishm/go-rejson/v4"
	goredis "github.com/go-redis/redis/v8"
	"github.com/gomodule/redigo/redis"
)

// Name - student name
type Name struct {
	First string `json:"first,omitempty"`
	Middle string `json:"middle,omitempty"`
	Last string `json:"last,omitempty"`
}

// Student - student object
type Student struct {
	Name Name `json:"name,omitempty"`
	Rank int `json:"rank,omitempty"`
}

func Example_JSONSet(rh *rejson.Handler) {

	student := Student{
		Name: Name{
			"Mark",
			"S",
			"Pronto",
		},
		Rank: 1,
	}
	res, err := rh.JSONSet("student", ".", student)
	if err != nil {
		log.Fatalf("Failed to JSONSet")
		return
	}

	if res.(string) == "OK" {
		fmt.Printf("Success: %s\n", res)
	} else {
		fmt.Println("Failed to Set: ")
	}

	studentJSON, err := redis.Bytes(rh.JSONGet("student", "."))
	if err != nil {
		log.Fatalf("Failed to JSONGet")
		return
	}

	readStudent := Student{}
	err = json.Unmarshal(studentJSON, &readStudent)
	if err != nil {
		log.Fatalf("Failed to JSON Unmarshal")
		return
	}

	fmt.Printf("Student read from redis : %#v\n", readStudent)
}

func main() {
	var addr = flag.String("Server", "localhost:6379", "Redis server address")

	rh := rejson.NewReJSONHandler()
	flag.Parse()

	// Redigo Client
	conn, err := redis.Dial("tcp", *addr)
	if err != nil {
		log.Fatalf("Failed to connect to redis-server @ %s", *addr)
	}
	defer func() {
		_, err = conn.Do("FLUSHALL")
		err = conn.Close()
		if err != nil {
			log.Fatalf("Failed to communicate to redis-server @ %v", err)
		}
	}()
	rh.SetRedigoClient(conn)
	fmt.Println("Executing Example_JSONSET for Redigo Client")
	Example_JSONSet(rh)

	// GoRedis Client
	cli := goredis.NewClient(&goredis.Options{Addr: *addr})
	defer func() {
		if err := cli.FlushAll(context.Background()).Err(); err != nil {
			log.Fatalf("goredis - failed to flush: %v", err)
		}
		if err := cli.Close(); err != nil {
			log.Fatalf("goredis - failed to communicate to redis-server: %v", err)
		}
	}()
	rh.SetGoRedisClient(cli)
	fmt.Println("\nExecuting Example_JSONSET for GoRedis Client")
	Example_JSONSet(rh)
}
```

go-rejson

REST client and standard `database/sql` driver for Azure Cosmos DB

# gocosmos

[![Go Report Card](https://goreportcard.com/badge/github.com/btnguyen2k/gocosmos)](https://goreportcard.com/report/github.com/btnguyen2k/gocosmos)
[![PkgGoDev](https://pkg.go.dev/badge/github.com/btnguyen2k/gocosmos)](https://pkg.go.dev/github.com/btnguyen2k/gocosmos)
[![Actions Status](https://github.com/btnguyen2k/gocosmos/workflows/gocosmos/badge.svg)](https://github.com/btnguyen2k/gocosmos/actions)
[![codecov](https://codecov.io/gh/btnguyen2k/gocosmos/branch/main/graph/badge.svg)](https://codecov.io/gh/btnguyen2k/gocosmos)
[![Release](https://img.shields.io/github/release/btnguyen2k/gocosmos.svg?style=flat-square)](RELEASE-NOTES.md)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go#database-drivers)

Go driver for [Azure Cosmos DB SQL API](https://azure.microsoft.com/services/cosmos-db/) which can be used with the standard [database/sql](https://golang.org/pkg/database/sql/) package. A REST client is also included.

## database/sql driver

Summary of supported SQL statements:

| Statement | Syntax |
|---------------------------------------------|------------------------------------------------------------------------------------------|
| Create a new database | `CREATE DATABASE [IF NOT EXISTS] <db-name>` |
| Change database's throughput | `ALTER DATABASE <db-name> WITH RU/MAXRU=<ru>` |
| Delete an existing database | `DROP DATABASE [IF EXISTS] <db-name>` |
| List all existing databases | `LIST DATABASES` |
| Create a new collection | `CREATE COLLECTION [IF NOT EXISTS] [<db-name>.]<collection-name> <WITH PK=partitionKey>` |
| Change collection's throughput | `ALTER COLLECTION [<db-name>.]<collection-name> WITH RU/MAXRU=<ru>` |
| Delete an existing collection | `DROP COLLECTION [IF EXISTS] [<db-name>.]<collection-name>` |
| List all existing collections in a database | `LIST COLLECTIONS [FROM <db-name>]` |
| Insert a new document into collection | `INSERT INTO [<db-name>.]<collection-name> ...` |
| Insert or replace a document | `UPSERT INTO [<db-name>.]<collection-name> ...` |
| Delete an existing document | `DELETE FROM [<db-name>.]<collection-name> WHERE id=<id-value>` |
| Update an existing document | `UPDATE [<db-name>.]<collection-name> SET ... WHERE id=<id-value>` |
| Query documents in a collection | `SELECT [CROSS PARTITION] ... FROM <collection-name> ... [WITH database=<db-name>]` |

See [supported SQL statements](SQL.md) for details.

> Azure Cosmos DB SQL API currently supports only [SELECT statement](https://learn.microsoft.com/azure/cosmos-db/nosql/query/select).
> `gocosmos` implements other statements by translating the SQL statement to [REST API calls](https://learn.microsoft.com/rest/api/cosmos-db/).

### Example usage:

```go
package main

import (
	"database/sql"
	_ "github.com/btnguyen2k/gocosmos"
)

func main() {
	driver := "gocosmos"
	dsn := "AccountEndpoint=https://localhost:8081/;AccountKey=<cosmosdb-account-key>"
	db, err := sql.Open(driver, dsn)
	if err != nil {
		panic(err)
	}
	defer db.Close()
	
	_, err = db.Exec("CREATE DATABASE mydb WITH maxru=10000")
	if err != nil {
		panic(err)
	}
	
	// database "mydb" has been created successfuly
}
```

**Data Source Name (DSN) syntax for Cosmos DB**

_Note: line-break is for readability only!_

```connection
AccountEndpoint=<cosmosdb-endpoint>
;AccountKey=<cosmosdb-account-key>
[;TimeoutMs=<timeout-in-ms>]
[;Version=<cosmosdb-api-version>]
[;DefaultDb|Db=<db-name>]
[;AutoId=<true/false>]
[;InsecureSkipVerify=<true/false>]
```

- `AccountEndpoint`: (required) endpoint to access Cosmos DB. For example, the endpoint for Azure Cosmos DB Emulator running on local is `https://localhost:8081/`.
- `AccountKey`: (required) account key to authenticate.
- `TimeoutMs`: (optional) operation timeout in milliseconds. Default value is `10 seconds` if not specified.
- `Version`: (optional) version of Cosmos DB to use. Default value is `2020-07-15` if not specified. See: https://learn.microsoft.com/rest/api/cosmos-db/#supported-rest-api-versions.
- `DefaultDb`: (optional, available since [v0.1.1](RELEASE-NOTES.md)) specify the default database used in Cosmos DB operations. Alias `Db` can also be used instead of `DefaultDb`.
- `AutoId`: (optional, available since [v0.1.2](RELEASE-NOTES.md)) see [auto id](#auto-id) session.
- `InsecureSkipVerify`: (optional, available since [v0.1.4](RELEASE-NOTES.md)) if `true`, disable CA verification for https endpoint (useful to run against test/dev env with local/docker Cosmos DB emulator).

### Auto-id

Azure Cosmos DB requires each document has a [unique ID](https://learn.microsoft.com/rest/api/cosmos-db/documents) that identifies the document.
When creating new document, if value for the unique ID field is not supplied `gocosmos` is able to generate one automatically. This feature is enabled
by specifying setting `AutoId=true` in the Data Source Name (for `database/sql` driver) or the connection string (for REST client). If not specified, default
value is `AutoId=true`.

_This setting is available since [v0.1.2](RELEASE-NOTES.md)._

### Known issues

**`GROUP BY` combined with `ORDER BY` is not supported**

Azure Cosmos DB does not support `GROUP BY` combined with `ORDER BY` yet. You will receive the following error message:

> 'ORDER BY' is not supported in presence of GROUP BY.

**Cross-partition paging**

Cross-partition paging can be done with the `OFFSET...LIMIT` clause. However, the query is not stable without `ORDER BY`. The returned results may not be consistent from query to query.

**Queries that may consume a large amount of memory**

These queries may consume a large amount of memory if executed against a large table:

- `OFFSET...LIMIT` clause with big offset or limit values.
- `SELECT DISTINCT` and `SELECT DISTINCT VALUE` queries.
- Queries with `GROUP BY` clause.

## REST client

See the [REST.md](REST.md) file for details.

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details.

## Support and Contribution

> Disclaimer: I am also a core maintainer of [microsoft/gocosmos](https://github.com/microsoft/gocosmos/). Features and bug fixes are synchronized between the two projects.

This project uses [GitHub Issues](https://github.com/btnguyen2k/gocosmos/issues) to track bugs and feature requests. Please search the existing issues before filing new issues to avoid duplicates. For new issues, file your bug or feature request as a new Issue.

Please create [pull requests](https://github.com/microsoft/gocosmos/pulls) in the [microsoft/gocosmos](https://github.com/microsoft/gocosmos/) repository.

If you find this project useful, please start it.

gocosmos

redis client implement by golang, inspired by jedis

# godis
[![Go Doc](https://img.shields.io/badge/godoc-reference-blue.svg)](https://godoc.org/github.com/piaohao/godis)
[![Build Status](https://travis-ci.com/piaohao/godis.svg?branch=dev.master)](https://travis-ci.com/piaohao/godis) 
[![Go Report](https://goreportcard.com/badge/github.com/piaohao/godis?123)](https://goreportcard.com/report/github.com/piaohao/godis) 
[![codecov](https://codecov.io/gh/piaohao/godis/branch/master/graph/badge.svg)](https://codecov.io/gh/piaohao/godis)
[![License](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/piaohao/godis)

redis client implement by golang, refers to jedis.  
this library implements most of redis command, include normal redis command, cluster command, sentinel command, pipeline command and transaction command.  
if you've ever used jedis, then you can use godis easily, godis almost has the same method of jedis.  
especially, godis implements distributed lock in single mode and cluster mode, godis's lock is much more faster than redisson, on my computer(i7,8core,32g), run 100,000 loop, use 8 threads, the business code is just count++, redisson need 18s-20s, while godis just need 7 second.  
godis has done many test case to make sure it's stable.  

I am glad you made any suggestions, and I will actively iterate over the project.  

* [https://github.com/piaohao/godis](https://github.com/piaohao/godis)
* [https://gitee.com/piaohao/godis](https://gitee.com/piaohao/godis) 

# Features
* cluster
* pipeline
* transaction
* distributed lock
* other feature under development

# Installation
```
go get -u github.com/piaohao/godis
```
or use `go.mod`:
```
require github.com/piaohao/godis latest
```
# Documentation

* [ApiDoc](https://godoc.org/github.com/piaohao/godis)

# Quick Start
1. basic example

    ```go
    package main
    
    import (
        "github.com/piaohao/godis"
    )
    
    func main() {
        redis := godis.NewRedis(&godis.Option{
            Host: "localhost",
            Port: 6379,
            Db:   0,
        })
        defer redis.Close()
        redis.Set("godis", "1")
        arr, _ := redis.Get("godis")
        println(arr)
    }
    ```
1. use pool
    ```go
    package main
    
    import (
        "github.com/piaohao/godis"
    )
    
    func main() {
        option:=&godis.Option{
            Host: "localhost",
            Port: 6379,
            Db:   0,
        }
        pool := godis.NewPool(&godis.PoolConfig{}, option)
        redis, _ := pool.GetResource()
        defer redis.Close()
        redis.Set("godis", "1")
        arr, _ := redis.Get("godis")
        println(arr)
    }
    ```
1. pubsub
    ```go
    package main
    
    import (
        "github.com/piaohao/godis"
        "time"
    )
    
    func main() {
        option:=&godis.Option{
            Host: "localhost",
            Port: 6379,
            Db:   0,
        }
        pool := godis.NewPool(&godis.PoolConfig{}, option)
        go func() {
            redis, _ := pool.GetResource()
            defer redis.Close()
            pubsub := &godis.RedisPubSub{
                OnMessage: func(channel, message string) {
                    println(channel, message)
                },
                OnSubscribe: func(channel string, subscribedChannels int) {
                    println(channel, subscribedChannels)
                },
                OnPong: func(channel string) {
                    println("recieve pong")
                },
            }
            redis.Subscribe(pubsub, "godis")
        }()
        time.Sleep(1 * time.Second)
        {
            redis, _ := pool.GetResource()
            defer redis.Close()
            redis.Publish("godis", "godis pubsub")
            redis.Close()
        }
        time.Sleep(1 * time.Second)
    }
    ```
1. cluster
    ```go
    package main
    
    import (
        "github.com/piaohao/godis"
        "time"
    )
    
    func main() {
        cluster := godis.NewRedisCluster(&godis.ClusterOption{
            Nodes:             []string{"localhost:7000", "localhost:7001", "localhost:7002", "localhost:7003", "localhost:7004", "localhost:7005"},
            ConnectionTimeout: 0,
            SoTimeout:         0,
            MaxAttempts:       0,
            Password:          "",
            PoolConfig:        &godis.PoolConfig{},
        })
        cluster.Set("cluster", "godis cluster")
        reply, _ := cluster.Get("cluster")
        println(reply)
    }
    ```
1. pipeline
    ```go
    package main
    
    import (
        "github.com/piaohao/godis"
        "time"
    )
    
    func main() {
        option:=&godis.Option{
            Host: "localhost",
            Port: 6379,
            Db:   0,
        }
        pool := godis.NewPool(&godis.PoolConfig{}, option)
        redis, _ := pool.GetResource()
        defer redis.Close()
        p := redis.Pipelined()
        infoResp, _ := p.Info()
        timeResp, _ := p.Time()
        p.Sync()
        timeList, _ := timeResp.Get()
        println(timeList)
        info, _ := infoResp.Get()
        println(info)
    }
    ```
1. transaction
    ```go
    package main
    
    import (
        "github.com/piaohao/godis"
        "time"
    )
    
    func main() {
        option:=&godis.Option{
            Host: "localhost",
            Port: 6379,
            Db:   0,
        }
        pool := godis.NewPool(nil, option)
        redis, _ := pool.GetResource()
        defer redis.Close()
        p, _ := redis.Multi()
        infoResp, _ := p.Info()
        timeResp, _ := p.Time()
        p.Exec()
        timeList, _ := timeResp.Get()
        println(timeList)
        info, _ := infoResp.Get()
        println(info)
    }
    ``` 
1. distribute lock
    * single redis   
         ```go
            package main
            
            import (
                "github.com/piaohao/godis"
                "time"
            )
            
            func main() {
                locker := godis.NewLocker(&godis.Option{
                      Host: "localhost",
                      Port: 6379,
                      Db:   0,
                  }, &godis.LockOption{
                      Timeout: 5*time.Second,
                  })
                lock, err := locker.TryLock("lock")
                if err == nil && lock!=nil {
                    //do something
                    locker.UnLock(lock)
                }
                
            }
        ``` 
    * redis cluster   
         ```go
            package main
            
            import (
                "github.com/piaohao/godis"
                "time"
            )
            
            func main() {
                locker := godis.NewClusterLocker(&godis.ClusterOption{
                	Nodes:             []string{"localhost:7000", "localhost:7001", "localhost:7002", "localhost:7003", "localhost:7004", "localhost:7005"},
                    ConnectionTimeout: 0,
                    SoTimeout:         0,
                    MaxAttempts:       0,
                    Password:          "",
                    PoolConfig:        &godis.PoolConfig{},
                },&godis.LockOption{
                    Timeout: 5*time.Second,
                })
                lock, err := locker.TryLock("lock")
                if err == nil && lock!=nil {
                    //do something
                    locker.UnLock(lock)
                }
            }
        ```   
# License

`godis` is licensed under the [MIT License](LICENSE), 100% free and open-source, forever.      

# Thanks
* [[ jedis ] jedis is a popular redis client write by java](https://github.com/xetorthio/jedis)
* [[ gf ] gf is a amazing web framework write by golang](https://github.com/gogf/gf)
* [[ go-commons-pool ] refers to apache comnmon-pool](https://github.com/jolestar/go-commons-pool)

# Contact

piao.hao@qq.com
     

godis

A binary Memcached client for Go with support for sharding using consistent hashing, along with SASL

# Gomemcached

---
<div align=center>
<img src="https://github.com/aliexpressru/gomemcached/raw/main/assets/logo.png" width="300"/>

[![License](https://img.shields.io/github/license/gogf/gf.svg?style=flat)](https://github.com/aliexpressru/gomemcached)
[![Tag](https://img.shields.io/github/v/tag/aliexpressru/gomemcached?color=%23ff8936&logo=fitbit)](https://github.com/aliexpressru/gomemcached/tags)
[![Godoc](https://godoc.org/github.com/aliexpressru/gomemcached?status.svg)](https://pkg.go.dev/github.com/aliexpressru/gomemcached)

[![Gomemcached](https://goreportcard.com/badge/github.com/aliexpressru/gomemcached)](https://goreportcard.com/report/github.com/aliexpressru/gomemcached)
![Coverage](https://img.shields.io/badge/Coverage-93.6%25-brightgreen)

[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go?tab=readme-ov-file#nosql-database-drivers)
</div>

___
`Gomemcached` is a Golang Memcached client designed to interact with multiple instances as shards. Implements sharding using a Consistent Hash.
___

### Configuration

Configuration is primarily done through environment variables.

#### Namespace

By default, the client uses the **"aer"** namespace for environment variables and metrics. This means:

**Environment variables:**
```yaml
 - name: AER_MEMCACHED_HEADLESS_SERVICE_ADDRESS
 value: "my-memchached-service-headless.namespace.svc.cluster.local"
 - name: AER_MEMCACHED_PORT
 value: "11211"
 - name: AER_MEMCACHED_SERVERS
 value: "127.0.0.1:11211,192.168.0.1:1234"
```

#### Custom or Empty Namespace

You can customize or disable the namespace prefix using `WithNamespace()`:

```go
// Use no prefix (legacy behavior)
mcl, err := memcached.InitFromEnv(ctx, memcached.WithNamespace(""))
// Environment variables: MEMCACHED_SERVERS, MEMCACHED_PORT, MEMCACHED_HEADLESS_SERVICE_ADDRESS
// Metrics: gomemcached_method_duration_seconds, gomemcached_object_size_bytes

// Use custom prefix
mcl, err := memcached.InitFromEnv(ctx, memcached.WithNamespace("myapp"))
// Environment variables: MYAPP_MEMCACHED_SERVERS, MYAPP_MEMCACHED_PORT, MYAPP_MEMCACHED_HEADLESS_SERVICE_ADDRESS
// Metrics: myapp_gomemcached_method_duration_seconds, myapp_gomemcached_object_size_bytes
```

#### Configuration Variables

`MEMCACHED_HEADLESS_SERVICE_ADDRESS` (or `AER_MEMCACHED_HEADLESS_SERVICE_ADDRESS`) groups all memcached instances by ip addresses using dns lookup.

Default Memcached port is `11211`, but you can also specify it with `MEMCACHED_PORT` (or `AER_MEMCACHED_PORT`).

For local run or if you have a static amount and setup of pods you can specify Servers (list separated by commas along with the port) manually with `MEMCACHED_SERVERS` (or `AER_MEMCACHED_SERVERS`) instead of setting the HeadlessServiceAddress.

> **Note:** Environment variables are the preferred configuration method, but can be overridden programmatically with `WithHeadlessServiceAddress()`, `WithServersList()`, and `WithMemcachedPort()` options.
___

### Usage

Initialization client and connected to memcached servers.

```go
 mcl, err := memcached.InitFromEnv(ctx)
 mustInit(err)
 gracefulShutdown(
 func() error {
 mcl.CloseAllConns(ctx)
 return nil
 },
 )
```
[More examples](examples/usage_example.go)

To use SASL specify option for InitFromEnv:

```go
 memcached.InitFromEnv(memcached.WithAuthentication("<login>", "<password>"))
```

Can use Options with InitFromEnv to customize the client to suit your needs. However, for basic use, it is recommended
to use the default client implementation.

#### Metrics

The client automatically collects Prometheus metrics for method execution time and object sizes. By default, metrics are registered with `prometheus.DefaultRegisterer` and use the **"aer"** namespace prefix. See [metrics.go](memcached/metrics.go) for implementation details.

Available metrics (with default "aer" namespace):
- `aer_gomemcached_method_duration_seconds` - histogram of method execution times
- `aer_gomemcached_object_size_bytes` - histogram of object sizes being stored

##### Default Usage

Metrics are automatically registered with the default Prometheus registry and "aer" namespace:

```go
mcl, err := memcached.InitFromEnv(ctx)
// Metrics: aer_gomemcached_method_duration_seconds, aer_gomemcached_object_size_bytes
```

##### Custom Prometheus Registry

You can use a custom Prometheus registry for metric isolation or multi-tenancy:

```go
customRegistry := prometheus.NewRegistry()
mcl, err := memcached.InitFromEnv(
 ctx,
 memcached.WithMetricsRegisterer(customRegistry),
)
```

##### Custom Histogram Buckets

Adjust histogram buckets to match your expected latency profile:

```go
// Default duration buckets (seconds): [0.0005, 0.001, 0.005, 0.007, 0.015, 0.05, 0.1, 0.2, 0.5, 1]
customDurationBuckets := []float64{0.001, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0}
mcl, err := memcached.InitFromEnv(
 ctx,
 memcached.WithMetricsDurationBuckets(customDurationBuckets),
)
```

Adjust object size buckets to match your typical data sizes:

```go
// Default size buckets (bytes): [10, 100, 1024, 10240, 51200, 102400, 524288, 1048576, 5242880, 10485760]
// (10 bytes, 100 bytes, 1KB, 10KB, 50KB, 100KB, 512KB, 1MB, 5MB, 10MB)
customSizeBuckets := []float64{1024, 10240, 102400, 1048576} // 1KB, 10KB, 100KB, 1MB
mcl, err := memcached.InitFromEnv(
 ctx,
 memcached.WithMetricsObjectSizeBuckets(customSizeBuckets),
)
```

##### Disable Metrics

To disable metrics collection entirely:

```go
memcached.InitFromEnv(ctx, memcached.WithDisableMemcachedDiagnostic())
```

See [custom_metrics_example.go](examples/custom_metrics_example.go) for more examples.

---

### Recommended Versions

This project is developed and tested with the following recommended versions:

- Go: 1.24 or higher
 - [Download Go](https://golang.org/dl/)

- Memcached: 1.6.9 or higher
 - [Memcached Releases](https://memcached.org/downloads)

--- 

### Dependencies

This project utilizes the following third-party libraries, each governed by the MIT License:

1. [gomemcache](https://github.com/bradfitz/gomemcache)
 - Description: A Go client library for the memcached server.
 - Used for: Primary client methods for interacting with the library.
 - License: Apache License 2.0

2. [go-zero](https://github.com/zeromicro/go-zero)
 - Description: A cloud-native Go microservices framework with cli tool for productivity.
 - Used for: Implementation of Consistent Hash.
 - License: MIT License

3. [gomemcached](https://github.com/dustin/gomemcached)
 - Description: A memcached binary protocol toolkit for go.
 - Used for: Implementation of a binary client for Memcached.
 - License: MIT License

Please review the respective license files in the linked repositories for more details.

gomemcached

gorethink

neoism - Neo4j client for Go
===========================

![Neoism Logo](https://raw.github.com/jmcvetta/neoism/master/neoism.png)

Package `neoism` is a [Go](http://golang.org) client library providing access to
the [Neo4j](http://www.neo4j.org) graph database via its REST API.


# Status

| System    | Status                                                                                                                  |
|-----------|:-----------------------------------------------------------------------------------------------------------------------:|
| Travis CI | [![Travis CI](https://travis-ci.org/jmcvetta/neoism.png?branch=master)](https://travis-ci.org/jmcvetta/neoism)          |
| CircleCI  | [![CircleCI](https://circleci.com/gh/jmcvetta/neoism.svg?style=svg)](https://circleci.com/gh/jmcvetta/neoism)           | 
| Coveralls | [![Coveralls](https://img.shields.io/coveralls/jmcvetta/neoism/master.svg)](https://coveralls.io/r/jmcvetta/neoism)     |
| Codecov   | [![Codecov](https://img.shields.io/codecov/c/github/jmcvetta/neoism/master.svg)](https://codecov.io/gh/jmcvetta/neoism) |

This driver is fairly complete, and may now be suitable for general use.  The
code has an extensive set of integration tests, but little real-world testing.
YMMV; use in production at your own risk.


# Requirements

[Go 1.1](http://golang.org/doc/go1.1) or later is required.

Tested against Neo4j 2.2.4 and Go 1.4.1.


# Installation

## Development

```
go get -v github.com/jmcvetta/neoism
```


## Stable

Neoism is versioned using [`gopkg.in`](http://gopkg.in).  

Current release is `v1`

```
go get gopkg.in/jmcvetta/neoism.v1
```


# Documentation

See [GoDoc](http://godoc.org/github.com/jmcvetta/neoism) or
[Go Walker](http://gowalker.org/github.com/jmcvetta/neoism) for 
automatically generated documentation.


# Usage

## Connect to Neo4j Database

```go
db, err := neoism.Connect("http://localhost:7474/db/data")
```

## Create a Node

```go
n, err := db.CreateNode(neoism.Props{"name": "Captain Kirk"})
```


## Issue a Cypher Query

```go
// res will be populated with the query results.  It must be a slice of structs.
res := []struct {
		// `json:` tags matches column names in query
		A   string `json:"a.name"` 
		Rel string `json:"type(r)"`
		B   string `json:"b.name"`
	}{}

// cq holds the Cypher query itself (required), any parameters it may have 
// (optional), and a pointer to a result object (optional).
cq := neoism.CypherQuery{
	// Use backticks for long statements - Cypher is whitespace indifferent
	Statement: `
		MATCH (a:Person)-[r]->(b)
		WHERE a.name = {name}
		RETURN a.name, type(r), b.name
	`,
	Parameters: neoism.Props{"name": "Dr McCoy"},
	Result:     &res,
}

// Issue the query.
err := db.Cypher(&cq)

// Get the first result.
r := res[0]
```

## Issue Cypher queries with a transaction

```go
tx, err := db.Begin(qs)
if err != nil {
  // Handle error
}

cq0 := neoism.CypherQuery{
  Statement: `MATCH (a:Account) WHERE a.uuid = {account_id} SET balance = balance + {amount}`,
  Parameters: neoism.Props{"uuid": "abc123", amount: 20},
}
err = db.Cypher(&cq0)
if err != nil {
  // Handle error
}

cq1 := neoism.CypherQuery{
  Statement: `MATCH (a:Account) WHERE a.uuid = {account_id} SET balance = balance + {amount}`,
  Parameters: neoism.Props{"uuid": "def456", amount: -20},
}
err = db.Cypher(&cq1)
if err != nil {
  // Handle error
}

err := tx.Commit()
if err != nil {
  // Handle error
}
```


# Roadmap


## Completed:

* Node (create/edit/relate/delete/properties)
* Relationship (create/edit/delete/properties)
* Legacy Indexing (create/edit/delete/add node/remove node/find/query)
* Cypher queries
* Batched Cypher queries
* Transactional endpoint (Neo4j 2.0)
* Node labels (Neo4j 2.0)
* Schema index (Neo4j 2.0)
* Authentication (Neo4j 2.2)


## To Do:

* Streaming API support - see Issue [#22](https://github.com/jmcvetta/neoism/issues/22)
* ~~Unique Indexes~~ - probably will not expand support for legacy indexing.
* ~~Automatic Indexes~~ - "
* High Availability
* Traversals - May never be supported due to security concerns.  From the
  manual:  "The Traversal REST Endpoint executes arbitrary Groovy code under
  the hood as part of the evaluators definitions. In hosted and open
  environments, this can constitute a security risk."
* Built-In Graph Algorithms
* Gremlin


# Testing

Neoism's test suite respects, but does not require, a `NEO4J_URL` environment
variable.  By default it assumes Neo4j is running on `localhost:7474`, with
username `neo4j` and password `foobar`.  

```bash
export NEO4J_URL=http://your_user:your_password@neo4j.yourdomain.com/db/data/
go test -v .
```

If you are using a fresh untouched Neo4j instance, you can use the included
`set_neo4j_password.sh` script to set the password to that expected by Neoism's
tests:

```bash
sh set_neo4j_password.sh
```


# Support

Support and consulting services are available from [Silicon Beach Heavy
Industries](http://siliconheavy.com).


# Contributing

Contributions in the form of Pull Requests are gladly accepted.  Before
submitting a PR, please ensure your code passes all tests, and that your
changes do not decrease test coverage.  I.e. if you add new features also add
corresponding new tests.



# License

This is Free Software, released under the terms of the [GPL
v3](http://www.gnu.org/copyleft/gpl.html).


neoism

Redigo is a Go client for the Redis database

redigo

redis

Fast Redis RESP3 client with auto pipelining and server-assisted client side caching

rueidis

Typesafe, customizable, clean & easy to use Redis client

# xredis [![Build Status](https://travis-ci.com/shomali11/xredis.svg?branch=master)](https://travis-ci.com/shomali11/xredis) [![Go Report Card](https://goreportcard.com/badge/github.com/shomali11/xredis)](https://goreportcard.com/report/github.com/shomali11/xredis) [![GoDoc](https://godoc.org/github.com/shomali11/xredis?status.svg)](https://godoc.org/github.com/shomali11/xredis) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

Built on top of [github.com/garyburd/redigo](https://github.com/garyburd/redigo) with the idea to simplify creating a Redis client, provide type safe calls and encapsulate the low level details to easily integrate with Redis.

## Features

* Type safe client
* Easy to setup using
 * Default client
 * Custom client via set options
 * `redigo`'s `redis.Pool`
* Connection pool provided automatically
* Support for Redis Sentinel
 * Writes go to the Master
 * Reads go to the Slaves. Falls back on Master if none are available.
* Supports the following Redis commands
 * **ECHO**, **INFO**, **PING**, **FLUSH**, **FLUSHALL**, **EXPIRE**, **APPEND**
 * **SET**, **SETEX**, **SETNX**, **GET**, **DEL**, **EXISTS**, **KEYS**, **SCAN**, **GETRANGE**, **SETRANGE**
 * **HSET**, **HGET**, **HGETALL**, **HDEL**, **HEXISTS**, **HKEYS**, **HSCAN**
 * **INCR**, **INCRBY**, **INCRBYFLOAT**, **DECR**, **DECRBY**, **DECRBYFLOAT**
 * **HINCR**, **HINCRBY**, **HINCRBYFLOAT**, **HDECR**, **HDECRBY**, **HDECRBYFLOAT**
 * _More coming soon_
* Full access to Redigo's API [github.com/garyburd/redigo](https://github.com/garyburd/redigo)

## Dependencies

* `redigo` [github.com/garyburd/redigo](https://github.com/garyburd/redigo)
* `go-sentinel` [github.com/FZambia/go-sentinel](https://github.com/FZambia/go-sentinel)

# Examples

## Example 1

Using `DefaultClient` to create a redis client with default options

```go
package main

import (
	"fmt"
	"github.com/shomali11/xredis"
)

func main() {
	client := xredis.DefaultClient()
	defer client.Close()

	fmt.Println(client.Ping()) // PONG <nil>
}
```

List of default options

```text
defaultHost = "localhost"
defaultPort = 6379
defaultPassword = ""
defaultDatabase = 0
defaultNetwork = "tcp"
defaultConnectTimeout = time.Second
defaultWriteTimeout = time.Second
defaultReadTimeout = time.Second
defaultConnectionIdleTimeout = 240 * time.Second
defaultConnectionMaxIdle = 100
defaultConnectionMaxActive = 10000
defaultConnectionWait = false
defaultTlsConfig = nil
defaultTlsSkipVerify = false
defaultTestOnBorrowTimeout = time.Minute
```

## Example 2

Using `SetupClient` to create a redis client using provided options

```go
package main

import (
	"fmt"
	"github.com/shomali11/xredis"
)

func main() {
	options := &xredis.Options{
		Host: "localhost",
		Port: 6379,
	}

	client := xredis.SetupClient(options)
	defer client.Close()

	fmt.Println(client.Ping()) // PONG <nil>
}
```

Available options to set

```go
type Options struct {
	Host string
	Port int
	Password string
	Database int
	Network string
	ConnectTimeout time.Duration
	WriteTimeout time.Duration
	ReadTimeout time.Duration
	ConnectionIdleTimeout time.Duration
	ConnectionMaxIdle int
	ConnectionMaxActive int
	ConnectionWait bool
	TlsConfig *tls.Config
	TlsSkipVerify bool
	TestOnBorrowPeriod time.Duration
}
```

## Example 3

Using `SetupSentinelClient` to create a redis sentinel client using provided options

```go
package main

import (
	"fmt"
	"github.com/shomali11/xredis"
)

func main() {
	options := &xredis.SentinelOptions{
		Addresses: []string{"localhost:26379"},
		MasterName: "master",
	}

	client := xredis.SetupSentinelClient(options)
	defer client.Close()

	fmt.Println(client.Ping()) // PONG <nil>
}
```

Available options to set

```go
type SentinelOptions struct {
	Addresses []string
	MasterName string
	Password string
	Database int
	Network string
	ConnectTimeout time.Duration
	WriteTimeout time.Duration
	ReadTimeout time.Duration
	ConnectionIdleTimeout time.Duration
	ConnectionMaxIdle int
	ConnectionMaxActive int
	ConnectionWait bool
	TlsConfig *tls.Config
	TlsSkipVerify bool
}
```

## Example 4

Using `NewClient` to create a redis client using `redigo`'s `redis.Pool`

```go
package main

import (
	"fmt"
	"github.com/garyburd/redigo/redis"
	"github.com/shomali11/xredis"
)

func main() {
	pool := &redis.Pool{
		Dial: func() (redis.Conn, error) {
			return redis.Dial("tcp", "localhost:6379")
		},
	}

	client := xredis.NewClient(pool)
	defer client.Close()

	fmt.Println(client.Ping()) // PONG <nil>
}
```

## Example 5

Using the `Ping`, `Echo` & `Info` commands to ping, echo messages and return redis' information and statistics

```go
package main

import (
	"fmt"
	"github.com/shomali11/xredis"
)

func main() {
	client := xredis.DefaultClient()
	defer client.Close()

	fmt.Println(client.Ping()) // PONG <nil>
	fmt.Println(client.Echo("Hello")) // Hello <nil>
	fmt.Println(client.FlushDb()) // <nil>
	fmt.Println(client.FlushAll()) // <nil>
	fmt.Println(client.Info()) 
}
```

## Example 6

Using the `Set`, `Keys`, `Get`, `Exists`, `Expire`, `Append`, `GetRange`, `SetRange` and `Del` commands to show how to set, get and delete keys and values.
_Note that the `Get` returns 3 values, a `string` result, a `bool` that determines whether the key exists and an `error`_

```go
package main

import (
	"fmt"
	"github.com/shomali11/xredis"
)

func main() {
	client := xredis.DefaultClient()
	defer client.Close()

	fmt.Println(client.Set("name", "Raed Shomali")) // true <nil>
	fmt.Println(client.SetNx("name", "Hello")) // false <nil>
	fmt.Println(client.SetEx("id", "10", 1)) // true <nil>
	fmt.Println(client.Expire("name", 1)) // true <nil>
	fmt.Println(client.Expire("unknown", 1)) // false <nil>
	fmt.Println(client.Keys("*")) // [id name] <nil>
	fmt.Println(client.Get("name")) // "Raed Shomali" true <nil>
	fmt.Println(client.Exists("name")) // true <nil>
	fmt.Println(client.Del("name")) // 1 <nil>
	fmt.Println(client.Exists("name")) // false <nil>
	fmt.Println(client.Get("name")) // "" false <nil>
	fmt.Println(client.Del("name")) // 0 <nil>
	fmt.Println(client.Append("name", "a")) // 1 <nil>
	fmt.Println(client.Append("name", "b")) // 2 <nil>
	fmt.Println(client.Append("name", "c")) // 3 <nil>
	fmt.Println(client.Get("name")) // "abc" true <nil>
	fmt.Println(client.GetRange("name", 0 , 1)) // "ab" <nil>
	fmt.Println(client.SetRange("name", 2, "xyz")) // 5 <nil>
	fmt.Println(client.Get("name")) // "abxyz" <nil>
	fmt.Println(client.Scan(0, "*")) // 0 [name id] <nil>
	fmt.Println(client.Del("id", "name")) // 2 <nil>
}
```

## Example 7

Using the `Incr`, `IncrBy`, `IncrByFloat`, `Decr`, `DecrBy`, `DecrByFloat` commands, we can increment and decrement a key's value

```go
package main

import (
	"fmt"
	"github.com/shomali11/xredis"
)

func main() {
	client := xredis.DefaultClient()
	defer client.Close()

	fmt.Println(client.Set("integer", "10")) // true <nil>
	fmt.Println(client.Set("float", "5.5")) // true <nil>

	fmt.Println(client.Get("integer")) // 10 true <nil>
	fmt.Println(client.Get("float")) // 5.5 true <nil>

	fmt.Println(client.Incr("integer")) // 11 <nil>
	fmt.Println(client.IncrBy("integer", 10)) // 21 <nil>
	fmt.Println(client.DecrBy("integer", 5)) // 16 <nil>
	fmt.Println(client.Decr("integer")) // 15 <nil>

	fmt.Println(client.IncrByFloat("float", 3.3)) // 8.8 <nil>
	fmt.Println(client.DecrByFloat("float", 1.1)) // 7.7 <nil>

	fmt.Println(client.Get("integer")) // 15 true <nil>
	fmt.Println(client.Get("float")) // 7.7 true <nil>

	fmt.Println(client.Del("integer", "float")) // 2 <nil>
}
```

## Example 8

Using the `HSet`, `HKeys`, `HGet`, `HGetAll`, `HExists` and `HDel` commands to show how to set, get and delete hash keys, fields and values.
_Note that the `HGetAll` returns 2 values, a `map[string]string` result and an `error`_

```go
package main

import (
	"fmt"
	"github.com/shomali11/xredis"
)

func main() {
	client := xredis.DefaultClient()
	defer client.Close()

	fmt.Println(client.HSet("hash", "name", "Raed Shomali")) // true <nil>
	fmt.Println(client.HSet("hash", "sport", "Football")) // true <nil>
	fmt.Println(client.HKeys("hash")) // [name sport] <nil>
	fmt.Println(client.HScan("hash", 0, "*")) // 0 [name Raed Shomali sport Football] <nil>
	fmt.Println(client.HGet("hash", "name")) // "Raed Shomali" true <nil>
	fmt.Println(client.HGetAll("hash")) // map[name:Raed Shomali sport:Football] <nil>
	fmt.Println(client.HExists("hash", "name")) // true <nil>
	fmt.Println(client.HDel("hash", "name", "sport")) // 2 <nil>
	fmt.Println(client.HGet("hash", "name")) // "" false <nil>
	fmt.Println(client.HExists("hash", "name")) // false <nil>
	fmt.Println(client.HGetAll("hash")) // map[] nil
	fmt.Println(client.HDel("hash", "name")) // 0 <nil>
	fmt.Println(client.HKeys("hash")) // [] <nil>
}
```

## Example 9

Using the `HIncr`, `HIncrBy`, `HIncrByFloat`,`HDecr`, `HDecrBy` and `HDecrByFloat` commands to show how to increment and decrement hash fields' values.

```go
package main

import (
	"fmt"
	"github.com/shomali11/xredis"
)

func main() {
	client := xredis.DefaultClient()
	defer client.Close()

	fmt.Println(client.HSet("hash", "integer", "10")) // true <nil>
	fmt.Println(client.HSet("hash", "float", "5.5")) // true <nil>

	fmt.Println(client.HIncr("hash", "integer")) // 11 <nil>
	fmt.Println(client.HIncrBy("hash", "integer", 10)) // 21 <nil>
	fmt.Println(client.HDecrBy("hash", "integer", 5)) // 16 <nil>
	fmt.Println(client.HDecr("hash", "integer")) // 15 <nil>

	fmt.Println(client.HIncrByFloat("hash", "float", 3.3)) // 8.8 <nil>
	fmt.Println(client.HDecrByFloat("hash", "float", 1.1)) // 7.7 <nil>

	fmt.Println(client.HDel("hash", "integer", "float")) // 2 <nil>
}
```

## Example 10

Can't find the command you want? You have full access to `redigo`'s API.

```go
package main

import (
	"fmt"
	"github.com/garyburd/redigo/redis"
	"github.com/shomali11/xredis"
)

func main() {
	client := xredis.DefaultClient()
	defer client.Close()

	connection := client.GetConnection()
	defer connection.Close()

	fmt.Println(redis.String(connection.Do("INFO")))
}
```

xredis

# Go Client for Pilosa

This repo archived Sept 2022 as part of the transition from Pilosa to FeatureBase.
Please contact community[at]featurebase[dot]com with any questions.

<a href="https://github.com/pilosa"><img src="https://img.shields.io/badge/pilosa-1.3-blue.svg"></a>
<a href="https://godoc.org/github.com/pilosa/go-pilosa"><img src="https://godoc.org/github.com/pilosa/go-pilosa?status.svg" alt="GoDoc"></a>
<a href="https://travis-ci.org/pilosa/go-pilosa"><img src="https://api.travis-ci.org/pilosa/go-pilosa.svg?branch=master"></a>
<a href="https://goreportcard.com/report/github.com/pilosa/go-pilosa"><img src="https://goreportcard.com/badge/github.com/pilosa/go-pilosa?updated=1"></a>
<a href="https://coveralls.io/github/pilosa/go-pilosa"><img src="https://coveralls.io/repos/github/pilosa/go-pilosa/badge.svg?updated=2"></a>

<img src="https://www.pilosa.com/img/speed_sloth.svg" style="float: right" align="right" height="301">

Go client for Pilosa high performance distributed index.

## What's New?

See: [CHANGELOG](CHANGELOG.md)

## Requirements

* Go 1.12 and higher.

## Install

Download the library in your `GOPATH` using:
```
go get github.com/pilosa/go-pilosa
```

After that, you can import the library in your code using:

```go
import "github.com/pilosa/go-pilosa"
```

## Usage

### Quick overview

Assuming [Pilosa](https://github.com/pilosa/pilosa) server is running at `localhost:10101` (the default):

```go
package main

import (
	"fmt"

	"github.com/pilosa/go-pilosa"
)

func main() {
	var err error

	// Create the default client
	client := pilosa.DefaultClient()

	// Retrieve the schema
	schema, err := client.Schema()

	// Create an Index object
	myindex := schema.Index("myindex")

	// Create a Field object
	myfield := myindex.Field("myfield")

	// make sure the index and the field exists on the server
	err = client.SyncSchema(schema)

	// Send a Set query. If err is non-nil, response will be nil.
	response, err := client.Query(myfield.Set(5, 42))

	// Send a Row query. If err is non-nil, response will be nil.
	response, err = client.Query(myfield.Row(5))

	// Get the result
	result := response.Result()
	// Act on the result
	if result != nil {
		columns := result.Row().Columns
		fmt.Println("Got columns: ", columns)
	}

	// You can batch queries to improve throughput
	response, err = client.Query(myindex.BatchQuery(
		myfield.Row(5),
		myfield.Row(10)))
	if err != nil {
		fmt.Println(err)
	}

	for _, result := range response.Results() {
		// Act on the result
		fmt.Println(result.Row().Columns)
	}
}
```

## Documentation

### Data Model and Queries

See: [Data Model and Queries](docs/data-model-queries.md)

### Executing Queries

See: [Server Interaction](docs/server-interaction.md)

### Importing and Exporting Data

See: [Importing and Exporting Data](docs/imports-exports.md)

### Other Documentation

* [Tracing](docs/tracing.md)

## Contributing

See: [CONTRIBUTING](CONTRIBUTING.md)

## License

See: [LICENSE](LICENSE)

go-pilosa

[![GoDoc](https://godoc.org/github.com/couchbase/gocb?status.png)](https://godoc.org/github.com/couchbase/gocb)

# Couchbase Go Client

This is the official Couchbase Go SDK.  If you are looking for our
previous unofficial prototype Go client library, please see:
[http://www.github.com/couchbase/go-couchbase](go-couchbase).

The Go SDK library allows you to connect to a Couchbase cluster from
Go. It is written in pure Go, and uses the included gocbcore library to
handle communicating to the cluster over the Couchbase binary
protocol.


## Useful Links

### Source
The project source is hosted at [http://github.com/couchbase/gocb](http://github.com/couchbase/gocb).

### Documentation
You can explore our API reference through godoc at [https://godoc.org/github.com/couchbase/gocb](https://godoc.org/github.com/couchbase/gocb).

You can also find documentation for the Go SDK at the Couchbase [Developer Portal](http://developer.couchbase.com/documentation/server/4.5/sdk/go/start-using-sdk.html).

### Bug Tracker
Issues are tracked on Couchbase's public [issues.couchbase.com](http://www.couchbase.com/issues/browse/GOCBC).
Contact [the site admins](https://issues.couchbase.com/secure/ContactAdministrators!default.jspa)
regarding login or other problems at issues.couchbase.com (officially) or ask
around in [couchbase/discuss on gitter.im](https://gitter.im/couchbase/discuss)
(unofficially).


## Installing

To install the latest stable version, run:
```bash
go get gopkg.in/couchbase/gocb.v1
```

To install the latest developer version, run:
```bash
go get github.com/couchbase/gocb
```


## License
Copyright 2016 Couchbase Inc.

Licensed under the Apache License, Version 2.0.

See
[LICENSE](https://github.com/couchbase/gocb/blob/master/LICENSE)
for further details.


gocb

A wrapper for the Google Cloud Platform Go Datastore package that adds caching using memcached

# Go DS Cache  
  
[![Build Status](https://travis-ci.org/defcronyke/godscache.svg?branch=master)](https://travis-ci.org/defcronyke/godscache)
[![Coverage Status](https://coveralls.io/repos/github/defcronyke/godscache/badge.svg?branch=master&service=github)](https://coveralls.io/github/defcronyke/godscache?branch=master)
[![Go Report Card](https://goreportcard.com/badge/github.com/defcronyke/godscache)](https://goreportcard.com/report/github.com/defcronyke/godscache)
[![Awesome Go](https://camo.githubusercontent.com/13c4e50d88df7178ae1882a203ed57b641674f94/68747470733a2f2f63646e2e7261776769742e636f6d2f73696e647265736f726875732f617765736f6d652f643733303566333864323966656437386661383536353265336136336531353464643865383832392f6d656469612f62616467652e737667)](https://github.com/avelino/awesome-go#database-drivers)
[![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/godscache/Lobby)
[![Freenode chat](https://img.shields.io/badge/chat-on%20freenode-brightgreen.svg)](https://webchat.freenode.net/?channels=#godscache)
[![GoDoc](https://godoc.org/github.com/defcronyke/godscache?status.png)](https://godoc.org/github.com/defcronyke/godscache)
  
An unofficial Google Cloud Platform Go Datastore wrapper that adds caching using memcached.  
  
For App Engine Flexible, Compute Engine, Kubernetes Engine, and more.  
  
Documentation is here: [https://godoc.org/github.com/defcronyke/godscache](https://godoc.org/github.com/defcronyke/godscache)  


godscache

neo4j.go
========

[![GoDoc](https://godoc.org/github.com/cihangir/neo4j?status.svg)](https://godoc.org/github.com/cihangir/neo4j)
[![Build Status](https://travis-ci.org/cihangir/neo4j.svg)](https://travis-ci.org/cihangir/neo4j)

Implementation of client package for communication with Neo4j Rest API.

For more information and documentation please read [Godoc Neo4j Page](http://godoc.org/github.com/cihangir/neo4j)


# setup

```
go get github.com/siesta/neo4j
```


# example usage


```
 Node:
     neo4jConnection := Connect("")
     node := &Node{}
     node.Id = "2229"
     err := neo4jConnection.Get(node)
     fmt.Println(node)

 Relationship:
    neo4jConnection := Connect("")
    rel             := &Relationship{}
    rel.Id          = "2412"
    neo4jConnection.Get(rel)

```


neo4j

The MongoDB driver for Go. It‘s based on official MongoDB driver but easier to use like Mgo

# Qmgo 

[![Build Status](https://travis-ci.org/qiniu/qmgo.png?branch=master)](https://travis-ci.org/qiniu/qmgo)
[![Coverage Status](https://codecov.io/gh/qiniu/qmgo/branch/master/graph/badge.svg)](https://codecov.io/gh/qiniu/qmgo)
[![Go Report Card](https://goreportcard.com/badge/github.com/qiniu/qmgo)](https://goreportcard.com/report/github.com/qiniu/qmgo)
[![GitHub release](https://img.shields.io/github/v/tag/qiniu/qmgo.svg?label=release)](https://github.com/qiniu/qmgo/releases)
[![GoDoc](https://pkg.go.dev/badge/github.com/qiniu/qmgo?status.svg)](https://pkg.go.dev/github.com/qiniu/qmgo?tab=doc) 

English | [简体中文](README_ZH.md)

`Qmgo` is a `Go` `driver` for `MongoDB` . It is based on [MongoDB official driver](https://github.com/mongodb/mongo-go-driver), but easier to use like [mgo](https://github.com/go-mgo/mgo) (such as the chain call). 

- `Qmgo` allows users to use the new features of `MongoDB` in a more elegant way.

- `Qmgo` is the first choice for migrating from `mgo` to the new `MongoDB driver` with minimal code changes.

## Requirements

-`Go 1.10` and above.

-`MongoDB 2.6` and above.

## Features
- CRUD to documents, with all official supported options
- Sort、limit、count、select、distinct
- Transactions
- Hooks
- Automatically default and custom fields
- Predefine operator keys
- Aggregate、indexes operation、cursor
- Validation tags
- Plugin

## Installation

- Use `go mod` to automatically install dependencies by `import github.com/qiniu/qmgo`

Or 

- Use `go get github.com/qiniu/qmgo`

## Usage

- Start

    `import` and create a new connection
    ```go
    import (
        "context"
      
        "github.com/qiniu/qmgo"
    )
    
    ctx := context.Background()
    client, err := qmgo.NewClient(ctx, &qmgo.Config{Uri: "mongodb://localhost:27017"})
    db := client.Database("class")
    coll := db.Collection("user")
    ```
    If your connection points to a fixed database and collection, recommend using the following way to initialize the connection.
    All operations can be based on `cli`:
    
    ```go
    cli, err := qmgo.Open(ctx, &qmgo.Config{Uri: "mongodb://localhost:27017", Database: "class", Coll: "user"})
    ```
    
    ***The following examples will be based on `cli`, if you use the first way for initialization, replace `cli` with `client`、`db` or `coll`***
    
    Make sure to defer a call to Disconnect after instantiating your client:
    
    ```go
    defer func() {
    if err = cli.Close(ctx); err != nil {
            panic(err)
        }
    }()
    ```

- Create index

    Before doing the operation, we first initialize some data:
    
    ```go
    type UserInfo struct {
        Name   string `bson:"name"`
        Age    uint16 `bson:"age"`
        Weight uint32 `bson:"weight"`
    }
    
    var userInfo = UserInfo{
        Name: "xm",
        Age: 7,
        Weight: 40,
    }
    ```
    
    Create index
    
    ```go
    cli.CreateOneIndex(context.Background(), options.IndexModel{Key: []string{"name"}})
    cli.CreateIndexes(context.Background(), []options.IndexModel{{Key: []string{"id2", "id3"}}})
    ```

- Insert a document

    ```go
    // insert one document
    result, err := cli.InsertOne(ctx, userInfo)
    ```

- Find a document

    ```go
    // find one document
      one := UserInfo{}
      err = cli.Find(ctx, bson.M{"name": userInfo.Name}).One(&one)
    ```

- Delete documents
    
    ```go
    err = cli.Remove(ctx, bson.M{"age": 7})
    ```

- Insert multiple data

    ```go
    // multiple insert
    var userInfos = []UserInfo{
        UserInfo{Name: "a1", Age: 6, Weight: 20},
        UserInfo{Name: "b2", Age: 6, Weight: 25},
        UserInfo{Name: "c3", Age: 6, Weight: 30},
        UserInfo{Name: "d4", Age: 6, Weight: 35},
        UserInfo{Name: "a1", Age: 7, Weight: 40},
        UserInfo{Name: "a1", Age: 8, Weight: 45},
    }
    result, err = cli.Collection.InsertMany(ctx, userInfos)
    ```

- Search all, sort and limit
    ```go
    // find all, sort and limit
    batch := []UserInfo{}
    cli.Find(ctx, bson.M{"age": 6}).Sort("weight").Limit(7).All(&batch)
    ```
- Count

    ````go
    count, err := cli.Find(ctx, bson.M{"age": 6}).Count()
    ````

- Update

    ````go
    // UpdateOne one
    err := cli.UpdateOne(ctx, bson.M{"name": "d4"}, bson.M{"$set": bson.M{"age": 7}})
    
    // UpdateAll
    result, err := cli.UpdateAll(ctx, bson.M{"age": 6}, bson.M{"$set": bson.M{"age": 10}})
    ````

- Select

    ````go
    err := cli.Find(ctx, bson.M{"age": 10}).Select(bson.M{"age": 1}).One(&one)
    ````

- Aggregate

    ```go
    matchStage := bson.D{{"$match", []bson.E{{"weight", bson.D{{"$gt", 30}}}}}}
    groupStage := bson.D{{"$group", bson.D{{"_id", "$name"}, {"total", bson.D{{"$sum", "$age"}}}}}}
    var showsWithInfo []bson.M
    err = cli.Aggregate(context.Background(), Pipeline{matchStage, groupStage}).All(&showsWithInfo)
    ```

- Support All mongoDB Options when create connection

    ````go
    poolMonitor := &event.PoolMonitor{
        Event: func(evt *event.PoolEvent) {
            switch evt.Type {
            case event.GetSucceeded:
                fmt.Println("GetSucceeded")
            case event.ConnectionReturned:
                fmt.Println("ConnectionReturned")
            }
        },
    }
    opt := options.Client().SetPoolMonitor(poolMonitor)  // more options use the chain options.
    cli, err := Open(ctx, &Config{Uri: URI, Database: DATABASE, Coll: COLL}, opt) 
    
    
    ````

- Transactions

    The super simple and powerful transaction, with features like `timeout`、`retry`:
    ````go
    callback := func(sessCtx context.Context) (interface{}, error) {
        // Important: make sure the sessCtx used in every operation in the whole transaction
        if _, err := cli.InsertOne(sessCtx, bson.D{{"abc", int32(1)}}); err != nil {
            return nil, err
        }
        if _, err := cli.InsertOne(sessCtx, bson.D{{"xyz", int32(999)}}); err != nil {
            return nil, err
        }
        return nil, nil
    }
    result, err = cli.DoTransaction(ctx, callback)
    ````
    [More about transaction](https://github.com/qiniu/qmgo/wiki/Transactions)

- Predefine operator keys

    ````go
    // aggregate
    matchStage := bson.D{{operator.Match, []bson.E{{"weight", bson.D{{operator.Gt, 30}}}}}}
    groupStage := bson.D{{operator.Group, bson.D{{"_id", "$name"}, {"total", bson.D{{operator.Sum, "$age"}}}}}}
    var showsWithInfo []bson.M
    err = cli.Aggregate(context.Background(), Pipeline{matchStage, groupStage}).All(&showsWithInfo)
    ````

- Hooks

    Qmgo flexible hooks:

    ````go
    type User struct {
        Name         string    `bson:"name"`
        Age          int       `bson:"age"`
    }
    func (u *User) BeforeInsert(ctx context.Context) error {
        fmt.Println("before insert called")
        return nil
    }
    func (u *User) AfterInsert(ctx context.Context) error {
        fmt.Println("after insert called")
        return nil
    }
    
    u := &User{Name: "Alice", Age: 7}
    _, err := cli.InsertOne(context.Background(), u)
    ````
    [More about hooks](https://github.com/qiniu/qmgo/wiki/Hooks)

- Automatically fields

    Qmgo support two ways to make specific fields automatically update in specific API
   
    - Default fields
    
    Inject `field.DefaultField` in document struct, Qmgo will update `createAt`、`updateAt` and `_id` in update and insert operation.
    
    ````go
    type User struct {
      field.DefaultField `bson:",inline"`
    
      Name string `bson:"name"`
      Age  int    `bson:"age"`
    }
  
  	u := &User{Name: "Lucas", Age: 7}
  	_, err := cli.InsertOne(context.Background(), u)
    // Fields with tag createAt、updateAt and _id will be generated automatically 
    ```` 

    - Custom fields
    
    Define the custom fields, Qmgo will update them in update and insert operation.

    ```go
    type User struct {
        Name string `bson:"name"`
        Age  int    `bson:"age"`
    
        MyId         string    `bson:"myId"`
        CreateTimeAt time.Time `bson:"createTimeAt"`
        UpdateTimeAt int64     `bson:"updateTimeAt"`
    }
    // Define the custom fields
    func (u *User) CustomFields() field.CustomFieldsBuilder {
        return field.NewCustom().SetCreateAt("CreateTimeAt").SetUpdateAt("UpdateTimeAt").SetId("MyId")
    }
  
    u := &User{Name: "Lucas", Age: 7}
    _, err := cli.InsertOne(context.Background(), u)
    // CreateTimeAt、UpdateTimeAt and MyId will be generated automatically 
  
    // suppose Id and ui is ready
  	err = cli.ReplaceOne(context.Background(), bson.M{"_id": Id}, &ui)
    // UpdateTimeAt will update
    ```

    Check [examples here](https://github.com/qiniu/qmgo/blob/master/field_test.go)

    [More about automatically fields](https://github.com/qiniu/qmgo/wiki/Automatically-update-fields)

- Validation tags

    Qmgo Validation tags is Based on [go-playground/validator](https://github.com/go-playground/validator).
    
    So Qmgo support [all validations on structs in go-playground/validator](https://github.com/go-playground/validator#usage-and-documentation), such as:
    
    ```go
    type User struct {
        FirstName string            `bson:"fname"`
        LastName  string            `bson:"lname"`
        Age       uint8             `bson:"age" validate:"gte=0,lte=130" `    // Age must in [0,130]
        Email     string            `bson:"e-mail" validate:"required,email"` //  Email can't be empty string, and must has email format
        CreateAt  time.Time         `bson:"createAt" validate:"lte"`          // CreateAt must lte than current time
        Relations map[string]string `bson:"relations" validate:"max=2"`       // Relations can't has more than 2 elements
    }
    ```
    
    Qmgo tags only supported in following API：
    ` InsertOne、InsertyMany、Upsert、UpsertId、ReplaceOne `

- Plugin
    
    - Implement following method:
    
    ```go
    func Do(ctx context.Context, doc interface{}, opType operator.OpType, opts ...interface{}) error{
      // do anything
    }
    ```
    
    - Call Register() in package middleware, register the method `Do`
    
      Qmgo will call `Do` before and after the [operation](operator/operate_type.go)
      
    ```go
    middleware.Register(Do)
    ```
    [Example](middleware/middleware_test.go)
    
    The `hook`、`automatically fields` and `validation tags` in Qmgo run on **plugin**.
    
## `Qmgo` vs `go.mongodb.org/mongo-driver`

Below we give an example of multi-file search、sort and limit to illustrate the similarities between `qmgo` and `mgo` and the improvement compare to `go.mongodb.org/mongo-driver`.
How do we do in`go.mongodb.org/mongo-driver`:

```go
// go.mongodb.org/mongo-driver
// find all, sort and limit
findOptions := options.Find()
findOptions.SetLimit(7) // set limit
var sorts D
sorts = append(sorts, E{Key: "weight", Value: 1})
findOptions.SetSort(sorts) // set sort

batch := []UserInfo{}
cur, err := coll.Find(ctx, bson.M{"age": 6}, findOptions)
cur.All(ctx, &batch)
```

How do we do in `Qmgo` and `mgo`:

```go
// qmgo
// find all, sort and limit
batch := []UserInfo{}
cli.Find(ctx, bson.M{"age": 6}).Sort("weight").Limit(7).All(&batch)

// mgo
// find all, sort and limit
coll.Find(bson.M{"age": 6}).Sort("weight").Limit(7).All(&batch)
```

## `Qmgo` vs `mgo`
[Differences between qmgo and mgo](https://github.com/qiniu/qmgo/wiki/Differences-between-Qmgo-and-Mgo)
 
## Contributing

The Qmgo project welcomes all contributors. We appreciate your help! 

## Communication:

- Join [qmgo discussions](https://github.com/qiniu/qmgo/discussions)



qmgo

Redis-protocol compatible TCP servers/services

# Redeo

[![Go Reference](https://pkg.go.dev/badge/github.com/bsm/redeo/v2)](https://pkg.go.dev/github.com/bsm/redeo/v2)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)

The high-performance Swiss Army Knife for building redis-protocol compatible servers/services.

## Parts

This repository is organised into multiple components:

* [root](./) package contains the framework for building redis-protocol compatible,
  high-performance servers.
* [resp](./resp/) implements low-level primitives for dealing with
  RESP (REdis Serialization Protocol), client and server-side. It
  contains basic wrappers for readers and writers to read/write requests and
  responses.
* [client](./client/) contains a minimalist pooled client.

For full documentation and examples, please see the individual packages and the
official API documentation: https://godoc.org/github.com/bsm/redeo.

## Examples

A simple server example with two commands:

```go
package main

import (
  "net"

  "github.com/bsm/redeo/v2"
)

func main() {
	srv := redeo.NewServer(nil)

	// Define handlers
	srv.HandleFunc("ping", func(w resp.ResponseWriter, _ *resp.Command) {
		w.AppendInlineString("PONG")
	})
	srv.HandleFunc("info", func(w resp.ResponseWriter, _ *resp.Command) {
		w.AppendBulkString(srv.Info().String())
	})

	// More handlers; demo usage of redeo.WrapperFunc
	srv.Handle("echo", redeo.WrapperFunc(func(c *resp.Command) interface{} {
		if c.ArgN() != 1 {
			return redeo.ErrWrongNumberOfArgs(c.Name)
		}
		return c.Arg(0)
	}))

	// Open a new listener
	lis, err := net.Listen("tcp", ":9736")
	if err != nil {
		panic(err)
	}
	defer lis.Close()

	// Start serving (blocking)
	srv.Serve(lis)
}
```

More complex handlers:

```go
func main() {
	mu := sync.RWMutex{}
	data := make(map[string]string)
	srv := redeo.NewServer(nil)

	srv.HandleFunc("set", func(w resp.ResponseWriter, c *resp.Command) {
		if c.ArgN() != 2 {
			w.AppendError(redeo.WrongNumberOfArgs(c.Name))
			return
		}

		key := c.Arg(0).String()
		val := c.Arg(1).String()

		mu.Lock()
		data[key] = val
		mu.Unlock()

		w.AppendInt(1)
	})

	srv.HandleFunc("get", func(w resp.ResponseWriter, c *resp.Command) {
		if c.ArgN() != 1 {
			w.AppendError(redeo.WrongNumberOfArgs(c.Name))
			return
		}

		key := c.Arg(0).String()
		mu.RLock()
		val, ok := data[key]
		mu.RUnlock()

		if ok {
			w.AppendBulkString(val)
			return
		}
		w.AppendNil()
	})
}
```

Redeo also supports command wrappers:

```go
func main() {
	mu := sync.RWMutex{}
	data := make(map[string]string)
	srv := redeo.NewServer(nil)

	srv.Handle("set", redeo.WrapperFunc(func(c *resp.Command) interface{} {
		if c.ArgN() != 2 {
			return redeo.ErrWrongNumberOfArgs(c.Name)
		}

		key := c.Arg(0).String()
		val := c.Arg(1).String()

		mu.Lock()
		data[key] = val
		mu.Unlock()

		return 1
	}))

	srv.Handle("get", redeo.WrapperFunc(func(c *resp.Command) interface{} {
		if c.ArgN() != 1 {
			return redeo.ErrWrongNumberOfArgs(c.Name)
		}

		key := c.Arg(0).String()
		mu.RLock()
		val, ok := data[key]
		mu.RUnlock()

		if ok {
			return val
		}
		return nil
	}))
}
```


redeo

go-couchbase

memcache client library for the Go programming language

## About

This is a memcache client library for the Go programming language
(http://golang.org/).

## Example

Install with:

```shell
$ go get github.com/bradfitz/gomemcache/memcache
```

Then use it like:

```go
import (
    "github.com/bradfitz/gomemcache/memcache"
)

func main() {
     mc := memcache.New("10.0.0.1:11211", "10.0.0.2:11211", "10.0.0.3:11212")
     mc.Set(&memcache.Item{Key: "foo", Value: []byte("my value")})

     it, err := mc.Get("foo")
     ...
}
```

## Full docs, see:

See https://pkg.go.dev/github.com/bradfitz/gomemcache/memcache

Or run:

```shell
$ godoc github.com/bradfitz/gomemcache/memcache
```



gomemcache

(unmaintained) MongoDB driver for the Go language that implements a rich and well tested selection of features under a very simple API following standard Go idioms

[![Build Status](https://travis-ci.org/globalsign/mgo.svg?branch=master)](https://travis-ci.org/globalsign/mgo) [![GoDoc](https://godoc.org/github.com/globalsign/mgo?status.svg)](https://godoc.org/github.com/globalsign/mgo)

The MongoDB driver for Go
-------------------------

This fork has had a few improvements by ourselves as well as several PR's merged from the original mgo repo that are currently awaiting review.
Changes are mostly geared towards performance improvements and bug fixes, though a few new features have been added.

Further PR's (with tests) are welcome, but please maintain backwards compatibility.

Detailed documentation of the API is available at
[GoDoc](https://godoc.org/github.com/globalsign/mgo).

A [sub-package](https://godoc.org/github.com/globalsign/mgo/bson) that implements the [BSON](http://bsonspec.org) specification is also included, and may be used independently of the driver.

## Supported Versions

`mgo` is known to work well on (and has integration tests against) MongoDB v3.0, 3.2, 3.4 and 3.6. 

MongoDB 4.0 is currently experimental - we would happily accept PRs to help improve support!

## Changes
* Fixes attempting to authenticate before every query ([details](https://github.com/go-mgo/mgo/issues/254))
* Removes bulk update / delete batch size limitations ([details](https://github.com/go-mgo/mgo/issues/288))
* Adds native support for `time.Duration` marshalling ([details](https://github.com/go-mgo/mgo/pull/373))
* Reduce memory footprint / garbage collection pressure by reusing buffers ([details](https://github.com/go-mgo/mgo/pull/229), [more](https://github.com/globalsign/mgo/pull/56))
* Support majority read concerns ([details](https://github.com/globalsign/mgo/pull/2))
* Improved connection handling ([details](https://github.com/globalsign/mgo/pull/5))
* Hides SASL warnings ([details](https://github.com/globalsign/mgo/pull/7))
* Support for partial indexes ([details](https://github.com/domodwyer/mgo/commit/5efe8eccb028238d93c222828cae4806aeae9f51))
* Fixes timezone handling ([details](https://github.com/go-mgo/mgo/pull/464))
* Integration tests run against MongoDB 3.2 & 3.4 releases ([details](https://github.com/globalsign/mgo/pull/4), [more](https://github.com/globalsign/mgo/pull/24), [more](https://github.com/globalsign/mgo/pull/35))
* Improved multi-document transaction performance ([details](https://github.com/globalsign/mgo/pull/10), [more](https://github.com/globalsign/mgo/pull/11), [more](https://github.com/globalsign/mgo/pull/16))
* Fixes cursor timeouts ([details](https://jira.mongodb.org/browse/SERVER-24899))
* Support index hints and timeouts for count queries ([details](https://github.com/globalsign/mgo/pull/17))
* Don't panic when handling indexed `int64` fields ([details](https://github.com/go-mgo/mgo/issues/475))
* Supports dropping all indexes on a collection ([details](https://github.com/globalsign/mgo/pull/25))
* Annotates log entries/profiler output with optional appName on 3.4+ ([details](https://github.com/globalsign/mgo/pull/28))
* Support for read-only [views](https://docs.mongodb.com/manual/core/views/) in 3.4+ ([details](https://github.com/globalsign/mgo/pull/33))
* Support for [collations](https://docs.mongodb.com/manual/reference/collation/) in 3.4+ ([details](https://github.com/globalsign/mgo/pull/37), [more](https://github.com/globalsign/mgo/pull/166))
* Provide BSON constants for convenience/sanity ([details](https://github.com/globalsign/mgo/pull/41))
* Consistently unmarshal time.Time values as UTC ([details](https://github.com/globalsign/mgo/pull/42))
* Enforces best practise coding guidelines ([details](https://github.com/globalsign/mgo/pull/44))
* GetBSON correctly handles structs with both fields and pointers ([details](https://github.com/globalsign/mgo/pull/40))
* Improved bson.Raw unmarshalling performance ([details](https://github.com/globalsign/mgo/pull/49))
* Minimise socket connection timeouts due to excessive locking ([details](https://github.com/globalsign/mgo/pull/52))
* Natively support X509 client authentication ([details](https://github.com/globalsign/mgo/pull/55))
* Gracefully recover from a temporarily unreachable server ([details](https://github.com/globalsign/mgo/pull/69))
* Use JSON tags when no explicit BSON are tags set ([details](https://github.com/globalsign/mgo/pull/91))
* Support [$changeStream](https://docs.mongodb.com/manual/changeStreams/) tailing on 3.6+ ([details](https://github.com/globalsign/mgo/pull/97))
* Fix deadlock in cluster synchronisation ([details](https://github.com/globalsign/mgo/issues/120))
* Implement `maxIdleTimeout` for pooled connections ([details](https://github.com/globalsign/mgo/pull/116))
* Connection pool waiting improvements ([details](https://github.com/globalsign/mgo/pull/115))
* Fixes BSON encoding for `$in` and friends ([details](https://github.com/globalsign/mgo/pull/128))
* Add BSON stream encoders ([details](https://github.com/globalsign/mgo/pull/127))
* Add integer map key support in the BSON encoder ([details](https://github.com/globalsign/mgo/pull/140)) 
* Support aggregation [collations](https://docs.mongodb.com/manual/reference/collation/) ([details](https://github.com/globalsign/mgo/pull/144))
* Support encoding of inline struct references ([details](https://github.com/globalsign/mgo/pull/146))
* Improved windows test harness ([details](https://github.com/globalsign/mgo/pull/158))
* Improved type and nil handling in the BSON codec ([details](https://github.com/globalsign/mgo/pull/147/files), [more](https://github.com/globalsign/mgo/pull/181))
* Separated network read/write timeouts ([details](https://github.com/globalsign/mgo/pull/161))
* Expanded dial string configuration options ([details](https://github.com/globalsign/mgo/pull/162))
* Implement MongoTimestamp ([details](https://github.com/globalsign/mgo/pull/171))
* Support setting `writeConcern` for `findAndModify` operations ([details](https://github.com/globalsign/mgo/pull/185))
* Add `ssl` to the dial string options ([details](https://github.com/globalsign/mgo/pull/184))


---

### Thanks to
* @aksentyev
* @bachue
* @bozaro
* @BenLubar
* @carldunham
* @carter2000
* @cedric-cordenier
* @cezarsa
* @DaytonG
* @ddspog
* @drichelson
* @dvic
* @eaglerayp
* @feliixx
* @fmpwizard
* @gazoon
* @gedge
* @gnawux
* @idy
* @jameinel
* @jefferickson
* @johnlawsharrison
* @KJTsanaktsidis
* @larrycinnabar
* @mapete94
* @maxnoel
* @mcspring
* @Mei-Zhao
* @peterdeka
* @Reenjii
* @roobre
* @smoya
* @steve-gray
* @tbruyelle
* @wgallagher


The Best Go Libraries For Database Drivers - NoSQL Database Drivers (28)