Back to godoc.org

Package driver

v3.2.0
Latest Go to latest

The latest major version is v3.

Published: Jul 10, 2020 | License: Apache-2.0 | Module: github.com/go-kivik/kivik/v3

Overview

Package driver defines interfaces to be implemented by database drivers as used by package kivik.

Most code should use package kivik.

Index

Constants

const EOQ = err("EOQ")

EOQ should be returned by a view iterator at the end of each query result set.

type Attachment

type Attachment struct {
	Filename        string        `json:"-"`
	ContentType     string        `json:"content_type"`
	Stub            bool          `json:"stub"`
	Follows         bool          `json:"follows"`
	Content         io.ReadCloser `json:"-"`
	Size            int64         `json:"length"`
	ContentEncoding string        `json:"encoding"`
	EncodedLength   int64         `json:"encoded_length"`
	RevPos          int64         `json:"revpos"`
	Digest          string        `json:"digest"`
}

Attachment represents a file attachment to a document.

type AttachmentMetaGetter

type AttachmentMetaGetter interface {
	// GetAttachmentMetaOpts returns meta information about an attachment.
	GetAttachmentMeta(ctx context.Context, docID, filename string, options map[string]interface{}) (*Attachment, error)
}

AttachmentMetaGetter is an optional interface which may be satisfied by a DB. If satisfied, it may be used to fetch meta data about an attachment. If not satisfied, GetAttachment will be used instead.

type Attachments

type Attachments interface {
	// Next is called to pupulate att with the next attachment in the result
	// set.
	//
	// Next should return io.EOF when there are no more attachments.
	Next(att *Attachment) error

	// Close closes the Attachments iterator
	Close() error
}

Attachments is an iterator over the attachments included in a document when Get is called with `include_docs=true`.

type Authenticator

type Authenticator interface {
	// Authenticate attempts to authenticate the client using an authenticator.
	// If the authenticator is not known to the client, an error should be
	// returned.
	Authenticate(ctx context.Context, authenticator interface{}) error
}

Authenticator is an optional interface that may be implemented by a Client that supports authenitcated connections.

type Bookmarker

type Bookmarker interface {
	// Bookmark returns an opaque bookmark string used for paging, added to
	// the /_find endpoint in CouchDB 2.1.1.  See the CouchDB documentation for
	// usage: http://docs.couchdb.org/en/2.1.1/api/database/find.html#pagination
	Bookmark() string
}

Bookmarker is an optional interface that may be implemented by a Rows for returning a paging bookmark.

type BulkDocer

type BulkDocer interface {
	// BulkDocs alls bulk create, update and/or delete operations. It returns an
	// iterator over the results.
	BulkDocs(ctx context.Context, docs []interface{}, options map[string]interface{}) (BulkResults, error)
}

BulkDocer is an optional interface which may be implemented by a DB to support bulk insert/update operations. For any driver that does not support the BulkDocer interface, the Put or CreateDoc methods will be called for each document to emulate the same functionality, with options passed through unaltered.

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 BulkGetter

type BulkGetter interface {
	// BulkGet uses the _bulk_get interface to fetch multiple documents in a single query.
	BulkGet(ctx context.Context, docs []BulkGetReference, options map[string]interface{}) (Rows, error)
}

BulkGetter is an optional interface which may be implemented by a driver to support bulk get operations.

type BulkResult

type BulkResult struct {
	ID    string `json:"id"`
	Rev   string `json:"rev"`
	Error error
}

BulkResult is the result of a single doc update in a BulkDocs request.

type BulkResults

type BulkResults interface {
	// Next is called to populate *BulkResult with the values of the next bulk
	// result in the set.
	//
	// Next should return io.EOF when there are no more results.
	Next(*BulkResult) error
	// Close closes the bulk results iterator.
	Close() error
}

BulkResults is an iterator over the results for a BulkDocs call.

type Change

type Change struct {
	// ID is the document ID to which the change relates.
	ID string `json:"id"`
	// Seq is the update sequence for the changes feed.
	Seq string `json:"seq"`
	// Deleted is set to true for the changes feed, if the document has been
	// deleted.
	Deleted bool `json:"deleted"`
	// Changes represents a list of document leaf revisions for the /_changes
	// endpoint.
	Changes ChangedRevs `json:"changes"`
	// Doc is the raw, un-decoded JSON document. This is only populated when
	// include_docs=true is set.
	Doc json.RawMessage `json:"doc"`
}

Change represents the changes to a single document.

type ChangedRevs

type ChangedRevs []string

ChangedRevs represents a "changes" field of a result in the /_changes stream.

func (*ChangedRevs) UnmarshalJSON

func (c *ChangedRevs) UnmarshalJSON(data []byte) error

UnmarshalJSON satisfies the json.Unmarshaler interface

type Changes

type Changes interface {
	// Next is called to populate *Change with the next value in the changes
	// feed.
	//
	// Next should return io.EOF when the changes feed is closed by request.
	Next(*Change) error
	// Close closes the changes feed iterator.
	Close() error
	// LastSeq returns the last change update sequence.
	LastSeq() string
	// Pending returns the count of remaining items in the feed
	Pending() int64
	// ETag returns the unquoted ETag header, if present.
	ETag() string
}

Changes is an iterator of the database changes feed.

type Client

type Client interface {
	// Version returns the server implementation's details.
	Version(ctx context.Context) (*Version, error)
	// AllDBs returns a list of all existing database names.
	AllDBs(ctx context.Context, options map[string]interface{}) ([]string, error)
	// DBExists returns true if the database exists.
	DBExists(ctx context.Context, dbName string, options map[string]interface{}) (bool, error)
	// CreateDB creates the requested DB. The dbName is validated as a valid
	// CouchDB database name prior to calling this function, so the driver can
	// assume a valid name.
	CreateDB(ctx context.Context, dbName string, options map[string]interface{}) error
	// DestroyDB deletes the requested DB.
	DestroyDB(ctx context.Context, dbName string, options map[string]interface{}) error
	// DB returns a handleto the requested database
	DB(ctx context.Context, dbName string, options map[string]interface{}) (DB, error)
}

Client is a connection to a database server.

type ClientCloser

type ClientCloser interface {
	Close(ctx context.Context) error
}

ClientCloser is an optional interface that may be implemented by a Client to clean up resources when a Client is no longer needed.

type ClientReplicator

type ClientReplicator interface {
	// Replicate initiates a replication.
	Replicate(ctx context.Context, targetDSN, sourceDSN string, options map[string]interface{}) (Replication, error)
	// GetReplications returns a list of replicatoins (i.e. all docs in the
	// _replicator database)
	GetReplications(ctx context.Context, options map[string]interface{}) ([]Replication, error)
}

ClientReplicator is an optional interface that may be implemented by a Client that supports replication between two database.

type Cluster

type Cluster interface {
	// ClusterStatus returns the current cluster status.
	ClusterStatus(ctx context.Context, options map[string]interface{}) (string, error)
	// ClusterSetup performs the action specified by action.
	ClusterSetup(ctx context.Context, action interface{}) error
}

Cluster is an optional interface that may be implemented by a Client to support CouchDB cluster configuration operations.

type Cluster2

type Cluster2 interface {
	// Membership returns a list of all known nodes, and all nodes configured as
	// part of the cluster.
	Membership(ctx context.Context) (*ClusterMembership, error)
}

Cluster2 extends Cluster (and is merged with it in kivik v4), to allow access to the /_membership endpoint.

type ClusterMembership

type ClusterMembership struct {
	AllNodes     []string `json:"all_nodes"`
	ClusterNodes []string `json:"cluster_nodes"`
}

ClusterMembership contains the list of known nodes, and cluster nodes, as returned by the /_membership endpoint. See https://docs.couchdb.org/en/latest/api/server/common.html#get--_membership

type ClusterStats

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

ClusterStats contains the cluster configuration for the database.

type Config

type Config map[string]ConfigSection

Config represents all the config sections.

type ConfigSection

type ConfigSection map[string]string

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

type Configer

type Configer interface {
	Config(ctx context.Context, node string) (Config, error)
	ConfigSection(ctx context.Context, node, section string) (ConfigSection, error)
	ConfigValue(ctx context.Context, node, section, key string) (string, error)
	SetConfigValue(ctx context.Context, node, section, key, value string) (string, error)
	DeleteConfigKey(ctx context.Context, node, section, key string) (string, error)
}

Configer is an optional interface that may be implemented by a Client to allow access to reading and setting server configuration.

type Copier

type Copier interface {
	Copy(ctx context.Context, targetID, sourceID string, options map[string]interface{}) (targetRev string, err error)
}

Copier is an optional interface that may be implemented by a DB.

If a DB does implement Copier, Copy() functions will use it. If a DB does not implement the Copier interface, the functionality will be emulated by calling Get followed by Put, with options passed through unaltered, except that the 'rev' option will be removed for the Put call.

type DB

type DB interface {
	// AllDocs returns all of the documents in the database, subject to the
	// options provided.
	AllDocs(ctx context.Context, options map[string]interface{}) (Rows, error)
	// Get fetches the requested document from the database, and returns the
	// content length (or -1 if unknown), and an io.ReadCloser to access the
	// raw JSON content.
	Get(ctx context.Context, docID string, options map[string]interface{}) (*Document, error)
	// CreateDoc creates a new doc, with a server-generated ID.
	CreateDoc(ctx context.Context, doc interface{}, options map[string]interface{}) (docID, rev string, err error)
	// Put writes the document in the database.
	Put(ctx context.Context, docID string, doc interface{}, options map[string]interface{}) (rev string, err error)
	// Delete marks the specified document as deleted.
	Delete(ctx context.Context, docID, rev string, options map[string]interface{}) (newRev string, err error)
	// Stats returns database statistics.
	Stats(ctx context.Context) (*DBStats, error)
	// Compact initiates compaction of the database.
	Compact(ctx context.Context) error
	// CompactView initiates compaction of the view.
	CompactView(ctx context.Context, ddocID string) error
	// ViewCleanup cleans up stale view files.
	ViewCleanup(ctx context.Context) error
	// Security returns the database's security document.
	Security(ctx context.Context) (*Security, error)
	// SetSecurity sets the database's security document.
	SetSecurity(ctx context.Context, security *Security) error
	// Changes returns a Rows iterator for the changes feed. In continuous mode,
	// the iterator will continue indefinitely, until Close is called.
	Changes(ctx context.Context, options map[string]interface{}) (Changes, error)
	// PutAttachment uploads an attachment to the specified document, returning
	// the new revision.
	PutAttachment(ctx context.Context, docID, rev string, att *Attachment, options map[string]interface{}) (newRev string, err error)
	// GetAttachment fetches an attachment for the associated document ID.
	GetAttachment(ctx context.Context, docID, filename string, options map[string]interface{}) (*Attachment, error)
	// DeleteAttachment deletes an attachment from a document, returning the
	// document's new revision.
	DeleteAttachment(ctx context.Context, docID, rev, filename string, options map[string]interface{}) (newRev string, err error)
	// Query performs a query against a view, subject to the options provided.
	// ddoc will be the design doc name without the '_design/' previx.
	// view will be the view name without the '_view/' prefix.
	Query(ctx context.Context, ddoc, view string, options map[string]interface{}) (Rows, error)
}

DB is a database handle.

type DBCloser

type DBCloser interface {
	Close(ctx context.Context) error
}

DBCloser is an optional interface that may be implemented by a DB to clean up resources when a DB is no longer needed.

type DBStats

type DBStats struct {
	Name           string          `json:"db_name"`
	CompactRunning bool            `json:"compact_running"`
	DocCount       int64           `json:"doc_count"`
	DeletedCount   int64           `json:"doc_del_count"`
	UpdateSeq      string          `json:"update_seq"`
	DiskSize       int64           `json:"disk_size"`
	ActiveSize     int64           `json:"data_size"`
	ExternalSize   int64           `json:"-"`
	Cluster        *ClusterStats   `json:"cluster,omitempty"`
	RawResponse    json.RawMessage `json:"-"`
}

DBStats contains database statistics.

type DBUpdate

type DBUpdate struct {
	DBName string `json:"db_name"`
	Type   string `json:"type"`
	Seq    string `json:"seq"`
}

DBUpdate represents a database update event.

type DBUpdater

type DBUpdater interface {
	// DBUpdates must return a DBUpdate iterator. The context, or the iterator's
	// Close method, may be used to close the iterator.
	DBUpdates(context.Context) (DBUpdates, error)
}

DBUpdater is an optional interface that may be implemented by a Client to provide access to the DB Updates feed.

type DBUpdates

type DBUpdates interface {
	// Next is called to populate DBUpdate with the values of the next update in
	// the feed.
	//
	// Next should return io.EOF when the feed is closed normally.
	Next(*DBUpdate) error
	// Close closes the iterator.
	Close() error
}

DBUpdates is a DBUpdates iterator.

type DBsStatser

type DBsStatser interface {
	// DBsStats returns database statistical information for each database
	// named in dbNames. The returned values should be in the same order as
	// the requested database names, and any missing databases should return
	// a nil *DBStats value.
	DBsStats(ctx context.Context, dbNames []string) ([]*DBStats, error)
}

DBsStatser is an optional interface, added to support CouchDB 2.2.0's /_dbs_info endpoint. If this is not supported, or if this method returns status 404, Kivik will fall back to calling the method of issuing a GET /{db} for each database requested.

type DesignDocer

type DesignDocer interface {
	// DesignDocs returns all of the design documents in the database, subject
	// to the options provided.
	DesignDocs(ctx context.Context, options map[string]interface{}) (Rows, error)
}

DesignDocer is an optional interface that may be implemented by a DB.

type Document

type Document struct {
	// ContentLength is the size of the document response in bytes.
	ContentLength int64

	// Rev is the revision number returned
	Rev string

	// Body contains the respons body, either in raw JSON or multipart/related
	// format.
	Body io.ReadCloser

	// Attachments will be nil except when attachments=true.
	Attachments Attachments
}

Document represents a single document returned by Get

type Driver

type Driver interface {
	// NewClient returns a connection handle to the database. The name is in a
	// driver-specific format.
	NewClient(name string) (Client, error)
}

Driver is the interface that must be implemented by a database driver.

type Finder

type Finder interface {
	Find(ctx context.Context, query interface{}) (Rows, error)
	CreateIndex(ctx context.Context, ddoc, name string, index interface{}) error
	GetIndexes(ctx context.Context) ([]Index, error)
	DeleteIndex(ctx context.Context, ddoc, name string) error
	Explain(ctx context.Context, query interface{}) (*QueryPlan, error)
}

Finder is the old Finder interface, which does not accept options. It remains for compatibility with older backends.

Deprecated: Use OptsFinder instead.

type Flusher

type Flusher interface {
	// 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
	Flush(ctx context.Context) error
}

Flusher is an optional interface that may be implemented by a DB that can force a flush of the database backend file(s) to disk or other permanent storage.

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 LocalDocer

type LocalDocer interface {
	// LocalDocs returns all of the local documents in the database, subject to
	// the options provided.
	LocalDocs(ctx context.Context, options map[string]interface{}) (Rows, error)
}

LocalDocer is an optional interface that may be implemented by a DB.

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 MetaGetter

type MetaGetter interface {
	// GetMeta returns the document size and revision of the requested document.
	// GetMeta should accept the same options as the Get method.
	GetMeta(ctx context.Context, docID string, options map[string]interface{}) (size int64, rev string, err error)
}

MetaGetter is an optional interface that may be implemented by a DB. If not implemented, the Get method will be used to emulate the functionality, with options passed through unaltered.

type OptsFinder

type OptsFinder interface {
	// Find executes a query using the new /_find interface. If query is a
	// string, []byte, or json.RawMessage, it should be treated as a raw JSON
	// payload. Any other type should be marshaled to JSON.
	Find(ctx context.Context, query interface{}, options map[string]interface{}) (Rows, error)
	// CreateIndex creates an index if it doesn't already exist. If the index
	// already exists, it should do nothing. ddoc and name may be empty, in
	// which case they should be provided by the backend. If index is a string,
	// []byte, or json.RawMessage, it should be treated as a raw JSON payload.
	// Any other type should be marshaled to JSON.
	CreateIndex(ctx context.Context, ddoc, name string, index interface{}, options map[string]interface{}) error
	// GetIndexes returns a list of all indexes in the database.
	GetIndexes(ctx context.Context, options map[string]interface{}) ([]Index, error)
	// Delete deletes the requested index.
	DeleteIndex(ctx context.Context, ddoc, name string, options map[string]interface{}) error
	// Explain returns the query plan for a given query. Explain takes the same
	// arguments as Find.
	Explain(ctx context.Context, query interface{}, options map[string]interface{}) (*QueryPlan, error)
}

OptsFinder is an optional interface which may be implemented by a DB. The Finder interface provides access to the new (in CouchDB 2.0) MongoDB-style query interface.

type PartitionStats

type PartitionStats struct {
	DBName          string
	DocCount        int64
	DeletedDocCount int64
	Partition       string
	ActiveSize      int64
	ExternalSize    int64
	RawResponse     json.RawMessage
}

PartitionStats contains partition statistics.

type PartitionedDB

type PartitionedDB interface {
	// PartitionStats returns information about the named partition.
	PartitionStats(ctx context.Context, name string) (*PartitionStats, error)
}

PartitionedDB is an optional interface that may be satisfied by a DB to support querying partitoin-specific information.

type Pinger

type Pinger interface {
	// Ping returns true if the database is online and available for requests.
	Ping(ctx context.Context) (bool, error)
}

Pinger is an optional interface that may be implemented by a Client. When not implemented, Kivik will call Version instead, to determine if the database is usable.

type PurgeResult

type PurgeResult struct {
	Seq    int64               `json:"purge_seq"`
	Purged map[string][]string `json:"purged"`
}

PurgeResult is the result of a purge request.

type Purger

type Purger interface {
	// Purge permanently removes the references to deleted documents from the
	// database.
	Purge(ctx context.Context, docRevMap map[string][]string) (*PurgeResult, error)
}

Purger is an optional interface which may be implemented by a DB to support document purging.

type QueryIndexer

type QueryIndexer interface {
	QueryIndex() int
}

QueryIndexer is an optional interface that may be implemented by a Rows, which allows a rows iterator to return a query index value. This is intended for use by multi-query queries to views.

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 response of an Explain query.

type Replication

type Replication interface {
	// The following methods are called just once, when the Replication is first
	// returned from Replicate() or GetReplications().
	ReplicationID() string
	Source() string
	Target() string
	StartTime() time.Time
	EndTime() time.Time
	State() string
	Err() error

	// Delete deletes a replication, which cancels it if it is running.
	Delete(context.Context) error
	// Update fetches the latest replication state from the server.
	Update(context.Context, *ReplicationInfo) error
}

Replication represents a _replicator document.

type ReplicationInfo

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

ReplicationInfo represents a snap-shot state of a replication, as provided by the _active_tasks endpoint.

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 RevsDiffer

type RevsDiffer interface {
	// RevsDiff returns a Rows iterator, which should populate the ID and Value
	// fields, and nothing else.
	RevsDiff(ctx context.Context, revMap interface{}) (Rows, error)
}

RevsDiffer is an optional interface that may be implemented by a DB.

type Row

type Row struct {
	// ID is the document ID of the result.
	ID string `json:"id"`
	// Key is the view key of the result. For built-in views, this is the same
	// as ID.
	Key json.RawMessage `json:"key"`
	// Value is the raw, un-decoded JSON value. For most built-in views (such as
	// /_all_docs), this is `{"rev":"X-xxx"}`.
	Value json.RawMessage `json:"value"`
	// Doc is the raw, un-decoded JSON document. This is only populated by views
	// which return docs, such as /_all_docs?include_docs=true.
	Doc json.RawMessage `json:"doc"`
	// Error represents the error for any row not fetched. Usually just
	// 'not_found'.
	Error error `json:"-"`
}

Row is a generic view result row.

type Rows

type Rows interface {
	// Next is called to populate row with the next row in the result set.
	//
	// Next should return io.EOF when there are no more rows.
	Next(row *Row) error
	// Close closes the rows iterator.
	Close() error
	// UpdateSeq is the update sequence of the database, if requested in the
	// result set.
	UpdateSeq() string
	// Offset is the offset where the result set starts.
	Offset() int64
	// TotalRows is the number of documents in the database/view.
	TotalRows() int64
}

Rows is an iterator over a view's results.

type RowsWarner

type RowsWarner interface {
	// Warning returns the warning generated by the query, if any.
	Warning() string
}

RowsWarner is an optional interface that may be implemented by a Rows, which allows a rows iterator to return a non-fatal warning. This is intended for use by the /_find endpoint, which generates warnings when indexes don't exist.

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 is a copy of kivik.Session

type Sessioner

type Sessioner interface {
	// Session returns information about the authenticated user.
	Session(ctx context.Context) (*Session, error)
}

Sessioner is an optional interface that a Client may satisfy to provide access to the authenticated session information.

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 as returned by the server.
	RawResponse json.RawMessage
}

Version represents a server version response.

Package Files

Documentation was rendered with GOOS=linux and GOARCH=amd64.

Jump to identifier

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to identifier