README

Build Status Codecov Go Report Card GoDoc Website

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 sql and 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 stable v3 branch of Kivik. For the latest changes, you may be interested in the development branch.

Example configuration for common dependency managers follow.

Go Modules

Kivik 3.x and later depends on Go modules, which requires Go 1.11 or later. If your project does not use modules, and you are unable to switch, you may use Kivik 2.x.

Installation

Install Kivik as you normally would for any Go package:

go get -u github.com/go-kivik/kivik/v3
go get -u github.com/go-kivik/couchdb/v3

This will install the main Kivik package and the CouchDB database driver. See the list of Kivik database drivers for a complete list of available drivers.

Example Usage

Please consult the the package documentation for all available API methods, and a complete usage documentation. And for additional usage examples, consult the wiki.

package main

import (
    "context"
    "fmt"

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

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

    db, err := client.DB(context.TODO(), "animals")
    if err != nil {
        panic(err)
    }

    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?

Read the design goals for the general design goals.

Specifically, I was motivated to write Kivik for a few reasons:

  1. I was unhappy with any of the existing CouchDB drivers for Go. The best one had a number of shortcomings:

    • It is no longer actively developed.
    • It doesn't have an open source license.
    • It doesn't support iterating over result sets, forcing one to load all results of a query into memory at once.
    • It doesn't support CouchDB 2.0 sequence IDs or MongoDB-style queries.
    • It doesn't natively support CookieAuth (it does allow a generic Auth method which could be used to do this, but I think it's appropriate to put directly in the library).
  2. I wanted a single client API that worked with both CouchDB and PouchDB. I had previously written go-pouchdb, a GopherJS wrapper around the PouchDB library with a public API modeled after fjl/go-couchdb, but I still wanted a unified driver infrastructure.

  3. I want an unambiguous, open source license. This software is released under the Apache 2.0 license. See the included LICENSE.md file for details.

  4. I wanted the ability to mock CouchDB connections for testing. This is possible with the sql / sql/driver approach by implementing a mock driver, but was not possible with any existing CouchDB client libraries. This library makes that possible for CouchDB apps, too.

  5. I wanted a simple, mock CouchDB server I could use for testing. It doesn't need to be efficient, or support all CouchDB servers, but it should be enough to test the basic functionality of a PouchDB app, for instance. Kivik aims to do this with the kivik serve command, in the near future.

  6. I wanted a toolkit that would make it easy to build a proxy to sit in front of CouchDB to handle custom authentication or other logic that CouchDB cannot support natively. Kivik aims to accomplish this in the future.

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 3.x aims for full compatibility with all stable releases of Go from 1.9. For Go 1.7 or 1.8 you can use Kivik 1.x
  • CouchDB The Kivik 3.x CouchDB driver aims for compatibility with all stable releases of CouchDB from 1.6.1.
  • GopherJS GopherJS always requires the latest stable version of Go, so building Kivik with GopherJS has this same requirement.
  • PouchDB The Kivik 3.x PouchDB driver aims for compatibility with all stable releases of PouchDB from 6.0.0.

What is the development status?

Kivik 3.x is considered production-ready and comes with a complete client API client and backend drivers for CouchDB and PouchDB.

Future goals are to flesh out the Memory driver, which will make automated testing without a real CouchDB server easier. Then I will work on completing the 'serve' mode.

You can see a complete overview of the current status on the Compatibility chart

Why the name "Kivik"?

Kivik 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?

This software is released under the terms of the Apache 2.0 license. See LICENCE.md, or read the full license.

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 is an open-source graph database. It uses Kivik for the CouchDB and PouchDB storage backends.
Expand ▾ Collapse ▴

Documentation

Overview

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

    The kivik package must be used in conjunction with a database driver. See https://github.com/go-kivik/kivik/wiki/Kivik-database-drivers for a list.

    The kivik driver system is modeled after the standard library's sql and 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.

    Index

    Constants

    View Source
    const (
    	// KivikVersion is the version of the Kivik library.
    	KivikVersion = "3.0.0"
    	// KivikVendor is the vendor string reported by this library.
    	KivikVendor = "Kivik"
    )
    View Source
    const EndKeySuffix = string(0xfff0)

      EndKeySuffix is a high Unicode character (0xfff0) useful for appending to an endkey argument, when doing a ranged search, as described here: http://couchdb.readthedocs.io/en/latest/ddocs/views/collation.html#string-ranges

      Example, to return all results with keys beginning with "foo":

      rows, err := db.Query(context.TODO(), "ddoc", "view", map[string]interface{}{
          "startkey": "foo",
          "endkey":   "foo" + kivik.EndKeySuffix,
      })
      
      View Source
      const SessionCookieName = "AuthSession"

        SessionCookieName is the name of the CouchDB session cookie.

        View Source
        const UserPrefix = "org.couchdb.user:"

          UserPrefix is the mandatory CouchDB user prefix. See http://docs.couchdb.org/en/2.0.0/intro/security.html#org-couchdb-user

          Variables

          This section is empty.

          Functions

          func Register

          func Register(name string, driver driver.Driver)

            Register makes a database driver available by the provided name. If Register is called twice with the same name or if driver is nil, it panics.

            func StatusCode

            func StatusCode(err error) int

              StatusCode returns the HTTP status code embedded in the error, or 500 (internal server error), if there was no specified status code. If err is nil, StatusCode returns 0. This provides a convenient way to determine the precise nature of a Kivik-returned error.

              For example, to panic for all but NotFound errors:

              err := db.Get(context.TODO(), "docID").ScanDoc(&doc)
              if kivik.StatusCode(err) == kivik.StatusNotFound {
                  return
              }
              if err != nil {
                  panic(err)
              }
              

              This method uses the statusCoder interface, which is not exported by this package, but is considered part of the stable public API. Driver implementations are expected to return errors which conform to this interface.

              type statusCoder interface {
                  StatusCode() (httpStatusCode int)
              }
              

              Types

              type Attachment

              type Attachment struct {
              	// Filename is the name of the attachment.
              	Filename string `json:"-"`
              
              	// ContentType is the MIME type of the attachment contents.
              	ContentType string `json:"content_type"`
              
              	// Stub will be true if the data structure only represents file metadata,
              	// and contains no actual content. Stub will be true when returned by the
              	// GetAttachmentMeta function, or when included in a document without the
              	// 'include_docs' option.
              	Stub bool `json:"stub"`
              
              	// Follows will be true when reading attachments in multipart/related
              	// format.
              	Follows bool `json:"follows"`
              
              	// Content represents the attachment's content.
              	//
              	// Kivik will always return a non-nil Content, even for 0-byte attachments
              	// or when Stub is true. It is the caller's responsibility to close
              	// Content.
              	Content io.ReadCloser `json:"-"`
              
              	// Size records the uncompressed size of the attachment. The value -1
              	// indicates that the length is unknown. Unless Stub is true, values >= 0
              	// indicate that the given number of bytes may be read from Content.
              	Size int64 `json:"length"`
              
              	// Used compression codec, if any. Will be the empty string if the
              	// attachment is uncompressed.
              	ContentEncoding string `json:"encoding"`
              
              	// EncodedLength records the compressed attachment size in bytes. Only
              	// meaningful when ContentEncoding is defined.
              	EncodedLength int64 `json:"encoded_length"`
              
              	// RevPos is the revision number when attachment was added.
              	RevPos int64 `json:"revpos"`
              
              	// Digest is the content hash digest.
              	Digest string `json:"digest"`
              }

                Attachment represents a file attachment on a CouchDB document.

                func (*Attachment) MarshalJSON

                func (a *Attachment) MarshalJSON() ([]byte, error)

                  MarshalJSON satisfies the json.Marshaler interface.

                  func (*Attachment) UnmarshalJSON

                  func (a *Attachment) UnmarshalJSON(data []byte) error

                    UnmarshalJSON implements the json.Unmarshaler interface for an Attachment.

                    type Attachments

                    type Attachments map[string]*Attachment

                      Attachments is a collection of one or more file attachments.

                      func (*Attachments) Delete

                      func (a *Attachments) Delete(filename string)

                        Delete removes the specified file from the collection.

                        func (*Attachments) Get

                        func (a *Attachments) Get(filename string) *Attachment

                          Get fetches the requested attachment, or returns nil if it does not exist.

                          func (*Attachments) Set

                          func (a *Attachments) Set(filename string, att *Attachment)

                            Set sets the attachment associated with filename in the collection, replacing it if it already existed.

                            func (*Attachments) UnmarshalJSON

                            func (a *Attachments) UnmarshalJSON(data []byte) error

                              UnmarshalJSON implements the json.Unmarshaler interface for a collection of Attachments.

                              type AttachmentsIterator

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

                                AttachmentsIterator is an experimental way to read streamed attachments from a multi-part Get request.

                                func (*AttachmentsIterator) Next

                                func (i *AttachmentsIterator) Next() (*Attachment, error)

                                  Next returns the next attachment in the stream. io.EOF will be returned when there are no more attachments.

                                  type BulkGetReference

                                  type BulkGetReference struct {
                                  	ID        string `json:"id"`
                                  	Rev       string `json:"rev,omitempty"`
                                  	AttsSince string `json:"atts_since,omitempty"`
                                  }

                                    BulkGetReference is a reference to a document given in a BulkGet query.

                                    type BulkResults

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

                                      BulkResults is an iterator over the results of a BulkDocs query.

                                      func (*BulkResults) Close

                                      func (r *BulkResults) Close() error

                                        Close closes the feed. Any unread updates will still be accessible via Next().

                                        func (*BulkResults) Err

                                        func (r *BulkResults) Err() error

                                          Err returns the error, if any, that was encountered during iteration. Err may be called after an explicit or implicit Close.

                                          func (*BulkResults) ID

                                          func (r *BulkResults) ID() string

                                            ID returns the document ID name for the current result.

                                            func (*BulkResults) Next

                                            func (r *BulkResults) Next() bool

                                              Next returns the next BulkResult from the feed. If an error occurs, it will be returned and the feed closed. io.EOF will be returned when there are no more results.

                                              func (*BulkResults) Rev

                                              func (r *BulkResults) Rev() string

                                                Rev returns the revision of the current curResult.

                                                func (*BulkResults) UpdateErr

                                                func (r *BulkResults) UpdateErr() error

                                                  UpdateErr returns the error associated with the current result, or nil if none. Do not confuse this with Err, which returns an error for the iterator itself.

                                                  type Changes

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

                                                    Changes is an iterator over the database changes feed.

                                                    func (*Changes) Changes

                                                    func (c *Changes) Changes() []string

                                                      Changes returns a list of changed revs.

                                                      func (*Changes) Close

                                                      func (c *Changes) Close() error

                                                        Close closes the Changes feed, preventing further enumeration, and freeing any resources (such as the http request body) of the underlying query. If Next is called and there are no further results, Changes is closed automatically and it will suffice to check the result of Err. Close is idempotent and does not affect the result of Err.

                                                        func (*Changes) Deleted

                                                        func (c *Changes) Deleted() bool

                                                          Deleted returns true if the change relates to a deleted document.

                                                          func (*Changes) ETag

                                                          func (c *Changes) ETag() string

                                                            ETag returns the unquoted ETag header, if any. Unlike LastSeq and Pending, because this value is returned in the response header (for standard CouchDB operation) anyway, it can be read immediately, before iteration even begins.

                                                            func (*Changes) Err

                                                            func (c *Changes) Err() error

                                                              Err returns the error, if any, that was encountered during iteration. Err may be called after an explicit or implicit Close.

                                                              func (*Changes) ID

                                                              func (c *Changes) ID() string

                                                                ID returns the ID of the current result.

                                                                func (*Changes) LastSeq

                                                                func (c *Changes) LastSeq() string

                                                                  LastSeq returns the last update sequence id present in the change set, if returned by the server. This value is only guaranteed to be set after all changes have been enumerated through by Next, thus should only be read after processing all changes in a change set. Calling Close before enumerating will render this value unreliable.

                                                                  func (*Changes) Next

                                                                  func (c *Changes) Next() bool

                                                                    Next prepares the next result value for reading. It returns true on success or false if there are no more results, due to an error or the changes feed having been closed. Err should be consulted to determine any error.

                                                                    func (*Changes) Pending

                                                                    func (c *Changes) Pending() int64

                                                                      Pending returns the count of remaining items in the change feed. This value is only guaranteed to be set after all changes have been enumerated through by Next, thus should only be read after processing all changes in a change set. Calling Close before enumerating will render this value unreliable.

                                                                      func (*Changes) ScanDoc

                                                                      func (c *Changes) ScanDoc(dest interface{}) error

                                                                        ScanDoc works the same as ScanValue, but on the doc field of the result. It is only valid for results that include documents.

                                                                        func (*Changes) Seq

                                                                        func (c *Changes) Seq() string

                                                                          Seq returns the Seq of the current result.

                                                                          type Client

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

                                                                            Client is a client connection handle to a CouchDB-like server.

                                                                            func New

                                                                            func New(driverName, dataSourceName string) (*Client, error)

                                                                              New creates a new client object specified by its database driver name and a driver-specific data source name.

                                                                              func (*Client) AllDBs

                                                                              func (c *Client) AllDBs(ctx context.Context, options ...Options) ([]string, error)

                                                                                AllDBs returns a list of all databases.

                                                                                func (*Client) Authenticate

                                                                                func (c *Client) Authenticate(ctx context.Context, a interface{}) error

                                                                                  Authenticate authenticates the client with the passed authenticator, which is driver-specific. If the driver does not understand the authenticator, an error will be returned.

                                                                                  func (*Client) Close

                                                                                  func (c *Client) Close(ctx context.Context) error

                                                                                    Close cleans up any resources used by Client.

                                                                                    func (*Client) ClusterSetup

                                                                                    func (c *Client) ClusterSetup(ctx context.Context, action interface{}) error

                                                                                      ClusterSetup performs the requested cluster action. action should be an object understood by the driver. For the CouchDB driver, this means an object which is marshalable to a JSON object of the expected format.

                                                                                      See http://docs.couchdb.org/en/stable/api/server/common.html#post--_cluster_setup

                                                                                      func (*Client) ClusterStatus

                                                                                      func (c *Client) ClusterStatus(ctx context.Context, options ...Options) (string, error)

                                                                                        ClusterStatus returns the current cluster status.

                                                                                        See http://docs.couchdb.org/en/stable/api/server/common.html#cluster-setup

                                                                                        func (*Client) Config

                                                                                        func (c *Client) Config(ctx context.Context, node string) (Config, error)

                                                                                          Config returns the entire server config, for the specified node.

                                                                                          See http://docs.couchdb.org/en/stable/api/server/configuration.html#get--_node-node-name-_config

                                                                                          func (*Client) ConfigSection

                                                                                          func (c *Client) ConfigSection(ctx context.Context, node, section string) (ConfigSection, error)

                                                                                            ConfigSection returns the requested section of the server config for the specified node.

                                                                                            See http://docs.couchdb.org/en/stable/api/server/configuration.html#node-node-name-config-section

                                                                                            func (*Client) ConfigValue

                                                                                            func (c *Client) ConfigValue(ctx context.Context, node, section, key string) (string, error)

                                                                                              ConfigValue returns a single config value for the specified node.

                                                                                              See http://docs.couchdb.org/en/stable/api/server/configuration.html#get--_node-node-name-_config-section-key

                                                                                              func (*Client) CreateDB

                                                                                              func (c *Client) CreateDB(ctx context.Context, dbName string, options ...Options) error

                                                                                                CreateDB creates a DB of the requested name. Any errors are deferred, or may be checked with Err().

                                                                                                func (*Client) DB

                                                                                                func (c *Client) DB(ctx context.Context, dbName string, options ...Options) *DB

                                                                                                  DB returns a handle to the requested database. Any options parameters passed are merged, with later values taking precidence. If any errors occur at this stage, they are deferred, or may be checked directly with Err()

                                                                                                  func (*Client) DBExists

                                                                                                  func (c *Client) DBExists(ctx context.Context, dbName string, options ...Options) (bool, error)

                                                                                                    DBExists returns true if the specified database exists.

                                                                                                    func (*Client) DBUpdates

                                                                                                    func (c *Client) DBUpdates(ctx context.Context) (*DBUpdates, error)

                                                                                                      DBUpdates begins polling for database updates.

                                                                                                      func (*Client) DBsStats

                                                                                                      func (c *Client) DBsStats(ctx context.Context, dbnames []string) ([]*DBStats, error)

                                                                                                        DBsStats returns database statistics about one or more databases.

                                                                                                        func (*Client) DSN

                                                                                                        func (c *Client) DSN() string

                                                                                                          DSN returns the data source name used to connect this client.

                                                                                                          func (*Client) DeleteConfigKey

                                                                                                          func (c *Client) DeleteConfigKey(ctx context.Context, node, section, key string) (string, error)

                                                                                                            DeleteConfigKey deletes the configuration key and associated value from the specified node. It returns the old value.

                                                                                                            See http://docs.couchdb.org/en/stable/api/server/configuration.html#delete--_node-node-name-_config-section-key

                                                                                                            func (*Client) DestroyDB

                                                                                                            func (c *Client) DestroyDB(ctx context.Context, dbName string, options ...Options) error

                                                                                                              DestroyDB deletes the requested DB.

                                                                                                              func (*Client) Driver

                                                                                                              func (c *Client) Driver() string

                                                                                                                Driver returns the name of the driver string used to connect this client.

                                                                                                                func (*Client) GetReplications

                                                                                                                func (c *Client) GetReplications(ctx context.Context, options ...Options) ([]*Replication, error)

                                                                                                                  GetReplications returns a list of defined replications in the _replicator database. Options are in the same format as to AllDocs(), except that "conflicts" and "update_seq" are ignored.

                                                                                                                  func (*Client) Ping

                                                                                                                  func (c *Client) Ping(ctx context.Context) (bool, error)

                                                                                                                    Ping returns true if the database is online and available for requests, for instance by querying the /_up endpoint. If the underlying driver supports the Pinger interface, it will be used. Otherwise, a fallback is made to calling Version.

                                                                                                                    func (*Client) Replicate

                                                                                                                    func (c *Client) Replicate(ctx context.Context, targetDSN, sourceDSN string, options ...Options) (*Replication, error)

                                                                                                                      Replicate initiates a replication from source to target.

                                                                                                                      func (*Client) Session

                                                                                                                      func (c *Client) Session(ctx context.Context) (*Session, error)

                                                                                                                        Session returns information about the currently authenticated user.

                                                                                                                        func (*Client) SetConfigValue

                                                                                                                        func (c *Client) SetConfigValue(ctx context.Context, node, section, key, value string) (string, error)

                                                                                                                          SetConfigValue sets the server's config value on the specified node, creating the key if it doesn't exist. It returns the old value.

                                                                                                                          See http://docs.couchdb.org/en/stable/api/server/configuration.html#put--_node-node-name-_config-section-key

                                                                                                                          func (*Client) Version

                                                                                                                          func (c *Client) Version(ctx context.Context) (*Version, error)

                                                                                                                            Version returns version and vendor info about the backend.

                                                                                                                            type ClusterConfig

                                                                                                                            type ClusterConfig struct {
                                                                                                                            	Replicas    int `json:"n"`
                                                                                                                            	Shards      int `json:"q"`
                                                                                                                            	ReadQuorum  int `json:"r"`
                                                                                                                            	WriteQuorum int `json:"w"`
                                                                                                                            }

                                                                                                                              ClusterConfig contains the cluster configuration for the database.

                                                                                                                              type Config

                                                                                                                              type Config map[string]ConfigSection

                                                                                                                                Config represents all the config sections.

                                                                                                                                Note that the Config struct, and all of the config-related methods are considered experimental, and may change in the future.

                                                                                                                                type ConfigSection

                                                                                                                                type ConfigSection map[string]string

                                                                                                                                  ConfigSection represents all key/value pairs for a section of configuration.

                                                                                                                                  type DB

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

                                                                                                                                    DB is a handle to a specific database.

                                                                                                                                    func (*DB) AllDocs

                                                                                                                                    func (db *DB) AllDocs(ctx context.Context, options ...Options) (*Rows, error)

                                                                                                                                      AllDocs returns a list of all documents in the database.

                                                                                                                                      func (*DB) BulkDocs

                                                                                                                                      func (db *DB) BulkDocs(ctx context.Context, docs []interface{}, options ...Options) (*BulkResults, error)

                                                                                                                                        BulkDocs allows you to create and update multiple documents at the same time within a single request. This function returns an iterator over the results of the bulk operation. See http://docs.couchdb.org/en/2.0.0/api/database/bulk-api.html#db-bulk-docs

                                                                                                                                        As with Put, each individual document may be a JSON-marshable object, or a raw JSON string in a []byte, json.RawMessage, or io.Reader.

                                                                                                                                        func (*DB) BulkGet

                                                                                                                                        func (db *DB) BulkGet(ctx context.Context, docs []BulkGetReference, options ...Options) (*Rows, error)

                                                                                                                                          BulkGet can be called to query several documents in bulk. It is well suited for fetching a specific revision of documents, as replicators do for example, or for getting revision history.

                                                                                                                                          See http://docs.couchdb.org/en/stable/api/database/bulk-api.html#db-bulk-get

                                                                                                                                          func (*DB) Changes

                                                                                                                                          func (db *DB) Changes(ctx context.Context, options ...Options) (*Changes, error)

                                                                                                                                            Changes returns an iterator over the real-time changes feed. The feed remains open until explicitly closed, or an error is encountered. See http://couchdb.readthedocs.io/en/latest/api/database/changes.html#get--db-_changes

                                                                                                                                            func (*DB) Client

                                                                                                                                            func (db *DB) Client() *Client

                                                                                                                                              Client returns the Client used to connect to the database.

                                                                                                                                              func (*DB) Close

                                                                                                                                              func (db *DB) Close(ctx context.Context) error

                                                                                                                                                Close cleans up any resources used by the DB. The default CouchDB driver does not use this, the default PouchDB driver does.

                                                                                                                                                func (*DB) Compact

                                                                                                                                                func (db *DB) Compact(ctx context.Context) error

                                                                                                                                                  Compact begins compaction of the database. Check the CompactRunning field returned by Info() to see if the compaction has completed. See http://docs.couchdb.org/en/2.0.0/api/database/compact.html#db-compact

                                                                                                                                                  This method may return immediately, or may wait for the compaction to complete before returning, depending on the backend implementation. In particular, CouchDB triggers the compaction and returns immediately, whereas PouchDB waits until compaction has completed, before returning.

                                                                                                                                                  func (*DB) CompactView

                                                                                                                                                  func (db *DB) CompactView(ctx context.Context, ddocID string) error

                                                                                                                                                    CompactView compats the view indexes associated with the specified design document. See http://docs.couchdb.org/en/2.0.0/api/database/compact.html#db-compact-design-doc

                                                                                                                                                    This method may return immediately, or may wait for the compaction to complete before returning, depending on the backend implementation. In particular, CouchDB triggers the compaction and returns immediately, whereas PouchDB waits until compaction has completed, before returning.

                                                                                                                                                    func (*DB) Copy

                                                                                                                                                    func (db *DB) Copy(ctx context.Context, targetID, sourceID string, options ...Options) (targetRev string, err error)

                                                                                                                                                      Copy copies the source document to a new document with an ID of targetID. If the database backend does not support COPY directly, the operation will be emulated with a Get followed by Put. The target will be an exact copy of the source, with only the ID and revision changed.

                                                                                                                                                      See http://docs.couchdb.org/en/2.0.0/api/document/common.html#copy--db-docid

                                                                                                                                                      func (*DB) CreateDoc

                                                                                                                                                      func (db *DB) CreateDoc(ctx context.Context, doc interface{}, options ...Options) (docID, rev string, err error)

                                                                                                                                                        CreateDoc creates a new doc with an auto-generated unique ID. The generated docID and new rev are returned.

                                                                                                                                                        func (*DB) CreateIndex

                                                                                                                                                        func (db *DB) CreateIndex(ctx context.Context, ddoc, name string, index interface{}) error

                                                                                                                                                          CreateIndex creates an index if it doesn't already exist. ddoc and name may be empty, in which case they will be auto-generated. index must be a valid index object, as described here: http://docs.couchdb.org/en/stable/api/database/find.html#db-index

                                                                                                                                                          func (*DB) Delete

                                                                                                                                                          func (db *DB) Delete(ctx context.Context, docID, rev string, options ...Options) (newRev string, err error)

                                                                                                                                                            Delete marks the specified document as deleted.

                                                                                                                                                            func (*DB) DeleteAttachment

                                                                                                                                                            func (db *DB) DeleteAttachment(ctx context.Context, docID, rev, filename string, options ...Options) (newRev string, err error)

                                                                                                                                                              DeleteAttachment deletes an attachment from a document, returning the document's new revision.

                                                                                                                                                              func (*DB) DeleteIndex

                                                                                                                                                              func (db *DB) DeleteIndex(ctx context.Context, ddoc, name string) error

                                                                                                                                                                DeleteIndex deletes the requested index.

                                                                                                                                                                func (*DB) DesignDocs

                                                                                                                                                                func (db *DB) DesignDocs(ctx context.Context, options ...Options) (*Rows, error)

                                                                                                                                                                  DesignDocs returns a list of all documents in the database.

                                                                                                                                                                  func (*DB) Err

                                                                                                                                                                  func (db *DB) Err() error

                                                                                                                                                                    Err returns the error, if any, that occurred while connecting to or creating the database. This error will be deferred until the next call, normally, so using this method is only ever necessary if you need to directly check the error status, and intend to do nothing else with the DB object.

                                                                                                                                                                    func (*DB) Explain

                                                                                                                                                                    func (db *DB) Explain(ctx context.Context, query interface{}) (*QueryPlan, error)

                                                                                                                                                                      Explain returns the query plan for a given query. Explain takes the same arguments as Find.

                                                                                                                                                                      func (*DB) Find

                                                                                                                                                                      func (db *DB) Find(ctx context.Context, query interface{}) (*Rows, error)

                                                                                                                                                                        Find executes a query using the new /_find interface. The query must be JSON-marshalable to a valid query. See http://docs.couchdb.org/en/2.0.0/api/database/find.html#db-find

                                                                                                                                                                        func (*DB) Flush

                                                                                                                                                                        func (db *DB) Flush(ctx context.Context) error

                                                                                                                                                                          Flush requests a flush of disk cache to disk or other permanent storage.

                                                                                                                                                                          See http://docs.couchdb.org/en/2.0.0/api/database/compact.html#db-ensure-full-commit

                                                                                                                                                                          func (*DB) Get

                                                                                                                                                                          func (db *DB) Get(ctx context.Context, docID string, options ...Options) *Row

                                                                                                                                                                            Get fetches the requested document. Any errors are deferred until the row.ScanDoc call.

                                                                                                                                                                            func (*DB) GetAttachment

                                                                                                                                                                            func (db *DB) GetAttachment(ctx context.Context, docID, filename string, options ...Options) (*Attachment, error)

                                                                                                                                                                              GetAttachment returns a file attachment associated with the document.

                                                                                                                                                                              func (*DB) GetAttachmentMeta

                                                                                                                                                                              func (db *DB) GetAttachmentMeta(ctx context.Context, docID, filename string, options ...Options) (*Attachment, error)

                                                                                                                                                                                GetAttachmentMeta returns meta data about an attachment. The attachment content returned will be empty.

                                                                                                                                                                                func (*DB) GetIndexes

                                                                                                                                                                                func (db *DB) GetIndexes(ctx context.Context) ([]Index, error)

                                                                                                                                                                                  GetIndexes returns the indexes defined on the current database.

                                                                                                                                                                                  func (*DB) GetMeta

                                                                                                                                                                                  func (db *DB) GetMeta(ctx context.Context, docID string, options ...Options) (size int64, rev string, err error)

                                                                                                                                                                                    GetMeta returns the size and rev of the specified document. GetMeta accepts the same options as the Get method.

                                                                                                                                                                                    func (*DB) LocalDocs

                                                                                                                                                                                    func (db *DB) LocalDocs(ctx context.Context, options ...Options) (*Rows, error)

                                                                                                                                                                                      LocalDocs returns a list of all documents in the database.

                                                                                                                                                                                      func (*DB) Name

                                                                                                                                                                                      func (db *DB) Name() string

                                                                                                                                                                                        Name returns the database name as passed when creating the DB connection.

                                                                                                                                                                                        func (*DB) Purge

                                                                                                                                                                                        func (db *DB) Purge(ctx context.Context, docRevMap map[string][]string) (*PurgeResult, error)

                                                                                                                                                                                          Purge permanently removes the reference to deleted documents from the database. Normal deletion only marks the document with the key/value pair `_deleted=true`, to ensure proper replication of deleted documents. By using Purge, the document can be completely removed. But note that this operation is not replication safe, so great care must be taken when using Purge, and this should only be used as a last resort.

                                                                                                                                                                                          Purge expects as input a map with document ID as key, and slice of revisions as value.

                                                                                                                                                                                          func (*DB) Put

                                                                                                                                                                                          func (db *DB) Put(ctx context.Context, docID string, doc interface{}, options ...Options) (rev string, err error)

                                                                                                                                                                                            Put creates a new doc or updates an existing one, with the specified docID. If the document already exists, the current revision must be included in doc, with JSON key '_rev', otherwise a conflict will occur. The new rev is returned.

                                                                                                                                                                                            doc may be one of:

                                                                                                                                                                                            - An object to be marshaled to JSON. The resulting JSON structure must
                                                                                                                                                                                              conform to CouchDB standards.
                                                                                                                                                                                            - A []byte value, containing a valid JSON document
                                                                                                                                                                                            - A json.RawMessage value containing a valid JSON document
                                                                                                                                                                                            - An io.Reader, from which a valid JSON document may be read.
                                                                                                                                                                                            

                                                                                                                                                                                            func (*DB) PutAttachment

                                                                                                                                                                                            func (db *DB) PutAttachment(ctx context.Context, docID, rev string, att *Attachment, options ...Options) (newRev string, err error)

                                                                                                                                                                                              PutAttachment uploads the supplied content as an attachment to the specified document.

                                                                                                                                                                                              func (*DB) Query

                                                                                                                                                                                              func (db *DB) Query(ctx context.Context, ddoc, view string, options ...Options) (*Rows, error)

                                                                                                                                                                                                Query executes the specified view function from the specified design document. ddoc and view may or may not be be prefixed with '_design/' and '_view/' respectively. No other

                                                                                                                                                                                                func (*DB) RevsDiff

                                                                                                                                                                                                func (db *DB) RevsDiff(ctx context.Context, revMap interface{}) (*Rows, error)

                                                                                                                                                                                                  RevsDiff the subset of document/revision IDs that do not correspond to revisions stored in the database. This is used by the replication protocol, and is normally never needed otherwise. revMap must marshal to the expected format.

                                                                                                                                                                                                  Use ID() to return the current document ID, and ScanValue to access the full JSON value, which should be of the JSON format:

                                                                                                                                                                                                  {
                                                                                                                                                                                                      "missing": ["rev1",...],
                                                                                                                                                                                                      "possible_ancestors": ["revA",...]
                                                                                                                                                                                                  }
                                                                                                                                                                                                  

                                                                                                                                                                                                  See http://docs.couchdb.org/en/stable/api/database/misc.html#db-revs-diff

                                                                                                                                                                                                  func (*DB) Security

                                                                                                                                                                                                  func (db *DB) Security(ctx context.Context) (*Security, error)

                                                                                                                                                                                                    Security returns the database's security document. See http://couchdb.readthedocs.io/en/latest/api/database/security.html#get--db-_security

                                                                                                                                                                                                    func (*DB) SetSecurity

                                                                                                                                                                                                    func (db *DB) SetSecurity(ctx context.Context, security *Security) error

                                                                                                                                                                                                      SetSecurity sets the database's security document. See http://couchdb.readthedocs.io/en/latest/api/database/security.html#put--db-_security

                                                                                                                                                                                                      func (*DB) Stats

                                                                                                                                                                                                      func (db *DB) Stats(ctx context.Context) (*DBStats, error)

                                                                                                                                                                                                        Stats returns database statistics.

                                                                                                                                                                                                        func (*DB) ViewCleanup

                                                                                                                                                                                                        func (db *DB) ViewCleanup(ctx context.Context) error

                                                                                                                                                                                                          ViewCleanup removes view index files that are no longer required as a result of changed views within design documents. See http://docs.couchdb.org/en/2.0.0/api/database/compact.html#db-view-cleanup

                                                                                                                                                                                                          type DBStats

                                                                                                                                                                                                          type DBStats struct {
                                                                                                                                                                                                          	// Name is the name of the database.
                                                                                                                                                                                                          	Name string `json:"db_name"`
                                                                                                                                                                                                          	// CompactRunning is true if the database is currently being compacted.
                                                                                                                                                                                                          	CompactRunning bool `json:"compact_running"`
                                                                                                                                                                                                          	// DocCount is the number of documents are currently stored in the database.
                                                                                                                                                                                                          	DocCount int64 `json:"doc_count"`
                                                                                                                                                                                                          	// DeletedCount is a count of documents which have been deleted from the
                                                                                                                                                                                                          	// database.
                                                                                                                                                                                                          	DeletedCount int64 `json:"doc_del_count"`
                                                                                                                                                                                                          	// UpdateSeq is the current update sequence for the database.
                                                                                                                                                                                                          	UpdateSeq string `json:"update_seq"`
                                                                                                                                                                                                          	// DiskSize is the number of bytes used on-disk to store the database.
                                                                                                                                                                                                          	DiskSize int64 `json:"disk_size"`
                                                                                                                                                                                                          	// ActiveSize is the number of bytes used on-disk to store active documents.
                                                                                                                                                                                                          	// If this number is lower than DiskSize, then compaction would free disk
                                                                                                                                                                                                          	// space.
                                                                                                                                                                                                          	ActiveSize int64 `json:"data_size"`
                                                                                                                                                                                                          	// ExternalSize is the size of the documents in the database, as represented
                                                                                                                                                                                                          	// as JSON, before compression.
                                                                                                                                                                                                          	ExternalSize int64 `json:"-"`
                                                                                                                                                                                                          	// Cluster reports the cluster replication configuration variables.
                                                                                                                                                                                                          	Cluster *ClusterConfig `json:"cluster,omitempty"`
                                                                                                                                                                                                          	// RawResponse is the raw response body returned by the server, useful if
                                                                                                                                                                                                          	// you need additional backend-specific information.
                                                                                                                                                                                                          	//
                                                                                                                                                                                                          	// For the format of this document, see
                                                                                                                                                                                                          	// http://docs.couchdb.org/en/2.1.1/api/database/common.html#get--db
                                                                                                                                                                                                          	RawResponse json.RawMessage `json:"-"`
                                                                                                                                                                                                          }

                                                                                                                                                                                                            DBStats contains database statistics..

                                                                                                                                                                                                            type DBUpdates

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

                                                                                                                                                                                                              DBUpdates provides access to database updates.

                                                                                                                                                                                                              func (*DBUpdates) Close

                                                                                                                                                                                                              func (f *DBUpdates) Close() error

                                                                                                                                                                                                                Close closes the feed. Any unread updates will still be accessible via Next().

                                                                                                                                                                                                                func (*DBUpdates) DBName

                                                                                                                                                                                                                func (f *DBUpdates) DBName() string

                                                                                                                                                                                                                  DBName returns the database name for the current update.

                                                                                                                                                                                                                  func (*DBUpdates) Err

                                                                                                                                                                                                                  func (f *DBUpdates) Err() error

                                                                                                                                                                                                                    Err returns the error, if any, that was encountered during iteration. Err may be called after an explicit or implicit Close.

                                                                                                                                                                                                                    func (*DBUpdates) Next

                                                                                                                                                                                                                    func (f *DBUpdates) Next() bool

                                                                                                                                                                                                                      Next returns the next DBUpdate from the feed. This function will block until an event is received. If an error occurs, it will be returned and the feed closed. If the feed was closed normally, io.EOF will be returned when there are no more events in the buffer.

                                                                                                                                                                                                                      func (*DBUpdates) Seq

                                                                                                                                                                                                                      func (f *DBUpdates) Seq() string

                                                                                                                                                                                                                        Seq returns the update sequence of the current update.

                                                                                                                                                                                                                        func (*DBUpdates) Type

                                                                                                                                                                                                                        func (f *DBUpdates) Type() string

                                                                                                                                                                                                                          Type returns the type of the current update.

                                                                                                                                                                                                                          type Diffs

                                                                                                                                                                                                                          type Diffs map[string]RevDiff

                                                                                                                                                                                                                            Diffs is a collection of RevDiffs as returned by RevsDiff. The map key is the document ID.

                                                                                                                                                                                                                            type Error

                                                                                                                                                                                                                            type Error struct {
                                                                                                                                                                                                                            	// HTTPStatus is the HTTP status code associated with this error. Normally
                                                                                                                                                                                                                            	// this is the actual HTTP status returned by the server, but in some cases
                                                                                                                                                                                                                            	// it may be generated by Kivik directly. Check the FromServer value if
                                                                                                                                                                                                                            	// the distinction matters to you.
                                                                                                                                                                                                                            	HTTPStatus int
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// FromServer is set to true if the error was returned by the server.
                                                                                                                                                                                                                            	// This field is deprecated and will soon be removed.
                                                                                                                                                                                                                            	FromServer bool
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// Message is the error message.
                                                                                                                                                                                                                            	Message string
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// Err is the originating error, if any.
                                                                                                                                                                                                                            	Err error
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                              Error represents an error returned by Kivik.

                                                                                                                                                                                                                              This type definition is not guaranteed to remain stable, or even exported. When examining errors programatically, you should rely instead on the StatusCode() function in this package, rather than on directly observing the fields of this type.

                                                                                                                                                                                                                              func (*Error) Cause

                                                                                                                                                                                                                              func (e *Error) Cause() error

                                                                                                                                                                                                                                Cause satisfies the github.com/pkg/errors.causer interface by returning e.Err.

                                                                                                                                                                                                                                func (*Error) Error

                                                                                                                                                                                                                                func (e *Error) Error() string

                                                                                                                                                                                                                                func (*Error) Format

                                                                                                                                                                                                                                func (e *Error) Format(f fmt.State, c rune)

                                                                                                                                                                                                                                  Format implements fmt.Formatter

                                                                                                                                                                                                                                  func (*Error) FormatError

                                                                                                                                                                                                                                  func (e *Error) FormatError(p printer) error

                                                                                                                                                                                                                                    FormatError satisfies the Go 1.13 errors.Formatter interface (golang.org/x/xerrors.Formatter for older versions of Go).

                                                                                                                                                                                                                                    func (*Error) StatusCode

                                                                                                                                                                                                                                    func (e *Error) StatusCode() int

                                                                                                                                                                                                                                      StatusCode returns the HTTP status code associated with the error, or 500 (internal server error), if none.

                                                                                                                                                                                                                                      func (*Error) Unwrap

                                                                                                                                                                                                                                      func (e *Error) Unwrap() error

                                                                                                                                                                                                                                        Unwrap satisfies the Go 1.13 errors.Wrapper interface (golang.org/x/xerrors.Unwrap for older versions of Go).

                                                                                                                                                                                                                                        type Index

                                                                                                                                                                                                                                        type Index struct {
                                                                                                                                                                                                                                        	DesignDoc  string      `json:"ddoc,omitempty"`
                                                                                                                                                                                                                                        	Name       string      `json:"name"`
                                                                                                                                                                                                                                        	Type       string      `json:"type"`
                                                                                                                                                                                                                                        	Definition interface{} `json:"def"`
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                          Index is a MonboDB-style index definition.

                                                                                                                                                                                                                                          type Members

                                                                                                                                                                                                                                          type Members struct {
                                                                                                                                                                                                                                          	Names []string `json:"names,omitempty"`
                                                                                                                                                                                                                                          	Roles []string `json:"roles,omitempty"`
                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                            Members represents the members of a database security document.

                                                                                                                                                                                                                                            type Options

                                                                                                                                                                                                                                            type Options map[string]interface{}

                                                                                                                                                                                                                                              Options is a collection of options. The keys and values are backend specific.

                                                                                                                                                                                                                                              type PurgeResult

                                                                                                                                                                                                                                              type PurgeResult struct {
                                                                                                                                                                                                                                              	// Seq is the purge sequence number.
                                                                                                                                                                                                                                              	Seq int64 `json:"purge_seq"`
                                                                                                                                                                                                                                              	// Purged is a map of document ids to revisions, indicated the
                                                                                                                                                                                                                                              	// document/revision pairs that were successfully purged.
                                                                                                                                                                                                                                              	Purged map[string][]string `json:"purged"`
                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                PurgeResult is the result of a purge request.

                                                                                                                                                                                                                                                type QueryPlan

                                                                                                                                                                                                                                                type QueryPlan struct {
                                                                                                                                                                                                                                                	DBName   string                 `json:"dbname"`
                                                                                                                                                                                                                                                	Index    map[string]interface{} `json:"index"`
                                                                                                                                                                                                                                                	Selector map[string]interface{} `json:"selector"`
                                                                                                                                                                                                                                                	Options  map[string]interface{} `json:"opts"`
                                                                                                                                                                                                                                                	Limit    int64                  `json:"limit"`
                                                                                                                                                                                                                                                	Skip     int64                  `json:"skip"`
                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                	// Fields is the list of fields to be returned in the result set, or
                                                                                                                                                                                                                                                	// an empty list if all fields are to be returned.
                                                                                                                                                                                                                                                	Fields []interface{}          `json:"fields"`
                                                                                                                                                                                                                                                	Range  map[string]interface{} `json:"range"`
                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                  QueryPlan is the query execution plan for a query, as returned by the Explain function.

                                                                                                                                                                                                                                                  type Replication

                                                                                                                                                                                                                                                  type Replication struct {
                                                                                                                                                                                                                                                  	Source string
                                                                                                                                                                                                                                                  	Target string
                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                    Replication represents a CouchDB replication process.

                                                                                                                                                                                                                                                    func (*Replication) Delete

                                                                                                                                                                                                                                                    func (r *Replication) Delete(ctx context.Context) error

                                                                                                                                                                                                                                                      Delete deletes a replication. If it is currently running, it will be cancelled.

                                                                                                                                                                                                                                                      func (*Replication) DocWriteFailures

                                                                                                                                                                                                                                                      func (r *Replication) DocWriteFailures() int64

                                                                                                                                                                                                                                                        DocWriteFailures returns the number of doc write failures, if known.

                                                                                                                                                                                                                                                        func (*Replication) DocsRead

                                                                                                                                                                                                                                                        func (r *Replication) DocsRead() int64

                                                                                                                                                                                                                                                          DocsRead returns the number of documents read, if known.

                                                                                                                                                                                                                                                          func (*Replication) DocsWritten

                                                                                                                                                                                                                                                          func (r *Replication) DocsWritten() int64

                                                                                                                                                                                                                                                            DocsWritten returns the number of documents written, if known.

                                                                                                                                                                                                                                                            func (*Replication) EndTime

                                                                                                                                                                                                                                                            func (r *Replication) EndTime() time.Time

                                                                                                                                                                                                                                                              EndTime returns the replication end time, once the replication has terminated.

                                                                                                                                                                                                                                                              func (*Replication) Err

                                                                                                                                                                                                                                                              func (r *Replication) Err() error

                                                                                                                                                                                                                                                                Err returns the error, if any, that caused the replication to abort.

                                                                                                                                                                                                                                                                func (*Replication) IsActive

                                                                                                                                                                                                                                                                func (r *Replication) IsActive() bool

                                                                                                                                                                                                                                                                  IsActive returns true if the replication has not yet completed or errored.

                                                                                                                                                                                                                                                                  func (*Replication) Progress

                                                                                                                                                                                                                                                                  func (r *Replication) Progress() float64

                                                                                                                                                                                                                                                                    Progress returns the current replication progress, if known.

                                                                                                                                                                                                                                                                    func (*Replication) ReplicationID

                                                                                                                                                                                                                                                                    func (r *Replication) ReplicationID() string

                                                                                                                                                                                                                                                                      ReplicationID returns the _replication_id field of the replicator document.

                                                                                                                                                                                                                                                                      func (*Replication) StartTime

                                                                                                                                                                                                                                                                      func (r *Replication) StartTime() time.Time

                                                                                                                                                                                                                                                                        StartTime returns the replication start time, once the replication has been triggered.

                                                                                                                                                                                                                                                                        func (*Replication) State

                                                                                                                                                                                                                                                                        func (r *Replication) State() ReplicationState

                                                                                                                                                                                                                                                                          State returns the current replication state

                                                                                                                                                                                                                                                                          func (*Replication) Update

                                                                                                                                                                                                                                                                          func (r *Replication) Update(ctx context.Context) error

                                                                                                                                                                                                                                                                            Update requests a replication state update from the server. If there is an error retrieving the update, it is returned and the replication state is unaltered.

                                                                                                                                                                                                                                                                            type ReplicationInfo

                                                                                                                                                                                                                                                                            type ReplicationInfo struct {
                                                                                                                                                                                                                                                                            	DocWriteFailures int64
                                                                                                                                                                                                                                                                            	DocsRead         int64
                                                                                                                                                                                                                                                                            	DocsWritten      int64
                                                                                                                                                                                                                                                                            	Progress         float64
                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                              ReplicationInfo represents a snapshot of the status of a replication.

                                                                                                                                                                                                                                                                              type ReplicationState

                                                                                                                                                                                                                                                                              type ReplicationState string

                                                                                                                                                                                                                                                                                ReplicationState represents a replication's state

                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                	ReplicationNotStarted ReplicationState = ""
                                                                                                                                                                                                                                                                                	ReplicationStarted    ReplicationState = "triggered"
                                                                                                                                                                                                                                                                                	ReplicationError      ReplicationState = "error"
                                                                                                                                                                                                                                                                                	ReplicationComplete   ReplicationState = "completed"
                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                  The possible values for the _replication_state field in _replicator documents plus a blank value for unstarted replications.

                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                  	ReplicationInitializing ReplicationState = "initializing"
                                                                                                                                                                                                                                                                                  	ReplicationRunning      ReplicationState = "running"
                                                                                                                                                                                                                                                                                  	ReplicationPending      ReplicationState = "pending"
                                                                                                                                                                                                                                                                                  	ReplicationCrashing     ReplicationState = "crashing"
                                                                                                                                                                                                                                                                                  	ReplicationFailed       ReplicationState = "failed"
                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                    The additional possible values for the state field in the _scheduler docs.

                                                                                                                                                                                                                                                                                    type RevDiff

                                                                                                                                                                                                                                                                                    type RevDiff struct {
                                                                                                                                                                                                                                                                                    	Missing           []string `json:"missing,omitempty"`
                                                                                                                                                                                                                                                                                    	PossibleAncestors []string `json:"possible_ancestors,omitempty"`
                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                      RevDiff represents a rev diff for a single document, as returned by the RevsDiff method.

                                                                                                                                                                                                                                                                                      type Row

                                                                                                                                                                                                                                                                                      type Row struct {
                                                                                                                                                                                                                                                                                      	// ContentLength records the size of the JSON representation of the document
                                                                                                                                                                                                                                                                                      	// as requestd. The value -1 indicates that the length is unknown. Values
                                                                                                                                                                                                                                                                                      	// >= 0 indicate that the given number of bytes may be read from Body.
                                                                                                                                                                                                                                                                                      	ContentLength int64
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	// Rev is the revision ID of the returned document.
                                                                                                                                                                                                                                                                                      	Rev string
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	// Body represents the document's content.
                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                      	// Kivik will always return a non-nil Body, except when Err is non-nil. The
                                                                                                                                                                                                                                                                                      	// ScanDoc method will close Body. When not using ScanDoc, it is the
                                                                                                                                                                                                                                                                                      	// caller's responsibility to close Body
                                                                                                                                                                                                                                                                                      	Body io.ReadCloser
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	// Err contains any error that occurred while fetching the document. It is
                                                                                                                                                                                                                                                                                      	// typically returned by ScanDoc.
                                                                                                                                                                                                                                                                                      	Err error
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	// Attachments is experimental
                                                                                                                                                                                                                                                                                      	Attachments *AttachmentsIterator
                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                        Row contains the result of calling Get for a single document. For most uses, it is sufficient just to call the ScanDoc method. For more advanced uses, the fields may be accessed directly.

                                                                                                                                                                                                                                                                                        func (*Row) ScanDoc

                                                                                                                                                                                                                                                                                        func (r *Row) ScanDoc(dest interface{}) error

                                                                                                                                                                                                                                                                                          ScanDoc unmarshals the data from the fetched row into dest. It is an intelligent wrapper around json.Unmarshal which also handles multipart/related responses. When done, the underlying reader is closed.

                                                                                                                                                                                                                                                                                          type Rows

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

                                                                                                                                                                                                                                                                                            Rows is an iterator over a a multi-value query.

                                                                                                                                                                                                                                                                                            func (*Rows) Bookmark

                                                                                                                                                                                                                                                                                            func (r *Rows) Bookmark() string

                                                                                                                                                                                                                                                                                              Bookmark returns the paging bookmark, if one was provided with the result set. This is intended for use with the Mango /_find interface, with CouchDB 2.1.1 and later. Consult the official CouchDB documentation for detailed usage instructions. http://docs.couchdb.org/en/2.1.1/api/database/find.html#pagination

                                                                                                                                                                                                                                                                                              func (*Rows) Close

                                                                                                                                                                                                                                                                                              func (r *Rows) Close() error

                                                                                                                                                                                                                                                                                                Close closes the Rows, preventing further enumeration, and freeing any resources (such as the http request body) of the underlying query. If Next is called and there are no further results, Rows is closed automatically and it will suffice to check the result of Err. Close is idempotent and does not affect the result of Err.

                                                                                                                                                                                                                                                                                                func (*Rows) Err

                                                                                                                                                                                                                                                                                                func (r *Rows) Err() error

                                                                                                                                                                                                                                                                                                  Err returns the error, if any, that was encountered during iteration. Err may be called after an explicit or implicit Close.

                                                                                                                                                                                                                                                                                                  func (*Rows) ID

                                                                                                                                                                                                                                                                                                  func (r *Rows) ID() string

                                                                                                                                                                                                                                                                                                    ID returns the ID of the current result.

                                                                                                                                                                                                                                                                                                    func (*Rows) Key

                                                                                                                                                                                                                                                                                                    func (r *Rows) Key() string

                                                                                                                                                                                                                                                                                                      Key returns the Key of the current result as a raw JSON string. For compound keys, the ScanKey() method may be more convenient.

                                                                                                                                                                                                                                                                                                      func (*Rows) Next

                                                                                                                                                                                                                                                                                                      func (r *Rows) Next() bool

                                                                                                                                                                                                                                                                                                        Next prepares the next result value for reading. It returns true on success or false if there are no more results or an error occurs while preparing it. Err should be consulted to distinguish between the two.

                                                                                                                                                                                                                                                                                                        func (*Rows) Offset

                                                                                                                                                                                                                                                                                                        func (r *Rows) Offset() int64

                                                                                                                                                                                                                                                                                                          Offset returns the starting offset where the result set started. It is only guaranteed to be set after all result rows have been enumerated through by Next, and thus should only be read after processing all rows in a result set. Calling Close before enumerating will render this value unreliable.

                                                                                                                                                                                                                                                                                                          func (*Rows) ScanDoc

                                                                                                                                                                                                                                                                                                          func (r *Rows) ScanDoc(dest interface{}) error

                                                                                                                                                                                                                                                                                                            ScanDoc works the same as ScanValue, but on the doc field of the result. It will panic if the query does not include documents.

                                                                                                                                                                                                                                                                                                            func (*Rows) ScanKey

                                                                                                                                                                                                                                                                                                            func (r *Rows) ScanKey(dest interface{}) error

                                                                                                                                                                                                                                                                                                              ScanKey works the same as ScanValue, but on the key field of the result. For simple keys, which are just strings, the Key() method may be easier to use.

                                                                                                                                                                                                                                                                                                              func (*Rows) ScanValue

                                                                                                                                                                                                                                                                                                              func (r *Rows) ScanValue(dest interface{}) error

                                                                                                                                                                                                                                                                                                                ScanValue copies the data from the result value into the value pointed at by dest. Think of this as a json.Unmarshal into dest.

                                                                                                                                                                                                                                                                                                                If the dest argument has type *[]byte, Scan stores a copy of the input data. The copy is owned by the caller and can be modified and held indefinitely.

                                                                                                                                                                                                                                                                                                                The copy can be avoided by using an argument of type *json.RawMessage instead. After a ScanValue into a json.RawMessage, the slice is only valid until the next call to Next or Close.

                                                                                                                                                                                                                                                                                                                For all other types, refer to the documentation for json.Unmarshal for type conversion rules.

                                                                                                                                                                                                                                                                                                                func (*Rows) TotalRows

                                                                                                                                                                                                                                                                                                                func (r *Rows) TotalRows() int64

                                                                                                                                                                                                                                                                                                                  TotalRows returns the total number of rows in the view which would have been returned if no limiting were used. This value is only guaranteed to be set after all result rows have been enumerated through by Next, and thus should only be read after processing all rows in a result set. Calling Close before enumerating will render this value unreliable.

                                                                                                                                                                                                                                                                                                                  func (*Rows) UpdateSeq

                                                                                                                                                                                                                                                                                                                  func (r *Rows) UpdateSeq() string

                                                                                                                                                                                                                                                                                                                    UpdateSeq returns the sequence id of the underlying database the view reflects, if requested in the query. This value is only guaranteed to be set after all result rows have been enumerated through by Next, and thus should only be read after processing all rows in a result set. Calling Close before enumerating will render this value unreliable.

                                                                                                                                                                                                                                                                                                                    func (*Rows) Warning

                                                                                                                                                                                                                                                                                                                    func (r *Rows) Warning() string

                                                                                                                                                                                                                                                                                                                      Warning returns a warning generated by the query, if any. This value is only guaranteed to be set after all result rows have been enumeratd through by Next.

                                                                                                                                                                                                                                                                                                                      type Security

                                                                                                                                                                                                                                                                                                                      type Security struct {
                                                                                                                                                                                                                                                                                                                      	Admins  Members `json:"admins"`
                                                                                                                                                                                                                                                                                                                      	Members Members `json:"members"`
                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                        Security represents a database security document.

                                                                                                                                                                                                                                                                                                                        type Session

                                                                                                                                                                                                                                                                                                                        type Session struct {
                                                                                                                                                                                                                                                                                                                        	// Name is the name of the authenticated user.
                                                                                                                                                                                                                                                                                                                        	Name string
                                                                                                                                                                                                                                                                                                                        	// Roles is a list of roles the user belongs to.
                                                                                                                                                                                                                                                                                                                        	Roles []string
                                                                                                                                                                                                                                                                                                                        	// AuthenticationMethod is the authentication method that was used for this
                                                                                                                                                                                                                                                                                                                        	// session.
                                                                                                                                                                                                                                                                                                                        	AuthenticationMethod string
                                                                                                                                                                                                                                                                                                                        	// AuthenticationDB is the user database against which authentication was
                                                                                                                                                                                                                                                                                                                        	// performed.
                                                                                                                                                                                                                                                                                                                        	AuthenticationDB string
                                                                                                                                                                                                                                                                                                                        	// AuthenticationHandlers is a list of authentication handlers configured on
                                                                                                                                                                                                                                                                                                                        	// the server.
                                                                                                                                                                                                                                                                                                                        	AuthenticationHandlers []string
                                                                                                                                                                                                                                                                                                                        	// RawResponse is the raw JSON response sent by the server, useful for
                                                                                                                                                                                                                                                                                                                        	// custom backends which may provide additional fields.
                                                                                                                                                                                                                                                                                                                        	RawResponse json.RawMessage
                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                          Session represents an authentication session.

                                                                                                                                                                                                                                                                                                                          type Version

                                                                                                                                                                                                                                                                                                                          type Version struct {
                                                                                                                                                                                                                                                                                                                          	// Version is the version number reported by the server or backend.
                                                                                                                                                                                                                                                                                                                          	Version string
                                                                                                                                                                                                                                                                                                                          	// Vendor is the vendor string reported by the server or backend.
                                                                                                                                                                                                                                                                                                                          	Vendor string
                                                                                                                                                                                                                                                                                                                          	// Features is a list of enabled, optional features.  This was added in
                                                                                                                                                                                                                                                                                                                          	// CouchDB 2.1.0, and can be expected to be empty for older versions.
                                                                                                                                                                                                                                                                                                                          	Features []string
                                                                                                                                                                                                                                                                                                                          	// RawResponse is the raw response body returned by the server, useful if
                                                                                                                                                                                                                                                                                                                          	// you need additional backend-specific information.
                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                          	// For the format of this document, see
                                                                                                                                                                                                                                                                                                                          	// http://docs.couchdb.org/en/2.0.0/api/server/common.html#get
                                                                                                                                                                                                                                                                                                                          	RawResponse json.RawMessage
                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                            Version represents a server version response.

                                                                                                                                                                                                                                                                                                                            Directories

                                                                                                                                                                                                                                                                                                                            Path Synopsis
                                                                                                                                                                                                                                                                                                                            Package driver defines interfaces to be implemented by database drivers as used by package kivik.
                                                                                                                                                                                                                                                                                                                            Package driver defines interfaces to be implemented by database drivers as used by package kivik.
                                                                                                                                                                                                                                                                                                                            Package errors provides convenience functions for Kivik drivers to report meaningful errors.
                                                                                                                                                                                                                                                                                                                            Package errors provides convenience functions for Kivik drivers to report meaningful errors.
                                                                                                                                                                                                                                                                                                                            internal
                                                                                                                                                                                                                                                                                                                            mock
                                                                                                                                                                                                                                                                                                                            Package mock provides minimal mocks for kivik driver interfaces.
                                                                                                                                                                                                                                                                                                                            Package mock provides minimal mocks for kivik driver interfaces.