aggregations

Documentation

Overview

Package aggregations provides aggregation pipelines.

Index

• func GetPushdownQuery(stagesDocs []any) (match *types.Document, sort *types.Document)
• func SumNumbers(vs ...any) any
• type Expression
  • func NewExpression(expression string) (*Expression, error)
  • func NewExpressionWithOpts(expression string, opts *ExpressionOpts) (*Expression, error)
  • func (e *Expression) Evaluate(doc *types.Document) (any, error)
  • func (e *Expression) GetExpressionSuffix() string
• type ExpressionError
  • func (e *ExpressionError) Code() ExpressionErrorCode
  • func (e *ExpressionError) Error() string
• type ExpressionErrorCode
  • func (i ExpressionErrorCode) String() string
• type ExpressionOpts
• type Stage

Functions

func GetPushdownQuery

func GetPushdownQuery(stagesDocs []any) (match *types.Document, sort *types.Document)

GetPushdownQuery gets pushdown query ($match and $sort) for aggregation.

If the first two stages are either $match, $sort, or a combination of them, we can push them down. In this case, we return the first match and sort statements to pushdown. If $match stage is not present, match is returned as nil. If $sort stage is not present, sort is returned as nil.

func SumNumbers

func SumNumbers(vs ...any) any

SumNumbers accumulate numbers and returns the result of summation. The result has the same type as the input, except when the result cannot be presented accurately. Then int32 is converted to int64, and int64 is converted to float64. It ignores non-number values. For empty `vs`, it returns int32(0). This should only be used for aggregation, aggregation does not return error on overflow.

Types

type Expression

type Expression struct {
	*ExpressionOpts
	// contains filtered or unexported fields
}

Expression is an expression constructed from field value.

func NewExpression

func NewExpression(expression string) (*Expression, error)

NewExpression creates a new instance by checking expression string.

func NewExpressionWithOpts

func NewExpressionWithOpts(expression string, opts *ExpressionOpts) (*Expression, error)

NewExpressionWithOpts creates a new instance by checking expression string. It can take additional opts that specify how expressions should be evaluated.

func (*Expression) Evaluate

func (e *Expression) Evaluate(doc *types.Document) (any, error)

Evaluate gets the value at the path. It returns error if the path does not exists.

func (*Expression) GetExpressionSuffix

func (e *Expression) GetExpressionSuffix() string

GetExpressionSuffix returns suffix of pathExpression.

type ExpressionError

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

ExpressionError describes an error that occurs while evaluating expression.

func (*ExpressionError) Code

func (e *ExpressionError) Code() ExpressionErrorCode

Code returns the ExpressionError code.

func (*ExpressionError) Error

func (e *ExpressionError) Error() string

Error implements the error interface.

type ExpressionErrorCode

type ExpressionErrorCode int

ExpressionErrorCode represents Expression error code.

const (

	// ErrNotExpression indicates that field is not an expression.
	ErrNotExpression ExpressionErrorCode

	// ErrInvalidExpression indicates that expression is invalid.
	ErrInvalidExpression

	// ErrEmptyFieldPath indicates that field path expression is empty.
	ErrEmptyFieldPath

	// ErrUndefinedVariable indicates that variable name is not defined.
	ErrUndefinedVariable

	// ErrEmptyVariable indicates that variable name is empty.
	ErrEmptyVariable
)

func (ExpressionErrorCode) String

func (i ExpressionErrorCode) String() string

type ExpressionOpts

type ExpressionOpts struct {

	// IgnoreArrays disables checking arrays for provided key.
	// So expression {"$v.foo"} won't match {"v":[{"foo":42}]}
	IgnoreArrays bool // defaults to false
}

ExpressionOpts represents options used to modify behavior of Expression functions.

type Stage

type Stage interface {
	// Process applies an aggregate stage on documents from iterator.
	Process(ctx context.Context, iter types.DocumentsIterator, closer *iterator.MultiCloser) (types.DocumentsIterator, error)
}

Stage is a common interface for all aggregation stages.