gocb

package module
v0.0.0-...-2042249 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 14, 2019 License: Apache-2.0 Imports: 17 Imported by: 0

README

Couchbase Go Alpha v2 Client

This is the v2 alpha version of official Couchbase Go SDK. If you are looking for the official stable package then go to gocb.

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

Installing

To install the latest developer version, run:

go get github.com/couchbaselabs/gocb2alpha

License

Copyright 2016 Couchbase Inc.

Licensed under the Apache License, Version 2.0.

See LICENSE for further details.

Documentation

Index

Constants

View Source 
const (
	// IndexTypeN1ql indicates that GSI was used to build the index.
	IndexTypeN1ql = IndexType("gsi")

	// IndexTypeView indicates that views were used to build the index.
	IndexTypeView = IndexType("views")
)
View Source 
const (
	// MemdService represents a memcached service.
	MemdService = ServiceType(gocbcore.MemdService)

	// MgmtService represents a management service (typically ns_server).
	MgmtService = ServiceType(gocbcore.MgmtService)

	// CapiService represents a CouchAPI service (typically for views).
	CapiService = ServiceType(gocbcore.CapiService)

	// N1qlService represents a N1QL service (typically for query).
	N1qlService = ServiceType(gocbcore.N1qlService)

	// FtsService represents a full-text-search service.
	FtsService = ServiceType(gocbcore.FtsService)

	// CbasService represents an analytics service.
	CbasService = ServiceType(gocbcore.CbasService)
)
View Source 
const (
	// QueryProfileNone disables query profiling
	QueryProfileNone = QueryProfileType("off")

	// QueryProfilePhases includes phase profiling information in the query response
	QueryProfilePhases = QueryProfileType("phases")

	// QueryProfileTimings includes timing profiling information in the query response
	QueryProfileTimings = QueryProfileType("timings")
)
View Source 
const (
	// SubdocFlagNone indicates no special behaviours
	SubdocFlagNone = SubdocFlag(gocbcore.SubdocFlagNone)

	// SubdocFlagCreatePath indicates you wish to recursively create the tree of paths
	// if it does not already exist within the document.
	SubdocFlagCreatePath = SubdocFlag(gocbcore.SubdocFlagMkDirP)

	// SubdocFlagXattr indicates your path refers to an extended attribute rather than the document.
	SubdocFlagXattr = SubdocFlag(gocbcore.SubdocFlagXattrPath)

	// SubdocFlagUseMacros indicates that you wish macro substitution to occur on the value
	SubdocFlagUseMacros = SubdocFlag(gocbcore.SubdocFlagExpandMacros)
)
View Source 
const (
	// SubdocDocFlagNone indicates no special behaviours
	SubdocDocFlagNone = SubdocDocFlag(gocbcore.SubdocDocFlagNone)

	// SubdocDocFlagMkDoc indicates that the document should be created if it does not already exist.
	SubdocDocFlagMkDoc = SubdocDocFlag(gocbcore.SubdocDocFlagMkDoc)

	// SubdocDocFlagReplaceDoc indices that this operation should be a replace rather than upsert.
	SubdocDocFlagReplaceDoc = SubdocDocFlag(gocbcore.SubdocDocFlagReplaceDoc)

	// SubdocDocFlagAccessDeleted indicates that you wish to receive soft-deleted documents.
	SubdocDocFlagAccessDeleted = SubdocDocFlag(gocbcore.SubdocDocFlagAccessDeleted)
)
View Source 
const (
	// DurabilityLevelMajority specifies that a mutation must be replicated (held in memory) to a majority of nodes.
	DurabilityLevelMajority = DurabilityLevel(1)

	// DurabilityLevelMajorityAndPersistActive specifies that a mutation must be replicated (held in memory) to a
	// majority of nodes and also persisted (written to disk) on the active node.
	DurabilityLevelMajorityAndPersistActive = DurabilityLevel(2)

	// DurabilityLevelPersistToMajority specifies that a mutation must be persisted (written to disk) to a majority
	// of nodes.
	DurabilityLevelPersistToMajority = DurabilityLevel(3)
)
View Source 
const (
	LogError        = LogLevel(gocbcore.LogError)
	LogWarn         = LogLevel(gocbcore.LogWarn)
	LogInfo         = LogLevel(gocbcore.LogInfo)
	LogDebug        = LogLevel(gocbcore.LogDebug)
	LogTrace        = LogLevel(gocbcore.LogTrace)
	LogSched        = LogLevel(gocbcore.LogSched)
	LogMaxVerbosity = LogLevel(gocbcore.LogMaxVerbosity)
)

Various logging levels (or subsystems) which can categorize the message. Currently these are ordered in decreasing severity.

View Source 
const (
	// RedactNone indicates to perform no redactions
	RedactNone = LogRedactLevel(0)

	// RedactPartial indicates to redact all possible user-identifying information from logs.
	RedactPartial = LogRedactLevel(1)

	// RedactFull indicates to fully redact all possible identifying information from logs.
	RedactFull = LogRedactLevel(2)
)
View Source 
const (
	// NotBounded indicates no data consistency is required.
	NotBounded = ConsistencyMode(1)
	// RequestPlus indicates that request-level data consistency is required.
	RequestPlus = ConsistencyMode(2)
	// StatementPlus indicates that statement-level data consistency is required.
	StatementPlus = ConsistencyMode(3)
)
View Source 
const (
	// DefaultHighlightStyle specifies to use the default to highlight search result hits.
	DefaultHighlightStyle = SearchHighlightStyle("")

	// HtmlHighlightStyle specifies to use HTML tags to highlight search result hits.
	HtmlHighlightStyle = SearchHighlightStyle("html")

	// AnsiHightlightStyle specifies to use ANSI tags to highlight search result hits.
	AnsiHightlightStyle = SearchHighlightStyle("ansi")
)
View Source 
const (
	// Before indicates to update the index before querying it.
	Before = StaleMode(1)
	// None indicates that no special behaviour should be used.
	None = StaleMode(2)
	// After indicates to update the index asynchronously after querying.
	After = StaleMode(3)
)
View Source 
const (
	// Ascending indicates the query results should be sorted from lowest to highest.
	Ascending = SortOrder(1)
	// Descending indicates the query results should be sorted from highest to lowest.
	Descending = SortOrder(2)
)

Variables

View Source 
var (

	// ErrNoResults occurs when no results are available to a query.
	ErrNoResults = errors.New("No results returned.")
	// ErrNoOpenBuckets occurs when a cluster-level operation is performed before any buckets are opened.
	ErrNoOpenBuckets = errors.New("You must open a bucket before you can perform cluster level operations.")
	// ErrIndexInvalidName occurs when an invalid name was specified for an index.
	ErrIndexInvalidName = errors.New("An invalid index name was specified.")
	// ErrIndexNoFields occurs when an index with no fields is created.
	ErrIndexNoFields = errors.New("You must specify at least one field to index.")
	// ErrIndexNotFound occurs when an operation expects an index but it was not found.
	ErrIndexNotFound = errors.New("The index specified does not exist.")
	// ErrIndexAlreadyExists occurs when an operation expects an index not to exist, but it was found.
	ErrIndexAlreadyExists = errors.New("The index specified already exists.")
	// ErrFacetNoRanges occurs when a range-based facet is specified but no ranges were indicated.
	ErrFacetNoRanges = errors.New("At least one range must be specified on a facet.")

	// ErrSearchIndexInvalidName occurs when an invalid name was specified for a search index.
	ErrSearchIndexInvalidName = errors.New("An invalid search index name was specified.")
	// ErrSearchIndexMissingType occurs when no type was specified for a search index.
	ErrSearchIndexMissingType = errors.New("No search index type was specified.")
	// ErrSearchIndexInvalidSourceType occurs when an invalid source type was specific for a search index.
	ErrSearchIndexInvalidSourceType = errors.New("An invalid search index source type was specified.")
	// ErrSearchIndexInvalidSourceName occurs when an invalid source name was specific for a search index.
	ErrSearchIndexInvalidSourceName = errors.New("An invalid search index source name was specified.")
	// ErrSearchIndexAlreadyExists occurs when an invalid source name was specific for a search index.
	ErrSearchIndexAlreadyExists = errors.New("The search index specified already exists.")
	// ErrSearchIndexInvalidIngestControlOp occurs when an invalid ingest control op was specific for a search index.
	ErrSearchIndexInvalidIngestControlOp = errors.New("An invalid search index ingest control op was specified.")
	// ErrSearchIndexInvalidQueryControlOp occurs when an invalid query control op was specific for a search index.
	ErrSearchIndexInvalidQueryControlOp = errors.New("An invalid search index query control op was specified.")
	// ErrSearchIndexInvalidPlanFreezeControlOp occurs when an invalid plan freeze control op was specific for a search index.
	ErrSearchIndexInvalidPlanFreezeControlOp = errors.New("An invalid search index plan freeze control op was specified.")

	// ErrDispatchFail occurs when we failed to execute an operation due to internal routing issues.
	ErrDispatchFail = gocbcore.ErrDispatchFail
	// ErrBadHosts occurs when an invalid list of hosts is specified for bootstrapping.
	ErrBadHosts = gocbcore.ErrBadHosts
	// ErrProtocol occurs when an invalid protocol is specified for bootstrapping.
	ErrProtocol = gocbcore.ErrProtocol
	// ErrNoReplicas occurs when an operation expecting replicas is performed, but no replicas are available.
	ErrNoReplicas = gocbcore.ErrNoReplicas
	// ErrInvalidServer occurs when a specified server index is invalid.
	ErrInvalidServer = gocbcore.ErrInvalidServer
	// ErrInvalidVBucket occurs when a specified vbucket index is invalid.
	ErrInvalidVBucket = gocbcore.ErrInvalidVBucket
	// ErrInvalidReplica occurs when a specified replica index is invalid.
	ErrInvalidReplica = gocbcore.ErrInvalidReplica
	// ErrInvalidCert occurs when the specified certificate is not valid.
	ErrInvalidCert = gocbcore.ErrInvalidCert
	// ErrInvalidCredentials is returned when an invalid set of credentials is provided for a service.
	ErrInvalidCredentials = gocbcore.ErrInvalidCredentials
	// ErrNonZeroCas occurs when an operation that require a CAS value of 0 is used with a non-zero value.
	ErrNonZeroCas = gocbcore.ErrNonZeroCas

	// ErrShutdown occurs when an operation is performed on a bucket that has been closed.
	ErrShutdown = gocbcore.ErrShutdown
	// ErrOverload occurs when more operations were dispatched than the client is capable of writing.
	ErrOverload = gocbcore.ErrOverload
)

Functions

func DefaultDecode 

func DefaultDecode(bytes []byte, flags uint32, out interface{}) error

DefaultDecode applies the default Couchbase transcoding behaviour to decode into a Go type.

func DefaultEncode 

func DefaultEncode(value interface{}) ([]byte, uint32, error)

DefaultEncode applies the default Couchbase transcoding behaviour to encode a Go type. For a byte array this will return the value supplied with Binary flags. For a string this will return the value supplied with String flags. For aanything else this will try to return the value JSON encoded supplied, with JSON flags.

func ErrorCause 

func ErrorCause(err error) error

ErrorCause returns the underlying cause of an error.

func ExponentialDelayFunction 

func ExponentialDelayFunction(retryDelay uint, retries uint) time.Duration

ExponentialDelayFunction provides retry delay durations (ms) following an exponential increment pattern

func IsAccessError 

func IsAccessError(err error) bool

IsAccessError verifies whether or not the cause for an error is an access error.

func IsAuthenticationError 

func IsAuthenticationError(err error) bool

IsAuthenticationError verifies whether or not the cause for an error is an authentication error.

func IsBucketMissingError 

func IsBucketMissingError(err error) bool

IsBucketMissingError verifies whether or not the cause for an error is a bucket missing error.

func IsCollectionMissingError 

func IsCollectionMissingError(err error) bool

IsCollectionMissingError verifies whether or not the cause for an error is scope unknown

func IsConfigurationError 

func IsConfigurationError(err error) bool

IsConfigurationError verifies whether or not the cause for an error is a configuration error.

func IsDurabilityError 

func IsDurabilityError(err error) bool

IsDurabilityError verifies whether or not the cause for an error is due to a durability error.

func IsHTTPError 

func IsHTTPError(err error) bool

IsHTTPError indicates whether the passed error is a HTTP error.

func IsInvalidRangeError 

func IsInvalidRangeError(err error) bool

IsInvalidRangeError indicates whether the passed error is a key-value "requested value is outside range" error.

func IsKeyExistsError 

func IsKeyExistsError(err error) bool

IsKeyExistsError indicates whether the passed error is a key-value "Key Already Exists" error.

func IsKeyLockedError 

func IsKeyLockedError(err error) bool

IsKeyLockedError indicates whether the passed error is a key-value operation failed due to the document being locked.

func IsKeyNotFoundError 

func IsKeyNotFoundError(err error) bool

IsKeyNotFoundError indicates whether the passed error is a key-value "Key Not Found" error.

func IsNetworkError 

func IsNetworkError(err error) bool

IsNetworkError indicates whether the passed error is a network error.

func IsPartialResultsError 

func IsPartialResultsError(err error) bool

IsPartialResultsError indicates whether or not the response returned error(s) but also contains data.

func IsPathExistsError 

func IsPathExistsError(err error) bool

IsPathExistsError indicates whether the passed error is a key-value "given path already exists in the document" error.

func IsPathNotFoundError 

func IsPathNotFoundError(err error) bool

IsPathNotFoundError indicates whether the passed error is a key-value "sub-document path does not exist" error.

func IsScopeMissingError 

func IsScopeMissingError(err error) bool

IsScopeMissingError verifies whether or not the cause for an error is scope unknown

func IsServiceNotFoundError 

func IsServiceNotFoundError(err error) bool

IsServiceNotFoundError indicates whether the passed error occurred due to the requested service not being found.

func IsSubdocPathExistsError 

func IsSubdocPathExistsError(err error) bool

IsSubdocPathExistsError verifies whether or not the cause for an error is due to a subdoc operation path exists

func IsSubdocPathNotFoundError 

func IsSubdocPathNotFoundError(err error) bool

IsSubdocPathNotFoundError verifies whether or not the cause for an error is due to a subdoc operation path not found.

func IsTempFailError 

func IsTempFailError(err error) bool

IsTempFailError indicates whether the passed error is a key-value "temporary failure, try again later" error.

func IsTimeoutError 

func IsTimeoutError(err error) bool

IsTimeoutError verifies whether or not the cause for an error is a timeout.

func IsValueTooBigError 

func IsValueTooBigError(err error) bool

IsValueTooBigError indicates whether the passed error is a key-value "document value was too large" error.

func JSONEncode 

func JSONEncode(value interface{}) ([]byte, uint32, error)

JSONEncode applies JSON encoding to a Go type. For strings and byte array data this will just return the value passed to it as bytes with flags set to JSON.

func LinearDelayFunction 

func LinearDelayFunction(retryDelay uint, retries uint) time.Duration

LinearDelayFunction provides retry delay durations (ms) following a linear increment pattern

func SetLogRedactionLevel 

func SetLogRedactionLevel(level LogRedactLevel)

SetLogRedactionLevel specifies the level with which logs should be redacted.

func SetLogger 

func SetLogger(logger Logger)

SetLogger sets a logger to be used by the library. A logger can be obtained via the DefaultStdioLogger() or VerboseStdioLogger() functions. You can also implement your own logger using the Logger interface.

func Version 

func Version() string

Version returns a string representation of the current SDK version.

Types

type AnalyticsDeferredResultHandle 

type AnalyticsDeferredResultHandle interface {
	One(valuePtr interface{}) error
	Next(valuePtr interface{}) bool
	NextBytes() []byte
	Close() error

	Status() (string, error)
}

AnalyticsDeferredResultHandle allows access to the handle of a deferred Analytics query.

Experimental: This API is subject to change at any time.

type AnalyticsQueryError 

type AnalyticsQueryError interface {
	error
	Code() uint32
	Message() string
}

AnalyticsQueryError occurs for errors created by Couchbase Server during Analytics query execution.

type AnalyticsQueryErrors 

type AnalyticsQueryErrors interface {
	error
	Errors() []AnalyticsQueryError
	HTTPStatus() int
	Endpoint() string
	ContextID() string
}

AnalyticsQueryErrors is a collection of one or more AnalyticsQueryError that occurs for errors created by Couchbase Server during Analytics query execution.

type AnalyticsQueryOptions 

type AnalyticsQueryOptions struct {
	ServerSideTimeout    time.Duration
	Context              context.Context
	ParentSpanContext    opentracing.SpanContext
	Pretty               bool
	ContextID            string
	RawParam             map[string]interface{}
	Priority             bool
	PositionalParameters []interface{}
	NamedParameters      map[string]interface{}

	// Experimental: This API is subject to change at any time.
	Deferred bool
}

AnalyticsQueryOptions is the set of options available to an Analytics query.

type AnalyticsResultMetrics 

type AnalyticsResultMetrics struct {
	ElapsedTime      time.Duration
	ExecutionTime    time.Duration
	ResultCount      uint
	ResultSize       uint
	MutationCount    uint
	SortCount        uint
	ErrorCount       uint
	WarningCount     uint
	ProcessedObjects uint
}

AnalyticsResultMetrics encapsulates various metrics gathered during a queries execution.

type AnalyticsResults 

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

AnalyticsResults allows access to the results of a Analytics query.

func (*AnalyticsResults) ClientContextID 

func (r *AnalyticsResults) ClientContextID() string

ClientContextID returns the context ID used for this query.

func (*AnalyticsResults) Close 

func (r *AnalyticsResults) Close() error

Close marks the results as closed, returning any errors that occurred during reading the results.

func (*AnalyticsResults) Handle 

func (r *AnalyticsResults) Handle() AnalyticsDeferredResultHandle

Handle returns a deferred result handle. This can be polled to verify whether the result is ready to be read.

Experimental: This API is subject to change at any time.

func (*AnalyticsResults) Metrics 

func (r *AnalyticsResults) Metrics() AnalyticsResultMetrics

Metrics returns metrics about execution of this result.

func (*AnalyticsResults) Next 

func (r *AnalyticsResults) Next(valuePtr interface{}) bool

Next assigns the next result from the results into the value pointer, returning whether the read was successful.

func (*AnalyticsResults) NextBytes 

func (r *AnalyticsResults) NextBytes() []byte

NextBytes returns the next result from the results as a byte array.

func (*AnalyticsResults) One 

func (r *AnalyticsResults) One(valuePtr interface{}) error

One assigns the first value from the results into the value pointer.

func (*AnalyticsResults) RequestID 

func (r *AnalyticsResults) RequestID() string

RequestID returns the request ID used for this query.

func (*AnalyticsResults) Signature 

func (r *AnalyticsResults) Signature() interface{}

Signature returns TODO

func (*AnalyticsResults) Status 

func (r *AnalyticsResults) Status() string

Status returns the status for the results.

func (*AnalyticsResults) Warnings 

func (r *AnalyticsResults) Warnings() []AnalyticsWarning

Warnings returns any warnings that occurred during query execution.

type AnalyticsWarning 

type AnalyticsWarning struct {
	Code    uint32 `json:"code"`
	Message string `json:"msg"`
}

AnalyticsWarning represents any warning generating during the execution of an Analytics query.

type AppendOptions 

type AppendOptions struct {
	ParentSpanContext opentracing.SpanContext
	Timeout           time.Duration
	Context           context.Context
}

AppendOptions are the options available to the Append operation.

type AuthCredsRequest 

type AuthCredsRequest struct {
	Service  ServiceType
	Endpoint string
	Bucket   string
}

AuthCredsRequest encapsulates the data for a credential request from the new Authenticator interface. UNCOMMITTED

type Authenticator 

type Authenticator interface {
	Credentials(req AuthCredsRequest) ([]UserPassPair, error)
}

Authenticator provides an interface to authenticate to each service. Note that only authenticators implemented here are stable, and support for custom authenticators is considered volatile.

type Bucket 

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

Bucket represents a single bucket within a cluster.

func (*Bucket) Collection 

func (b *Bucket) Collection(scopeName string, collectionName string, opts *CollectionOptions) *Collection

Collection returns an instance of a collection.

func (*Bucket) DefaultCollection 

func (b *Bucket) DefaultCollection(opts *CollectionOptions) *Collection

DefaultCollection returns an instance of the default collection.

func (*Bucket) Name 

func (b *Bucket) Name() string

Name returns the name of the bucket.

func (*Bucket) Scope 

func (b *Bucket) Scope(scopeName string) *Scope

Scope returns an instance of a Scope.

func (*Bucket) SpatialViewQuery 

func (b *Bucket) SpatialViewQuery(designDoc string, viewName string, opts *SpatialViewOptions) (*ViewResults, error)

SpatialViewQuery performs a spatial query and returns a list of rows or an error.

func (*Bucket) ViewQuery 

func (b *Bucket) ViewQuery(designDoc string, viewName string, opts *ViewOptions) (*ViewResults, error)

ViewQuery performs a view query and returns a list of rows or an error.

type BucketOptions 

type BucketOptions struct {
	UseMutationTokens bool
}

BucketOptions are the options available when connecting to a Bucket.

type Cas 

type Cas gocbcore.Cas

Cas represents the specific state of a document on the cluster.

type CertAuthenticator 

type CertAuthenticator struct {
}

CertAuthenticator implements an Authenticator which can be used with certificate authentication.

func (CertAuthenticator) Credentials 

func (ca CertAuthenticator) Credentials(req AuthCredsRequest) ([]UserPassPair, error)

Credentials returns the credentials for a particular service.

type Cluster 

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

Cluster represents a connection to a specific Couchbase cluster.

func NewCluster 

func NewCluster(connStr string, opts ClusterOptions) (*Cluster, error)

NewCluster creates and returns a Cluster instance created using the provided options and connection string. The connection string properties are copied from (and should stay in sync with) the gocbcore agent.FromConnStr comment. Supported connSpecStr options are: 

cacertpath (string) - Path to the CA certificate
certpath (string) - Path to your authentication certificate
keypath (string) - Path to your authentication key
config_total_timeout (int) - Maximum period to attempt to connect to cluster in ms.
config_node_timeout (int) - Maximum period to attempt to connect to a node in ms.
http_redial_period (int) - Maximum period to keep HTTP config connections open in ms.
http_retry_delay (int) - Period to wait between retrying nodes for HTTP config in ms.
config_poll_floor_interval (int) - Minimum time to wait between fetching configs via CCCP in ms.
config_poll_interval (int) - Period to wait between CCCP config polling in ms.
kv_pool_size (int) - The number of connections to establish per node.
max_queue_size (int) - The maximum size of the operation queues per node.
use_kverrmaps (bool) - Whether to enable error maps from the server.
use_enhanced_errors (bool) - Whether to enable enhanced error information.
fetch_mutation_tokens (bool) - Whether to fetch mutation tokens for operations.
compression (bool) - Whether to enable network-wise compression of documents.
compression_min_size (int) - The minimal size of the document to consider compression.
compression_min_ratio (float64) - The minimal compress ratio (compressed / original) for the document to be sent compressed.
server_duration (bool) - Whether to enable fetching server operation durations.
http_max_idle_conns (int) - Maximum number of idle http connections in the pool.
http_max_idle_conns_per_host (int) - Maximum number of idle http connections in the pool per host.
http_idle_conn_timeout (int) - Maximum length of time for an idle connection to stay in the pool in ms.
network (string) - The network type to use.
orphaned_response_logging (bool) - Whether to enable orphan response logging.
orphaned_response_logging_interval (int) - How often to log orphan responses in ms.
orphaned_response_logging_sample_size (int) - The number of samples to include in each orphaned response log.
operation_tracing (bool) - Whether to enable tracing.
n1ql_timeout (int) - Maximum execution time for n1ql queries in ms.
fts_timeout (int) - Maximum execution time for fts searches in ms.
analytics_timeout (int) - Maximum execution time for analytics queries in ms.

func (*Cluster) AnalyticsQuery 

func (c *Cluster) AnalyticsQuery(statement string, opts *AnalyticsQueryOptions) (*AnalyticsResults, error)

AnalyticsQuery performs an analytics query and returns a list of rows or an error.

func (*Cluster) Bucket 

func (c *Cluster) Bucket(bucketName string, opts *BucketOptions) *Bucket

Bucket connects the cluster to server(s) and returns a new Bucket instance.

func (*Cluster) Close 

func (c *Cluster) Close(opts *ClusterCloseOptions) error

Close shuts down all buckets in this cluster and invalidates any references this cluster has.

func (*Cluster) Query 

func (c *Cluster) Query(statement string, opts *QueryOptions) (*QueryResults, error)

Query executes the N1QL query statement on the server n1qlEp. This function assumes that `opts` already contains all the required settings. This function will inject any additional connection or request-level settings into the `opts` map (currently this is only the timeout).

func (*Cluster) SearchQuery 

func (c *Cluster) SearchQuery(q SearchQuery, opts *SearchQueryOptions) (*SearchResults, error)

SearchQuery performs a n1ql query and returns a list of rows or an error.

type ClusterCloseOptions 

type ClusterCloseOptions struct {
}

ClusterCloseOptions is the set of options available when disconnecting from a Cluster.

type ClusterOptions 

type ClusterOptions struct {
	Authenticator     Authenticator
	ConnectTimeout    time.Duration
	KVTimeout         time.Duration
	ViewTimeout       time.Duration
	QueryTimeout      time.Duration
	AnalyticsTimeout  time.Duration
	SearchTimeout     time.Duration
	ManagementTimeout time.Duration
	EnableTracing     bool
}

ClusterOptions is the set of options available for creating a Cluster.

type Collection 

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

Collection represents a single collection.

func (*Collection) Binary 

func (c *Collection) Binary() *CollectionBinary

Binary creates and returns a CollectionBinary object.

func (*Collection) Exists 

func (c *Collection) Exists(key string, opts *ExistsOptions) (docOut *ExistsResult, errOut error)

Exists checks if a document exists for the given key.

func (*Collection) Get 

func (c *Collection) Get(key string, opts *GetOptions) (docOut *GetResult, errOut error)

Get performs a fetch operation against the collection. This can take 3 paths, a standard full document fetch, a subdocument full document fetch also fetching document expiry (when WithExpiry is set), or a subdocument fetch (when Project is used).

func (*Collection) GetAndLock 

func (c *Collection) GetAndLock(key string, expiration uint32, opts *GetAndLockOptions) (docOut *GetResult, errOut error)

GetAndLock locks a document for a period of time, providing exclusive RW access to it.

func (*Collection) GetAndTouch 

func (c *Collection) GetAndTouch(key string, expiration uint32, opts *GetAndTouchOptions) (docOut *GetResult, errOut error)

GetAndTouch retrieves a document and simultaneously updates its expiry time.

func (*Collection) GetFromReplica 

func (c *Collection) GetFromReplica(key string, replicaIdx int, opts *GetFromReplicaOptions) (docOut *GetResult, errOut error)

GetFromReplica returns the value of a particular document from a replica server..

func (*Collection) Insert 

func (c *Collection) Insert(key string, val interface{}, opts *InsertOptions) (mutOut *MutationResult, errOut error)

Insert creates a new document in the Collection.

func (*Collection) LookupIn 

func (c *Collection) LookupIn(key string, ops []LookupInOp, opts *LookupInOptions) (docOut *LookupInResult, errOut error)

LookupIn performs a set of subdocument lookup operations on the document identified by key.

func (*Collection) Mutate 

func (c *Collection) Mutate(key string, ops []MutateInOp, opts *MutateInOptions) (mutOut *MutateInResult, errOut error)

Mutate performs a set of subdocument mutations on the document specified by key.

func (*Collection) Remove 

func (c *Collection) Remove(key string, opts *RemoveOptions) (mutOut *MutationResult, errOut error)

Remove removes a document from the collection.

func (*Collection) Replace 

func (c *Collection) Replace(key string, val interface{}, opts *ReplaceOptions) (mutOut *MutationResult, errOut error)

Replace updates a document in the collection.

func (*Collection) Touch 

func (c *Collection) Touch(key string, expiration uint32, opts *TouchOptions) (mutOut *MutationResult, errOut error)

Touch touches a document, specifying a new expiry time for it.

func (*Collection) Unlock 

func (c *Collection) Unlock(key string, opts *UnlockOptions) (mutOut *MutationResult, errOut error)

Unlock unlocks a document which was locked with GetAndLock.

func (*Collection) Upsert 

func (c *Collection) Upsert(key string, val interface{}, opts *UpsertOptions) (mutOut *MutationResult, errOut error)

Upsert creates a new document in the Collection if it does not exist, if it does exist then it updates it.

type CollectionBinary 

type CollectionBinary struct {
	*Collection
}

CollectionBinary is a set of binary operations.

func (*CollectionBinary) Append 

func (c *CollectionBinary) Append(key string, val []byte, opts *AppendOptions) (mutOut *MutationResult, errOut error)

Append appends a byte value to a document.

func (*CollectionBinary) Decrement 

func (c *CollectionBinary) Decrement(key string, opts *CounterOptions) (countOut *CounterResult, errOut error)

Decrement performs an atomic subtraction for an integer document. Passing a non-negative `initial` value will cause the document to be created if it did not already exist.

func (*CollectionBinary) Increment 

func (c *CollectionBinary) Increment(key string, opts *CounterOptions) (countOut *CounterResult, errOut error)

Increment performs an atomic addition for an integer document. Passing a non-negative `initial` value will cause the document to be created if it did not already exist.

func (*CollectionBinary) Prepend 

func (c *CollectionBinary) Prepend(key string, val []byte, opts *PrependOptions) (mutOut *MutationResult, errOut error)

Prepend prepends a byte value to a document.

type CollectionOptions 

type CollectionOptions struct {
	ParentSpanContext opentracing.SpanContext
	Timeout           time.Duration
	Context           context.Context
}

CollectionOptions are the options available when opening a collection.

type ConfigurationError 

type ConfigurationError interface {
	error
	ConfigurationError() bool
}

ConfigurationError occurs when the client is configured incorrectly.

type ConsistencyMode 

type ConsistencyMode int

ConsistencyMode indicates the level of data consistency desired for a query.

type CounterOptions 

type CounterOptions struct {
	ParentSpanContext opentracing.SpanContext
	Timeout           time.Duration
	Context           context.Context
	// Expiration is the length of time in seconds that the document will be stored in Couchbase.
	// A value of 0 will set the document to never expire.
	Expiration uint32
	// Initial, if non-negative, is the `initial` value to use for the document if it does not exist.
	// If present, this is the value that will be returned by a successful operation.
	Initial int64
	// Delta is the value to use for incrementing/decrementing if Initial is not present.
	Delta uint64
}

CounterOptions are the options available to the Counter operation.

type CounterResult 

type CounterResult struct {
	MutationResult
	// contains filtered or unexported fields
}

CounterResult is the return type of counter operations.

func (CounterResult) Cas 

func (mr CounterResult) Cas() Cas

Cas returns the Cas value for a document following an operation.

func (CounterResult) Content 

func (mr CounterResult) Content() uint64

Content returns the new value for the counter document.

func (CounterResult) MutationToken 

func (mr CounterResult) MutationToken() MutationToken

MutationToken returns the mutation token belonging to an operation.

type Decode 

type Decode func([]byte, uint32, interface{}) error

Decode retrieved bytes into a Go type.

type DelayRetryBehavior 

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

DelayRetryBehavior provides the behavior to use when retrying queries with a backoff delay

func StandardDelayRetryBehavior 

func StandardDelayRetryBehavior(maxRetries uint, retryDelay uint, delayLimit time.Duration, delayFunc RetryDelayFunction) *DelayRetryBehavior

StandardDelayRetryBehavior provides a DelayRetryBehavior that will retry at most maxRetries number of times and with an initial retry delay of retryDelay (ms) up to a maximum delay of delayLimit

func (*DelayRetryBehavior) CanRetry 

func (rb *DelayRetryBehavior) CanRetry(retries uint) bool

CanRetry determines whether or not the query can be retried according to the behavior

func (*DelayRetryBehavior) NextInterval 

func (rb *DelayRetryBehavior) NextInterval(retries uint) time.Duration

NextInterval calculates what the next retry interval (ms) should be given how many retries there have been already

type DurabilityError 

type DurabilityError interface {
	DurabilityError() bool
}

DurabilityError occurs when an error occurs during performing durability operations.

type DurabilityLevel 

type DurabilityLevel uint8

DurabilityLevel specifies the level of synchronous replication to use.

type Encode 

type Encode func(interface{}) ([]byte, uint32, error)

Encode a Go type into bytes for storage.

type ExistsOptions 

type ExistsOptions struct {
	ParentSpanContext opentracing.SpanContext
	Timeout           time.Duration
	Context           context.Context
}

ExistsOptions are the options available to the Exists command.

type ExistsResult 

type ExistsResult struct {
	Result
	// contains filtered or unexported fields
}

ExistsResult is the return type of Exist operations.

func (*ExistsResult) Exists 

func (d *ExistsResult) Exists() bool

Exists returns whether or not the document exists.

type GetAndLockOptions 

type GetAndLockOptions struct {
	ParentSpanContext opentracing.SpanContext
	Timeout           time.Duration
	Context           context.Context
}

GetAndLockOptions are the options available to the GetAndLock operation.

type GetAndTouchOptions 

type GetAndTouchOptions struct {
	ParentSpanContext opentracing.SpanContext
	Timeout           time.Duration
	Context           context.Context
}

GetAndTouchOptions are the options available to the GetAndTouch operation.

type GetFromReplicaOptions 

type GetFromReplicaOptions struct {
	ParentSpanContext opentracing.SpanContext
	Timeout           time.Duration
	Context           context.Context
}

GetFromReplicaOptions are the options available to the GetFromReplica command.

type GetOptions 

type GetOptions struct {
	ParentSpanContext opentracing.SpanContext
	Timeout           time.Duration
	Context           context.Context
	WithExpiry        bool
	// Project causes the Get operation to only fetch the fields indicated
	// by the paths. The result of the operation is then treated as a
	// standard GetResult.
	Project *ProjectOptions
}

GetOptions are the options available to a Get operation.

type GetResult 

type GetResult struct {
	Result
	// contains filtered or unexported fields
}

GetResult is the return type of Get operations.

func (*GetResult) Content 

func (d *GetResult) Content(valuePtr interface{}) error

Content assigns the value of the result into the valuePtr using default decoding.

func (*GetResult) Decode 

func (d *GetResult) Decode(valuePtr interface{}, decode Decode) error

Decode assigns the value of the result into the valuePtr using the decode function specified.

type HTTPError 

type HTTPError interface {
	error
	StatusCode() int
	HTTPError() bool
	// contains filtered or unexported methods
}

HTTPError occurs when there is a http error.

type IndexType 

type IndexType string

IndexType provides information on the type of indexer used for an index.

type InsertOptions 

type InsertOptions struct {
	ParentSpanContext opentracing.SpanContext
	Timeout           time.Duration
	Context           context.Context
	// The expiration length in seconds
	Expiration      uint32
	PersistTo       uint
	ReplicateTo     uint
	DurabilityLevel DurabilityLevel
	Encoder         Encode
}

InsertOptions are options that can be applied to an Insert operation.

type KeyValueError 

type KeyValueError interface {
	error
	ID() string
	StatusCode() int // ?
	Opaque() uint32
	KVError() bool
}

KeyValueError represents an error that occurred while executing a K/V operation. Assumes that the service has returned a response.

type LogLevel 

type LogLevel gocbcore.LogLevel

LogLevel specifies the severity of a log message.

type LogRedactLevel 

type LogRedactLevel int

LogRedactLevel specifies the degree with which to redact the logs.

type Logger 

type Logger interface {
	// Outputs logging information:
	// level is the verbosity level
	// offset is the position within the calling stack from which the message
	// originated. This is useful for contextual loggers which retrieve file/line
	// information.
	Log(level LogLevel, offset int, format string, v ...interface{}) error
}

Logger defines a logging interface. You can either use one of the default loggers (DefaultStdioLogger(), VerboseStdioLogger()) or implement your own.

func DefaultStdioLogger 

func DefaultStdioLogger() Logger

DefaultStdioLogger gets the default standard I/O logger. 

gocb.SetLogger(gocb.DefaultStdioLogger())

func VerboseStdioLogger 

func VerboseStdioLogger() Logger

VerboseStdioLogger is a more verbose level of DefaultStdioLogger(). Messages pertaining to the scheduling of ordinary commands (and their responses) will also be emitted. 

gocb.SetLogger(gocb.VerboseStdioLogger())

type LookupInOp 

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

LookupInOp is the representation of an operation available when calling LookupIn

type LookupInOptions 

type LookupInOptions struct {
	Context           context.Context
	Timeout           time.Duration
	ParentSpanContext opentracing.SpanContext
	WithExpiry        bool
}

LookupInOptions are the set of options available to LookupIn.

type LookupInResult 

type LookupInResult struct {
	Result
	// contains filtered or unexported fields
}

LookupInResult is the return type for LookupIn.

func (*LookupInResult) ContentAt 

func (lir *LookupInResult) ContentAt(idx int, valuePtr interface{}) error

ContentAt retrieves the value of the operation by its index. The index is the position of the operation as it was added to the builder.

func (*LookupInResult) Exists 

func (lir *LookupInResult) Exists(idx int) bool

Exists verifies that the item at idx exists.

type LookupInSpec 

type LookupInSpec struct {
}

LookupInSpec provides a way to create LookupInOps.

func (LookupInSpec) Count 

func (spec LookupInSpec) Count(path string) LookupInOp

Count allows you to retrieve the number of items in an array or keys within an dictionary within an element of a document.

func (LookupInSpec) Exists 

func (spec LookupInSpec) Exists(path string) LookupInOp

Exists is similar to Path(), but does not actually retrieve the value from the server. This may save bandwidth if you only need to check for the existence of a path (without caring for its content). You can check the status of this operation by using .ContentAt (and ignoring the value) or .Exists() on the LookupResult.

func (LookupInSpec) Get 

func (spec LookupInSpec) Get(path string) LookupInOp

Get indicates a path to be retrieved from the document. The value of the path can later be retrieved from the LookupResult. The path syntax follows N1QL's path syntax (e.g. `foo.bar.baz`).

func (LookupInSpec) XAttr 

func (spec LookupInSpec) XAttr(path string) LookupInOp

XAttr indicates an extended attribute to be retrieved from the document. The value of the path can later be retrieved from the LookupResult. The path syntax follows N1QL's path syntax (e.g. `foo.bar.baz`).

type MutateInOp 

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

MutateInOp is the representation of an operation available when calling MutateIn

type MutateInOptions 

type MutateInOptions struct {
	ParentSpanContext opentracing.SpanContext
	Timeout           time.Duration
	Context           context.Context
	Expiration        uint32
	Cas               Cas
	PersistTo         uint
	ReplicateTo       uint
	DurabilityLevel   DurabilityLevel
	CreateDocument    bool
}

MutateInOptions are the set of options available to MutateIn.

type MutateInResult 

type MutateInResult struct {
	MutationResult
	// contains filtered or unexported fields
}

MutateInResult is the return type of any mutate in related operations. It contains Cas, mutation tokens and any returned content.

func (MutateInResult) ContentAt 

func (mir MutateInResult) ContentAt(idx int, valuePtr interface{}) error

ContentAt retrieves the value of the operation by its index. The index is the position of the operation as it was added to the builder.

type MutateInSpec 

type MutateInSpec struct {
}

MutateInSpec provides a way to create MutateInOps.

func (MutateInSpec) ArrayAddUnique 

func (spec MutateInSpec) ArrayAddUnique(path string, bytes []byte, opts *MutateInSpecArrayAddUniqueOptions) (*MutateInOp, error)

ArrayAddUnique adds an dictionary add unique operation to this mutation operation set.

func (MutateInSpec) ArrayAppend 

func (spec MutateInSpec) ArrayAppend(path string, bytes []byte, opts *MutateInSpecArrayAppendOptions) (*MutateInOp, error)

ArrayAppend adds an element to the end (i.e. right) of an array

func (MutateInSpec) ArrayInsert 

func (spec MutateInSpec) ArrayInsert(path string, bytes []byte, opts *MutateInSpecArrayInsertOptions) (*MutateInOp, error)

ArrayInsert inserts an element at a given position within an array. The position should be specified as part of the path, e.g. path.to.array[3]

func (MutateInSpec) ArrayPrepend 

func (spec MutateInSpec) ArrayPrepend(path string, bytes []byte, opts *MutateInSpecArrayPrependOptions) (*MutateInOp, error)

ArrayPrepend adds an element to the beginning (i.e. left) of an array

func (MutateInSpec) Decrement 

func (spec MutateInSpec) Decrement(path string, delta int64, opts *MutateInSpecCounterOptions) (*MutateInOp, error)

Decrement adds a decrement operation to this mutation operation set.

func (MutateInSpec) Increment 

func (spec MutateInSpec) Increment(path string, delta int64, opts *MutateInSpecCounterOptions) (*MutateInOp, error)

Increment adds an increment operation to this mutation operation set.

func (MutateInSpec) Insert 

func (spec MutateInSpec) Insert(path string, val interface{}, opts *MutateInSpecInsertOptions) (*MutateInOp, error)

Insert inserts a value at the specified path within the document, optionally creating the document first.

func (MutateInSpec) Remove 

func (spec MutateInSpec) Remove(path string, opts *MutateInSpecRemoveOptions) (*MutateInOp, error)

Remove removes the field at path.

func (MutateInSpec) Replace 

func (spec MutateInSpec) Replace(path string, val interface{}, opts *MutateInSpecReplaceOptions) (*MutateInOp, error)

Replace replaces the value of the field at path.

func (MutateInSpec) Upsert 

func (spec MutateInSpec) Upsert(path string, val interface{}, opts *MutateInSpecUpsertOptions) (*MutateInOp, error)

Upsert creates a new value at the specified path within the document if it does not exist, if it does exist then it updates it.

type MutateInSpecArrayAddUniqueOptions 

type MutateInSpecArrayAddUniqueOptions struct {
	CreateParents bool
	IsXattr       bool
}

MutateInSpecArrayAddUniqueOptions are the options available to subdocument ArrayAddUnique operations.

type MutateInSpecArrayAppendOptions 

type MutateInSpecArrayAppendOptions struct {
	CreateParents bool
	IsXattr       bool
}

MutateInSpecArrayAppendOptions are the options available to subdocument ArrayAppend operations.

type MutateInSpecArrayInsertOptions 

type MutateInSpecArrayInsertOptions struct {
	CreateParents bool
	IsXattr       bool
}

MutateInSpecArrayInsertOptions are the options available to subdocument ArrayInsert operations.

type MutateInSpecArrayPrependOptions 

type MutateInSpecArrayPrependOptions struct {
	CreateParents bool
	IsXattr       bool
}

MutateInSpecArrayPrependOptions are the options available to subdocument ArrayPrepend operations.

type MutateInSpecCounterOptions 

type MutateInSpecCounterOptions struct {
	CreateParents bool
	IsXattr       bool
}

MutateInSpecCounterOptions are the options available to subdocument Increment and Decrement operations.

type MutateInSpecInsertOptions 

type MutateInSpecInsertOptions struct {
	CreateParents bool
	IsXattr       bool
}

MutateInSpecInsertOptions are the options available to subdocument Insert operations.

type MutateInSpecRemoveOptions 

type MutateInSpecRemoveOptions struct {
	IsXattr bool
}

MutateInSpecRemoveOptions are the options available to subdocument Remove operations.

type MutateInSpecReplaceOptions 

type MutateInSpecReplaceOptions struct {
	IsXattr bool
}

MutateInSpecReplaceOptions are the options available to subdocument Replace operations.

type MutateInSpecUpsertOptions 

type MutateInSpecUpsertOptions struct {
	CreateParents bool
	IsXattr       bool
}

MutateInSpecUpsertOptions are the options available to subdocument Upsert operations.

type MutationResult 

type MutationResult struct {
	Result
	// contains filtered or unexported fields
}

MutationResult is the return type of any store related operations. It contains Cas and mutation tokens.

func (MutationResult) MutationToken 

func (mr MutationResult) MutationToken() MutationToken

MutationToken returns the mutation token belonging to an operation.

type MutationState 

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

MutationState holds and aggregates MutationToken's across multiple operations.

func NewMutationState 

func NewMutationState(tokens ...MutationToken) *MutationState

NewMutationState creates a new MutationState for tracking mutation state.

func (*MutationState) Add 

func (mt *MutationState) Add(tokens ...MutationToken)

Add includes an operation's mutation information in this mutation state.

func (*MutationState) MarshalJSON 

func (mt *MutationState) MarshalJSON() ([]byte, error)

MarshalJSON marshal's this mutation state to JSON.

func (*MutationState) UnmarshalJSON 

func (mt *MutationState) UnmarshalJSON(data []byte) error

UnmarshalJSON unmarshal's a mutation state from JSON.

type MutationToken 

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

MutationToken holds the mutation state information from an operation.

type NetworkError 

type NetworkError interface {
	error
	NetworkError() bool
	// contains filtered or unexported methods
}

NetworkError occurs when there is a network error.

type NodeManager 

type NodeManager struct {
}

NodeManager is used for management of nodes in the cluster.

type PartialResultError 

type PartialResultError interface {
	PartialResults() bool
}

PartialResultError indicates that an error occurred but that data was also returned.

type PasswordAuthenticator 

type PasswordAuthenticator struct {
	Username string
	Password string
}

PasswordAuthenticator implements an Authenticator which uses an RBAC username and password.

func (PasswordAuthenticator) Credentials 

func (ra PasswordAuthenticator) Credentials(req AuthCredsRequest) ([]UserPassPair, error)

Credentials returns the credentials for a particular service.

type PrependOptions 

type PrependOptions struct {
	ParentSpanContext opentracing.SpanContext
	Timeout           time.Duration
	Context           context.Context
}

PrependOptions are the options available to the Prepend operation.

type ProjectOptions 

type ProjectOptions struct {
	Fields                 []string
	IgnorePathMissingError bool
}

ProjectOptions are the options for using projections as a part of a Get request.

type ProjectionErrors 

type ProjectionErrors interface {
	error
	Errors() []KeyValueError
	ProjectionErrors() bool
}

ProjectionErrors is a collection of one or more KeyValueError that occurs during a Get with projections operation.

type QueryError 

type QueryError interface {
	error
	Code() uint32
	Message() string
}

QueryError occurs for errors created by Couchbase Server during N1ql query execution.

type QueryErrors 

type QueryErrors interface {
	error
	Errors() []QueryError
	HTTPStatus() int
	Endpoint() string
	ContextID() string
}

QueryErrors is a collection of one or more QueryError that occurs for errors created by Couchbase Server during N1ql query execution.

type QueryOptions 

type QueryOptions struct {
	Consistency    ConsistencyMode
	ConsistentWith *MutationState
	Prepared       bool
	Profile        QueryProfileType
	// ScanCap specifies the maximum buffered channel size between the indexer
	// client and the query service for index scans. This parameter controls
	// when to use scan backfill. Use a negative number to disable.
	ScanCap int
	// PipelineBatch controls the number of items execution operators can
	// batch for fetch from the KV node.
	PipelineBatch int
	// PipelineCap controls the maximum number of items each execution operator
	// can buffer between various operators.
	PipelineCap int
	// ReadOnly controls whether a query can change a resulting recordset.  If
	// readonly is true, then only SELECT statements are permitted.
	ReadOnly             bool
	Timeout              time.Duration
	PositionalParameters []interface{}
	NamedParameters      map[string]interface{}
	Context              context.Context
	ParentSpanContext    opentracing.SpanContext
	// Custom allows specifying custom query options.
	Custom map[string]interface{}
}

QueryOptions represents the options available when executing a N1QL query.

type QueryProfileType 

type QueryProfileType string

QueryProfileType specifies the profiling mode to use during a query.

type QueryResultMetrics 

type QueryResultMetrics struct {
	ElapsedTime   time.Duration
	ExecutionTime time.Duration
	ResultCount   uint
	ResultSize    uint
	MutationCount uint
	SortCount     uint
	ErrorCount    uint
	WarningCount  uint
}

QueryResultMetrics encapsulates various metrics gathered during a queries execution.

type QueryResults 

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

QueryResults allows access to the results of a N1QL query.

func (*QueryResults) ClientContextID 

func (r *QueryResults) ClientContextID() string

ClientContextID returns the context ID used for this query.

func (*QueryResults) Close 

func (r *QueryResults) Close() error

Close marks the results as closed, returning any errors that occurred during reading the results.

func (*QueryResults) Metrics 

func (r *QueryResults) Metrics() QueryResultMetrics

Metrics returns metrics about execution of this result.

func (*QueryResults) Next 

func (r *QueryResults) Next(valuePtr interface{}) bool

Next assigns the next result from the results into the value pointer, returning whether the read was successful.

func (*QueryResults) NextBytes 

func (r *QueryResults) NextBytes() []byte

NextBytes returns the next result from the results as a byte array.

func (*QueryResults) One 

func (r *QueryResults) One(valuePtr interface{}) error

One assigns the first value from the results into the value pointer.

func (*QueryResults) RequestID 

func (r *QueryResults) RequestID() string

RequestID returns the request ID used for this query.

func (*QueryResults) SourceEndpoint 

func (r *QueryResults) SourceEndpoint() string

SourceEndpoint returns the endpoint used for execution of this query. VOLATILE

type Range 

type Range struct {
	Start        interface{}
	End          interface{}
	InclusiveEnd bool
}

Range specifies a value range to get results between.

type RemoveOptions 

type RemoveOptions struct {
	ParentSpanContext opentracing.SpanContext
	Timeout           time.Duration
	Context           context.Context
	Cas               Cas
	PersistTo         uint
	ReplicateTo       uint
	DurabilityLevel   DurabilityLevel
}

RemoveOptions are the options available to the Remove command.

type ReplaceOptions 

type ReplaceOptions struct {
	ParentSpanContext opentracing.SpanContext
	Timeout           time.Duration
	Context           context.Context
	Expiration        uint32
	Cas               Cas
	PersistTo         uint
	ReplicateTo       uint
	DurabilityLevel   DurabilityLevel
	Encoder           Encode
}

ReplaceOptions are the options available to a Replace operation.

type Result 

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

Result is the base type for the return types of operations

func (*Result) Cas 

func (d *Result) Cas() Cas

Cas returns the cas of the result.

func (*Result) Expiration 

func (d *Result) Expiration() uint32

Expiration returns the expiration value for the result.

func (*Result) HasExpiration 

func (d *Result) HasExpiration() bool

HasExpiration verifies whether or not the result has an expiration value.

type RetryBehavior 

type RetryBehavior interface {
	NextInterval(retries uint) time.Duration
	CanRetry(retries uint) bool
}

RetryBehavior defines the behavior to be used for retries

type RetryDelayFunction 

type RetryDelayFunction func(retryDelay uint, retries uint) time.Duration

RetryDelayFunction is called to get the next try delay

type Scope 

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

Scope represents a single scope within a bucket.

func (*Scope) Collection 

func (s *Scope) Collection(collectionName string, opts *CollectionOptions) *Collection

Collection returns an instance of a collection.

func (*Scope) DefaultCollection 

func (s *Scope) DefaultCollection(opts *CollectionOptions) *Collection

DefaultCollection returns an instance of the default collection.

type SearchError 

type SearchError interface {
	error
	Message() string
}

SearchError occurs for errors created by Couchbase Server during Search query execution.

type SearchErrors 

type SearchErrors interface {
	error
	Errors() []SearchError
	HTTPStatus() int
	Endpoint() string
	ContextID() string
	PartialResults() bool
}

SearchErrors is a collection of one or more SearchError that occurs for errors created by Couchbase Server during Search query execution.

type SearchHighlightOptions 

type SearchHighlightOptions struct {
	Style  SearchHighlightStyle
	Fields []string
}

SearchHighlightOptions are the options available for search highlighting.

type SearchHighlightStyle 

type SearchHighlightStyle string

SearchHighlightStyle indicates the type of highlighting to use for a search query.

type SearchQuery 

type SearchQuery struct {
	Name  string
	Query interface{}
}

SearchQuery represents a pending search query.

type SearchQueryOptions 

type SearchQueryOptions struct {
	Limit             int
	Skip              int
	Explain           bool
	Highlight         *SearchHighlightOptions
	Fields            []string
	Sort              []interface{}
	Facets            map[string]interface{}
	Timeout           time.Duration
	Consistency       ConsistencyMode
	ConsistentWith    *MutationState
	Context           context.Context
	ParentSpanContext opentracing.SpanContext
}

SearchQueryOptions represents a pending search query.

type SearchResultDateFacet 

type SearchResultDateFacet struct {
	Name  string `json:"name,omitempty"`
	Min   string `json:"min,omitempty"`
	Max   string `json:"max,omitempty"`
	Count int    `json:"count,omitempty"`
}

SearchResultDateFacet holds the results of a date facet in search results.

type SearchResultFacet 

type SearchResultFacet struct {
	Field         string                     `json:"field,omitempty"`
	Total         int                        `json:"total,omitempty"`
	Missing       int                        `json:"missing,omitempty"`
	Other         int                        `json:"other,omitempty"`
	Terms         []SearchResultTermFacet    `json:"terms,omitempty"`
	NumericRanges []SearchResultNumericFacet `json:"numeric_ranges,omitempty"`
	DateRanges    []SearchResultDateFacet    `json:"date_ranges,omitempty"`
}

SearchResultFacet holds the results of a specified facet in search results.

type SearchResultHit 

type SearchResultHit struct {
	Index       string                                       `json:"index,omitempty"`
	Id          string                                       `json:"id,omitempty"`
	Score       float64                                      `json:"score,omitempty"`
	Explanation map[string]interface{}                       `json:"explanation,omitempty"`
	Locations   map[string]map[string][]SearchResultLocation `json:"locations,omitempty"`
	Fragments   map[string][]string                          `json:"fragments,omitempty"`
	Fields      map[string]interface{}                       `json:"fields,omitempty"`
}

SearchResultHit holds a single hit in a list of search results.

type SearchResultLocation 

type SearchResultLocation struct {
	Position       int    `json:"position,omitempty"`
	Start          int    `json:"start,omitempty"`
	End            int    `json:"end,omitempty"`
	ArrayPositions []uint `json:"array_positions,omitempty"`
}

SearchResultLocation holds the location of a hit in a list of search results.

type SearchResultNumericFacet 

type SearchResultNumericFacet struct {
	Name  string  `json:"name,omitempty"`
	Min   float64 `json:"min,omitempty"`
	Max   float64 `json:"max,omitempty"`
	Count int     `json:"count,omitempty"`
}

SearchResultNumericFacet holds the results of a numeric facet in search results.

type SearchResultStatus 

type SearchResultStatus struct {
	Total      int `json:"total,omitempty"`
	Failed     int `json:"failed,omitempty"`
	Successful int `json:"successful,omitempty"`
}

SearchResultStatus holds the status information for an executed search query.

type SearchResultTermFacet 

type SearchResultTermFacet struct {
	Term  string `json:"term,omitempty"`
	Count int    `json:"count,omitempty"`
}

SearchResultTermFacet holds the results of a term facet in search results.

type SearchResults 

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

SearchResults allows access to the results of a search query.

func (SearchResults) Facets 

func (r SearchResults) Facets() map[string]SearchResultFacet

Facets contains the information relative to the facets requested in the search query.

func (SearchResults) Hits 

func (r SearchResults) Hits() []SearchResultHit

Hits are the matches for the search query.

func (SearchResults) MaxScore 

func (r SearchResults) MaxScore() float64

MaxScore returns the highest score of all documents for this query.

func (SearchResults) Status 

func (r SearchResults) Status() SearchResultStatus

Status is the status information for the results.

func (SearchResults) Took 

func (r SearchResults) Took() time.Duration

Took returns the time taken to execute the search.

func (SearchResults) TotalHits 

func (r SearchResults) TotalHits() int

TotalHits is the actual number of hits before the limit was applied.

type ServiceNotFoundError 

type ServiceNotFoundError interface {
	error
	ServiceNotFoundError() bool
}

ServiceNotFoundError is a generic error for HTTP errors.

type ServiceType 

type ServiceType gocbcore.ServiceType

ServiceType specifies a particular Couchbase service type.

type SortOrder 

type SortOrder int

SortOrder specifies the ordering for the view queries results.

type SpatialViewOptions 

type SpatialViewOptions struct {
	Stale StaleMode
	Skip  uint
	Limit uint
	// Bbox specifies the bounding region to use for the spatial query.
	Bbox              []float64
	Development       bool
	Custom            map[string]string
	Context           context.Context
	ParentSpanContext opentracing.SpanContext
}

SpatialViewOptions represents the options available when executing a spatial query.

type StaleMode 

type StaleMode int

StaleMode specifies the consistency required for a view query.

type SubdocDocFlag 

type SubdocDocFlag gocbcore.SubdocDocFlag

SubdocDocFlag specifies document-level flags for a sub-document operation.

type SubdocFlag 

type SubdocFlag gocbcore.SubdocFlag

SubdocFlag provides special handling flags for sub-document operations

type TimeoutError 

type TimeoutError interface {
	Timeout() bool
}

TimeoutError occurs when an operation times out.

type TouchOptions 

type TouchOptions struct {
	ParentSpanContext opentracing.SpanContext
	Timeout           time.Duration
	Context           context.Context
}

TouchOptions are the options available to the Touch operation.

type UnlockOptions 

type UnlockOptions struct {
	ParentSpanContext opentracing.SpanContext
	Timeout           time.Duration
	Context           context.Context
	Cas               Cas
}

UnlockOptions are the options available to the GetAndLock operation.

type UpsertOptions 

type UpsertOptions struct {
	ParentSpanContext opentracing.SpanContext
	Timeout           time.Duration
	Context           context.Context
	// The expiration length in seconds
	Expiration      uint32
	PersistTo       uint
	ReplicateTo     uint
	DurabilityLevel DurabilityLevel
	Encoder         Encode
}

UpsertOptions are options that can be applied to an Upsert operation.

type UserPassPair 

type UserPassPair gocbcore.UserPassPair

UserPassPair represents a username and password pair.

type ViewOptions 

type ViewOptions struct {
	Stale             StaleMode
	Skip              uint
	Limit             uint
	Order             SortOrder
	Reduce            bool
	Group             bool
	GroupLevel        uint
	Key               interface{}
	Keys              []interface{}
	Range             *Range
	IDRangeStart      string
	IDRangeEnd        string
	Development       bool
	Custom            map[string]string
	Context           context.Context
	ParentSpanContext opentracing.SpanContext
}

ViewOptions represents the options available when executing view query.

type ViewQueryError 

type ViewQueryError interface {
	error
	Reason() string
	Message() string
}

ViewQueryError is the error type for an error that occurs during view query execution.

type ViewQueryErrors 

type ViewQueryErrors interface {
	error
	Errors() []ViewQueryError
	HTTPStatus() int
	Endpoint() string
	PartialResults() bool
}

ViewQueryErrors is a collection of one or more ViewQueryError that occurs for errors created by Couchbase Server during View query execution.

type ViewResults 

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

ViewResults implements an iterator interface which can be used to iterate over the rows of the query results.

func (*ViewResults) Close 

func (r *ViewResults) Close() error

Close closes the results returning any errors that occurred during iteration.

func (*ViewResults) Next 

func (r *ViewResults) Next(valuePtr interface{}) bool

Next performs a JSON unmarshal on the next row in the results to the specified value pointer.

func (*ViewResults) NextBytes 

func (r *ViewResults) NextBytes() []byte

NextBytes gets the next row in the results as bytes.

func (*ViewResults) One 

func (r *ViewResults) One(valuePtr interface{}) error

One performs a JSON unmarshal of the first result from the rows into the value pointer.

func (*ViewResults) TotalRows 

func (r *ViewResults) TotalRows() int

TotalRows returns the total number of rows in the view, can be greater than the number of rows returned.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.