query

package
v0.0.0-...-f4d665a Latest Latest
Warning

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

 Go to latest Published: Mar 31, 2021 License: MIT Imports: 27 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// DefaultQueryTimeout is the default timeout for executing a query.
	// A value of zero will have no query timeout.
	DefaultQueryTimeout = time.Duration(0)
)
View Source 
const DefaultStatsInterval = time.Second

DefaultStatsInterval is the default value for IteratorEncoder.StatsInterval.

View Source 
const (

	// PanicCrashEnv is the environment variable that, when set, will prevent
	// the handler from recovering any panics.
	PanicCrashEnv = "INFLUXDB_PANIC_CRASH"
)

Statistics for the Executor

View Source 
const (
	// WarningLevel is the message level for a warning.
	WarningLevel = "warning"
)
View Source 
const ZeroTime = int64(math.MinInt64)

ZeroTime is the Unix nanosecond timestamp for no time. This time is not used by the query engine or the storage engine as a valid time.

Variables

View Source 
var (
	// ErrInvalidQuery is returned when executing an unknown query type.
	ErrInvalidQuery = errors.New("invalid query")

	// ErrNotExecuted is returned when a statement is not executed in a query.
	// This can occur when a previous statement in the same query has errored.
	ErrNotExecuted = errors.New("not executed")

	// ErrQueryInterrupted is an error returned when the query is interrupted.
	ErrQueryInterrupted = errors.New("query interrupted")

	// ErrQueryAborted is an error returned when the query is aborted.
	ErrQueryAborted = errors.New("query aborted")

	// ErrQueryEngineShutdown is an error sent when the query cannot be
	// created because the query engine was shutdown.
	ErrQueryEngineShutdown = errors.New("query engine shutdown")

	// ErrQueryTimeoutLimitExceeded is an error when a query hits the max time allowed to run.
	ErrQueryTimeoutLimitExceeded = errors.New("query-timeout limit exceeded")

	// ErrAlreadyKilled is returned when attempting to kill a query that has already been killed.
	ErrAlreadyKilled = errors.New("already killed")
)
View Source 
var DefaultTypeMapper = influxql.MultiTypeMapper(
	FunctionTypeMapper{},
	MathTypeMapper{},
)
View Source 
var ErrUnknownCall = errors.New("unknown call")

ErrUnknownCall is returned when operating on an unknown function call.

View Source 
var NullFloat interface{} = (*float64)(nil)
View Source 
var OpenAuthorizer = openAuthorizer{}

OpenAuthorizer can be shared by all goroutines.

View Source 
var SkipDefault = interface{}(0)

SkipDefault is a sentinel value to tell the IteratorScanner to skip setting the default value if none was present. This causes the map to use the previous value if it was previously set.

Functions

func AggregateBooleanPoints 

func AggregateBooleanPoints(a BooleanPointAggregator, points []BooleanPoint)

AggregateBooleanPoints feeds a slice of BooleanPoint into an aggregator. If the aggregator is a BooleanBulkPointAggregator, it will use the AggregateBulk method.

func AggregateFloatPoints 

func AggregateFloatPoints(a FloatPointAggregator, points []FloatPoint)

AggregateFloatPoints feeds a slice of FloatPoint into an aggregator. If the aggregator is a FloatBulkPointAggregator, it will use the AggregateBulk method.

func AggregateIntegerPoints 

func AggregateIntegerPoints(a IntegerPointAggregator, points []IntegerPoint)

AggregateIntegerPoints feeds a slice of IntegerPoint into an aggregator. If the aggregator is a IntegerBulkPointAggregator, it will use the AggregateBulk method.

func AggregateStringPoints 

func AggregateStringPoints(a StringPointAggregator, points []StringPoint)

AggregateStringPoints feeds a slice of StringPoint into an aggregator. If the aggregator is a StringBulkPointAggregator, it will use the AggregateBulk method.

func AggregateUnsignedPoints 

func AggregateUnsignedPoints(a UnsignedPointAggregator, points []UnsignedPoint)

AggregateUnsignedPoints feeds a slice of UnsignedPoint into an aggregator. If the aggregator is a UnsignedBulkPointAggregator, it will use the AggregateBulk method.

func AuthorizerIsOpen 

func AuthorizerIsOpen(a Authorizer) bool

AuthorizerIsOpen returns true if the provided Authorizer is guaranteed to authorize anything. A nil Authorizer returns true for this function, and this function should be preferred over directly checking if an Authorizer is nil or not.

func BooleanCountReduce 

func BooleanCountReduce(prev *IntegerPoint, curr *BooleanPoint) (int64, int64, []interface{})

BooleanCountReduce returns the count of points.

func BooleanFirstReduce 

func BooleanFirstReduce(prev, curr *BooleanPoint) (int64, bool, []interface{})

BooleanFirstReduce returns the first point sorted by time.

func BooleanLastReduce 

func BooleanLastReduce(prev, curr *BooleanPoint) (int64, bool, []interface{})

BooleanLastReduce returns the first point sorted by time.

func BooleanMaxReduce 

func BooleanMaxReduce(prev, curr *BooleanPoint) (int64, bool, []interface{})

BooleanMaxReduce returns the minimum value between prev & curr.

func BooleanMinReduce 

func BooleanMinReduce(prev, curr *BooleanPoint) (int64, bool, []interface{})

BooleanMinReduce returns the minimum value between prev & curr.

func DrainCursor 

func DrainCursor(cur Cursor) error

DrainCursor will read and discard all values from a Cursor and return the error if one happens.

func DrainIterator 

func DrainIterator(itr Iterator)

DrainIterator reads and discards all points from itr.

func DrainIterators 

func DrainIterators(itrs []Iterator)

DrainIterators reads and discards all points from itrs.

func ErrDatabaseNotFound 

func ErrDatabaseNotFound(name string) error

ErrDatabaseNotFound returns a database not found error for the given database name.

func ErrMaxConcurrentQueriesLimitExceeded 

func ErrMaxConcurrentQueriesLimitExceeded(n, limit int) error

ErrMaxConcurrentQueriesLimitExceeded is an error when a query cannot be run because the maximum number of queries has been reached.

func ErrMaxSelectPointsLimitExceeded 

func ErrMaxSelectPointsLimitExceeded(n, limit int) error

ErrMaxSelectPointsLimitExceeded is an error when a query hits the maximum number of points.

func FloatCountReduce 

func FloatCountReduce(prev *IntegerPoint, curr *FloatPoint) (int64, int64, []interface{})

FloatCountReduce returns the count of points.

func FloatFirstReduce 

func FloatFirstReduce(prev, curr *FloatPoint) (int64, float64, []interface{})

FloatFirstReduce returns the first point sorted by time.

func FloatLastReduce 

func FloatLastReduce(prev, curr *FloatPoint) (int64, float64, []interface{})

FloatLastReduce returns the last point sorted by time.

func FloatMaxReduce 

func FloatMaxReduce(prev, curr *FloatPoint) (int64, float64, []interface{})

FloatMaxReduce returns the maximum value between prev & curr.

func FloatMinReduce 

func FloatMinReduce(prev, curr *FloatPoint) (int64, float64, []interface{})

FloatMinReduce returns the minimum value between prev & curr.

func FloatSumReduce 

func FloatSumReduce(prev, curr *FloatPoint) (int64, float64, []interface{})

FloatSumReduce returns the sum prev value & curr value.

func IntegerCountReduce 

func IntegerCountReduce(prev, curr *IntegerPoint) (int64, int64, []interface{})

IntegerCountReduce returns the count of points.

func IntegerFirstReduce 

func IntegerFirstReduce(prev, curr *IntegerPoint) (int64, int64, []interface{})

IntegerFirstReduce returns the first point sorted by time.

func IntegerLastReduce 

func IntegerLastReduce(prev, curr *IntegerPoint) (int64, int64, []interface{})

IntegerLastReduce returns the last point sorted by time.

func IntegerMaxReduce 

func IntegerMaxReduce(prev, curr *IntegerPoint) (int64, int64, []interface{})

IntegerMaxReduce returns the maximum value between prev & curr.

func IntegerMinReduce 

func IntegerMinReduce(prev, curr *IntegerPoint) (int64, int64, []interface{})

IntegerMinReduce returns the minimum value between prev & curr.

func IntegerSumReduce 

func IntegerSumReduce(prev, curr *IntegerPoint) (int64, int64, []interface{})

IntegerSumReduce returns the sum prev value & curr value.

func NewContextWithIterators 

func NewContextWithIterators(ctx context.Context, itr *Iterators) context.Context

NewContextWithIterators returns a new context.Context with the *Iterators slice added. The query planner will add instances of AuxIterator to the Iterators slice.

func RewriteStatement 

func RewriteStatement(stmt influxql.Statement) (influxql.Statement, error)

RewriteStatement rewrites stmt into a new statement, if applicable.

func StringCountReduce 

func StringCountReduce(prev *IntegerPoint, curr *StringPoint) (int64, int64, []interface{})

StringCountReduce returns the count of points.

func StringFirstReduce 

func StringFirstReduce(prev, curr *StringPoint) (int64, string, []interface{})

StringFirstReduce returns the first point sorted by time.

func StringLastReduce 

func StringLastReduce(prev, curr *StringPoint) (int64, string, []interface{})

StringLastReduce returns the first point sorted by time.

func UnsignedCountReduce 

func UnsignedCountReduce(prev *IntegerPoint, curr *UnsignedPoint) (int64, int64, []interface{})

UnsignedCountReduce returns the count of points.

func UnsignedFirstReduce 

func UnsignedFirstReduce(prev, curr *UnsignedPoint) (int64, uint64, []interface{})

UnsignedFirstReduce returns the first point sorted by time.

func UnsignedLastReduce 

func UnsignedLastReduce(prev, curr *UnsignedPoint) (int64, uint64, []interface{})

UnsignedLastReduce returns the last point sorted by time.

func UnsignedMaxReduce 

func UnsignedMaxReduce(prev, curr *UnsignedPoint) (int64, uint64, []interface{})

UnsignedMaxReduce returns the maximum value between prev & curr.

func UnsignedMinReduce 

func UnsignedMinReduce(prev, curr *UnsignedPoint) (int64, uint64, []interface{})

UnsignedMinReduce returns the minimum value between prev & curr.

func UnsignedSumReduce 

func UnsignedSumReduce(prev, curr *UnsignedPoint) (int64, uint64, []interface{})

UnsignedSumReduce returns the sum prev value & curr value.

Types

type Authorizer 

type Authorizer interface {
	// AuthorizeDatabase indicates whether the given Privilege is authorized on the database with the given name.
	AuthorizeDatabase(p influxql.Privilege, name string) bool

	// AuthorizeQuery returns an error if the query cannot be executed
	AuthorizeQuery(database string, query *influxql.Query) error

	// AuthorizeSeriesRead determines if a series is authorized for reading
	AuthorizeSeriesRead(database string, measurement []byte, tags models.Tags) bool

	// AuthorizeSeriesWrite determines if a series is authorized for writing
	AuthorizeSeriesWrite(database string, measurement []byte, tags models.Tags) bool
}

Authorizer determines if certain operations are authorized.

type BooleanBulkPointAggregator 

type BooleanBulkPointAggregator interface {
	AggregateBooleanBulk(points []BooleanPoint)
}

BooleanBulkPointAggregator aggregates multiple points at a time.

type BooleanDistinctReducer 

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

BooleanDistinctReducer returns the distinct points in a series.

func NewBooleanDistinctReducer 

func NewBooleanDistinctReducer() *BooleanDistinctReducer

NewBooleanDistinctReducer creates a new BooleanDistinctReducer.

func (*BooleanDistinctReducer) AggregateBoolean 

func (r *BooleanDistinctReducer) AggregateBoolean(p *BooleanPoint)

AggregateBoolean aggregates a point into the reducer.

func (*BooleanDistinctReducer) Emit 

func (r *BooleanDistinctReducer) Emit() []BooleanPoint

Emit emits the distinct points that have been aggregated into the reducer.

type BooleanElapsedReducer 

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

BooleanElapsedReducer calculates the elapsed of the aggregated points.

func NewBooleanElapsedReducer 

func NewBooleanElapsedReducer(interval Interval) *BooleanElapsedReducer

NewBooleanElapsedReducer creates a new BooleanElapsedReducer.

func (*BooleanElapsedReducer) AggregateBoolean 

func (r *BooleanElapsedReducer) AggregateBoolean(p *BooleanPoint)

AggregateBoolean aggregates a point into the reducer and updates the current window.

func (*BooleanElapsedReducer) Emit 

func (r *BooleanElapsedReducer) Emit() []IntegerPoint

Emit emits the elapsed of the reducer at the current point.

type BooleanFuncFloatReducer 

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

BooleanFuncFloatReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewBooleanFuncFloatReducer 

func NewBooleanFuncFloatReducer(fn BooleanReduceFloatFunc, prev *FloatPoint) *BooleanFuncFloatReducer

NewBooleanFuncFloatReducer creates a new BooleanFuncFloatReducer.

func (*BooleanFuncFloatReducer) AggregateBoolean 

func (r *BooleanFuncFloatReducer) AggregateBoolean(p *BooleanPoint)

AggregateBoolean takes a BooleanPoint and invokes the reduce function with the current and new point to modify the current point.

func (*BooleanFuncFloatReducer) Emit 

func (r *BooleanFuncFloatReducer) Emit() []FloatPoint

Emit emits the point that was generated when reducing the points fed in with AggregateBoolean.

type BooleanFuncIntegerReducer 

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

BooleanFuncIntegerReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewBooleanFuncIntegerReducer 

func NewBooleanFuncIntegerReducer(fn BooleanReduceIntegerFunc, prev *IntegerPoint) *BooleanFuncIntegerReducer

NewBooleanFuncIntegerReducer creates a new BooleanFuncIntegerReducer.

func (*BooleanFuncIntegerReducer) AggregateBoolean 

func (r *BooleanFuncIntegerReducer) AggregateBoolean(p *BooleanPoint)

AggregateBoolean takes a BooleanPoint and invokes the reduce function with the current and new point to modify the current point.

func (*BooleanFuncIntegerReducer) Emit 

func (r *BooleanFuncIntegerReducer) Emit() []IntegerPoint

Emit emits the point that was generated when reducing the points fed in with AggregateBoolean.

type BooleanFuncReducer 

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

BooleanFuncReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewBooleanFuncReducer 

func NewBooleanFuncReducer(fn BooleanReduceFunc, prev *BooleanPoint) *BooleanFuncReducer

NewBooleanFuncReducer creates a new BooleanFuncBooleanReducer.

func (*BooleanFuncReducer) AggregateBoolean 

func (r *BooleanFuncReducer) AggregateBoolean(p *BooleanPoint)

AggregateBoolean takes a BooleanPoint and invokes the reduce function with the current and new point to modify the current point.

func (*BooleanFuncReducer) Emit 

func (r *BooleanFuncReducer) Emit() []BooleanPoint

Emit emits the point that was generated when reducing the points fed in with AggregateBoolean.

type BooleanFuncStringReducer 

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

BooleanFuncStringReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewBooleanFuncStringReducer 

func NewBooleanFuncStringReducer(fn BooleanReduceStringFunc, prev *StringPoint) *BooleanFuncStringReducer

NewBooleanFuncStringReducer creates a new BooleanFuncStringReducer.

func (*BooleanFuncStringReducer) AggregateBoolean 

func (r *BooleanFuncStringReducer) AggregateBoolean(p *BooleanPoint)

AggregateBoolean takes a BooleanPoint and invokes the reduce function with the current and new point to modify the current point.

func (*BooleanFuncStringReducer) Emit 

func (r *BooleanFuncStringReducer) Emit() []StringPoint

Emit emits the point that was generated when reducing the points fed in with AggregateBoolean.

type BooleanFuncUnsignedReducer 

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

BooleanFuncUnsignedReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewBooleanFuncUnsignedReducer 

func NewBooleanFuncUnsignedReducer(fn BooleanReduceUnsignedFunc, prev *UnsignedPoint) *BooleanFuncUnsignedReducer

NewBooleanFuncUnsignedReducer creates a new BooleanFuncUnsignedReducer.

func (*BooleanFuncUnsignedReducer) AggregateBoolean 

func (r *BooleanFuncUnsignedReducer) AggregateBoolean(p *BooleanPoint)

AggregateBoolean takes a BooleanPoint and invokes the reduce function with the current and new point to modify the current point.

func (*BooleanFuncUnsignedReducer) Emit 

func (r *BooleanFuncUnsignedReducer) Emit() []UnsignedPoint

Emit emits the point that was generated when reducing the points fed in with AggregateBoolean.

type BooleanIterator 

type BooleanIterator interface {
	Iterator
	Next() (*BooleanPoint, error)
}

BooleanIterator represents a stream of boolean points.

type BooleanPoint 

type BooleanPoint struct {
	Name string
	Tags Tags

	Time  int64
	Value bool
	Aux   []interface{}

	// Total number of points that were combined into this point from an aggregate.
	// If this is zero, the point is not the result of an aggregate function.
	Aggregated uint32
	Nil        bool
}

BooleanPoint represents a point with a bool value. DO NOT ADD ADDITIONAL FIELDS TO THIS STRUCT. See TestPoint_Fields in influxql/point_test.go for more details.

func BooleanModeReduceSlice 

func BooleanModeReduceSlice(a []BooleanPoint) []BooleanPoint

BooleanModeReduceSlice returns the mode value within a window.

func (*BooleanPoint) Clone 

func (v *BooleanPoint) Clone() *BooleanPoint

Clone returns a copy of v.

func (*BooleanPoint) CopyTo 

func (v *BooleanPoint) CopyTo(other *BooleanPoint)

CopyTo makes a deep copy into the point.

type BooleanPointAggregator 

type BooleanPointAggregator interface {
	AggregateBoolean(p *BooleanPoint)
}

BooleanPointAggregator aggregates points to produce a single point.

type BooleanPointDecoder 

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

BooleanPointDecoder decodes BooleanPoint points from a reader.

func NewBooleanPointDecoder 

func NewBooleanPointDecoder(ctx context.Context, r io.Reader) *BooleanPointDecoder

NewBooleanPointDecoder returns a new instance of BooleanPointDecoder that reads from r.

func (*BooleanPointDecoder) DecodeBooleanPoint 

func (dec *BooleanPointDecoder) DecodeBooleanPoint(p *BooleanPoint) error

DecodeBooleanPoint reads from the underlying reader and unmarshals into p.

func (*BooleanPointDecoder) Stats 

func (dec *BooleanPointDecoder) Stats() IteratorStats

Stats returns iterator stats embedded within the stream.

type BooleanPointEmitter 

type BooleanPointEmitter interface {
	Emit() []BooleanPoint
}

BooleanPointEmitter produces a single point from an aggregate.

type BooleanPointEncoder 

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

BooleanPointEncoder encodes BooleanPoint points to a writer.

func NewBooleanPointEncoder 

func NewBooleanPointEncoder(w io.Writer) *BooleanPointEncoder

NewBooleanPointEncoder returns a new instance of BooleanPointEncoder that writes to w.

func (*BooleanPointEncoder) EncodeBooleanPoint 

func (enc *BooleanPointEncoder) EncodeBooleanPoint(p *BooleanPoint) error

EncodeBooleanPoint marshals and writes p to the underlying writer.

type BooleanReduceFloatFunc 

type BooleanReduceFloatFunc func(prev *FloatPoint, curr *BooleanPoint) (t int64, v float64, aux []interface{})

BooleanReduceFloatFunc is the function called by a BooleanPoint reducer.

type BooleanReduceFloatSliceFunc 

type BooleanReduceFloatSliceFunc func(a []BooleanPoint) []FloatPoint

BooleanReduceFloatSliceFunc is the function called by a BooleanPoint reducer.

type BooleanReduceFunc 

type BooleanReduceFunc func(prev *BooleanPoint, curr *BooleanPoint) (t int64, v bool, aux []interface{})

BooleanReduceFunc is the function called by a BooleanPoint reducer.

type BooleanReduceIntegerFunc 

type BooleanReduceIntegerFunc func(prev *IntegerPoint, curr *BooleanPoint) (t int64, v int64, aux []interface{})

BooleanReduceIntegerFunc is the function called by a BooleanPoint reducer.

type BooleanReduceIntegerSliceFunc 

type BooleanReduceIntegerSliceFunc func(a []BooleanPoint) []IntegerPoint

BooleanReduceIntegerSliceFunc is the function called by a BooleanPoint reducer.

type BooleanReduceSliceFunc 

type BooleanReduceSliceFunc func(a []BooleanPoint) []BooleanPoint

BooleanReduceSliceFunc is the function called by a BooleanPoint reducer.

type BooleanReduceStringFunc 

type BooleanReduceStringFunc func(prev *StringPoint, curr *BooleanPoint) (t int64, v string, aux []interface{})

BooleanReduceStringFunc is the function called by a BooleanPoint reducer.

type BooleanReduceStringSliceFunc 

type BooleanReduceStringSliceFunc func(a []BooleanPoint) []StringPoint

BooleanReduceStringSliceFunc is the function called by a BooleanPoint reducer.

type BooleanReduceUnsignedFunc 

type BooleanReduceUnsignedFunc func(prev *UnsignedPoint, curr *BooleanPoint) (t int64, v uint64, aux []interface{})

BooleanReduceUnsignedFunc is the function called by a BooleanPoint reducer.

type BooleanReduceUnsignedSliceFunc 

type BooleanReduceUnsignedSliceFunc func(a []BooleanPoint) []UnsignedPoint

BooleanReduceUnsignedSliceFunc is the function called by a BooleanPoint reducer.

type BooleanSampleReducer 

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

BooleanSampleReducer implements a reservoir sampling to calculate a random subset of points

func NewBooleanSampleReducer 

func NewBooleanSampleReducer(size int) *BooleanSampleReducer

NewBooleanSampleReducer creates a new BooleanSampleReducer

func (*BooleanSampleReducer) AggregateBoolean 

func (r *BooleanSampleReducer) AggregateBoolean(p *BooleanPoint)

AggregateBoolean aggregates a point into the reducer.

func (*BooleanSampleReducer) Emit 

func (r *BooleanSampleReducer) Emit() []BooleanPoint

Emit emits the reservoir sample as many points.

type BooleanSliceFuncFloatReducer 

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

BooleanSliceFuncFloatReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewBooleanSliceFuncFloatReducer 

func NewBooleanSliceFuncFloatReducer(fn BooleanReduceFloatSliceFunc) *BooleanSliceFuncFloatReducer

NewBooleanSliceFuncFloatReducer creates a new BooleanSliceFuncFloatReducer.

func (*BooleanSliceFuncFloatReducer) AggregateBoolean 

func (r *BooleanSliceFuncFloatReducer) AggregateBoolean(p *BooleanPoint)

AggregateBoolean copies the BooleanPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*BooleanSliceFuncFloatReducer) AggregateBooleanBulk 

func (r *BooleanSliceFuncFloatReducer) AggregateBooleanBulk(points []BooleanPoint)

AggregateBooleanBulk performs a bulk copy of BooleanPoints into the internal slice. This is a more efficient version of calling AggregateBoolean on each point.

func (*BooleanSliceFuncFloatReducer) Emit 

func (r *BooleanSliceFuncFloatReducer) Emit() []FloatPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type BooleanSliceFuncIntegerReducer 

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

BooleanSliceFuncIntegerReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewBooleanSliceFuncIntegerReducer 

func NewBooleanSliceFuncIntegerReducer(fn BooleanReduceIntegerSliceFunc) *BooleanSliceFuncIntegerReducer

NewBooleanSliceFuncIntegerReducer creates a new BooleanSliceFuncIntegerReducer.

func (*BooleanSliceFuncIntegerReducer) AggregateBoolean 

func (r *BooleanSliceFuncIntegerReducer) AggregateBoolean(p *BooleanPoint)

AggregateBoolean copies the BooleanPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*BooleanSliceFuncIntegerReducer) AggregateBooleanBulk 

func (r *BooleanSliceFuncIntegerReducer) AggregateBooleanBulk(points []BooleanPoint)

AggregateBooleanBulk performs a bulk copy of BooleanPoints into the internal slice. This is a more efficient version of calling AggregateBoolean on each point.

func (*BooleanSliceFuncIntegerReducer) Emit 

func (r *BooleanSliceFuncIntegerReducer) Emit() []IntegerPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type BooleanSliceFuncReducer 

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

BooleanSliceFuncReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewBooleanSliceFuncReducer 

func NewBooleanSliceFuncReducer(fn BooleanReduceSliceFunc) *BooleanSliceFuncReducer

NewBooleanSliceFuncReducer creates a new BooleanSliceFuncReducer.

func (*BooleanSliceFuncReducer) AggregateBoolean 

func (r *BooleanSliceFuncReducer) AggregateBoolean(p *BooleanPoint)

AggregateBoolean copies the BooleanPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*BooleanSliceFuncReducer) AggregateBooleanBulk 

func (r *BooleanSliceFuncReducer) AggregateBooleanBulk(points []BooleanPoint)

AggregateBooleanBulk performs a bulk copy of BooleanPoints into the internal slice. This is a more efficient version of calling AggregateBoolean on each point.

func (*BooleanSliceFuncReducer) Emit 

func (r *BooleanSliceFuncReducer) Emit() []BooleanPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type BooleanSliceFuncStringReducer 

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

BooleanSliceFuncStringReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewBooleanSliceFuncStringReducer 

func NewBooleanSliceFuncStringReducer(fn BooleanReduceStringSliceFunc) *BooleanSliceFuncStringReducer

NewBooleanSliceFuncStringReducer creates a new BooleanSliceFuncStringReducer.

func (*BooleanSliceFuncStringReducer) AggregateBoolean 

func (r *BooleanSliceFuncStringReducer) AggregateBoolean(p *BooleanPoint)

AggregateBoolean copies the BooleanPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*BooleanSliceFuncStringReducer) AggregateBooleanBulk 

func (r *BooleanSliceFuncStringReducer) AggregateBooleanBulk(points []BooleanPoint)

AggregateBooleanBulk performs a bulk copy of BooleanPoints into the internal slice. This is a more efficient version of calling AggregateBoolean on each point.

func (*BooleanSliceFuncStringReducer) Emit 

func (r *BooleanSliceFuncStringReducer) Emit() []StringPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type BooleanSliceFuncUnsignedReducer 

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

BooleanSliceFuncUnsignedReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewBooleanSliceFuncUnsignedReducer 

func NewBooleanSliceFuncUnsignedReducer(fn BooleanReduceUnsignedSliceFunc) *BooleanSliceFuncUnsignedReducer

NewBooleanSliceFuncUnsignedReducer creates a new BooleanSliceFuncUnsignedReducer.

func (*BooleanSliceFuncUnsignedReducer) AggregateBoolean 

func (r *BooleanSliceFuncUnsignedReducer) AggregateBoolean(p *BooleanPoint)

AggregateBoolean copies the BooleanPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*BooleanSliceFuncUnsignedReducer) AggregateBooleanBulk 

func (r *BooleanSliceFuncUnsignedReducer) AggregateBooleanBulk(points []BooleanPoint)

AggregateBooleanBulk performs a bulk copy of BooleanPoints into the internal slice. This is a more efficient version of calling AggregateBoolean on each point.

func (*BooleanSliceFuncUnsignedReducer) Emit 

func (r *BooleanSliceFuncUnsignedReducer) Emit() []UnsignedPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type CallTypeMapper 

type CallTypeMapper struct{}

CallTypeMapper returns the types for call iterator functions. Call iterator functions are commonly implemented within the storage engine so this mapper is limited to only the return values of those functions.

func (CallTypeMapper) CallType 

func (CallTypeMapper) CallType(name string, args []influxql.DataType) (influxql.DataType, error)

func (CallTypeMapper) MapType 

func (CallTypeMapper) MapType(measurement *influxql.Measurement, field string) influxql.DataType

type ChandeMomentumOscillatorReducer 

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

func NewChandeMomentumOscillatorReducer 

func NewChandeMomentumOscillatorReducer(period int, holdPeriod int, warmupType gota.WarmupType) *ChandeMomentumOscillatorReducer

func (*ChandeMomentumOscillatorReducer) AggregateFloat 

func (r *ChandeMomentumOscillatorReducer) AggregateFloat(p *FloatPoint)

func (*ChandeMomentumOscillatorReducer) AggregateInteger 

func (r *ChandeMomentumOscillatorReducer) AggregateInteger(p *IntegerPoint)

func (*ChandeMomentumOscillatorReducer) AggregateUnsigned 

func (r *ChandeMomentumOscillatorReducer) AggregateUnsigned(p *UnsignedPoint)

func (*ChandeMomentumOscillatorReducer) Emit 

func (r *ChandeMomentumOscillatorReducer) Emit() []FloatPoint

type CompileOptions 

type CompileOptions struct {
	Now time.Time
}

CompileOptions are the customization options for the compiler.

type Cursor 

type Cursor interface {
	// Scan will retrieve the next row and assign the result to
	// the passed in Row. If the Row has not been initialized, the Cursor
	// will initialize the Row.
	// To increase speed and memory usage, the same Row can be used and
	// the previous values will be overwritten while using the same memory.
	Scan(row *Row) bool

	// Stats returns the IteratorStats from the underlying iterators.
	Stats() IteratorStats

	// Err returns any errors that were encountered from scanning the rows.
	Err() error

	// Columns returns the column names and types.
	Columns() []influxql.VarRef

	// Close closes the underlying resources that the cursor is using.
	Close() error
}

func RowCursor 

func RowCursor(rows []Row, columns []influxql.VarRef) Cursor

RowCursor returns a Cursor that iterates over Rows.

func Select 

func Select(ctx context.Context, stmt *influxql.SelectStatement, shardMapper ShardMapper, opt SelectOptions) (Cursor, error)

Select compiles, prepares, and then initiates execution of the query using the default compile options.

type DoubleExponentialMovingAverageReducer 

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

func NewDoubleExponentialMovingAverageReducer 

func NewDoubleExponentialMovingAverageReducer(period int, holdPeriod int, warmupType gota.WarmupType) *DoubleExponentialMovingAverageReducer

func (*DoubleExponentialMovingAverageReducer) AggregateFloat 

func (r *DoubleExponentialMovingAverageReducer) AggregateFloat(p *FloatPoint)

func (*DoubleExponentialMovingAverageReducer) AggregateInteger 

func (r *DoubleExponentialMovingAverageReducer) AggregateInteger(p *IntegerPoint)

func (*DoubleExponentialMovingAverageReducer) AggregateUnsigned 

func (r *DoubleExponentialMovingAverageReducer) AggregateUnsigned(p *UnsignedPoint)

func (*DoubleExponentialMovingAverageReducer) Emit 

func (r *DoubleExponentialMovingAverageReducer) Emit() []FloatPoint

type Emitter 

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

Emitter reads from a cursor into rows.

func NewEmitter 

func NewEmitter(cur Cursor, chunkSize int) *Emitter

NewEmitter returns a new instance of Emitter that pulls from itrs.

func (*Emitter) Close 

func (e *Emitter) Close() error

Close closes the underlying iterators.

func (*Emitter) Emit 

func (e *Emitter) Emit() (*models.Row, bool, error)

Emit returns the next row from the iterators.

type ExecutionContext 

type ExecutionContext struct {
	context.Context

	// The query ID of the executing query.
	QueryID uint64

	// Output channel where results and errors should be sent.
	Results chan *Result

	// Options used to start this query.
	ExecutionOptions
	// contains filtered or unexported fields
}

ExecutionContext contains state that the query is currently executing with.

func (*ExecutionContext) Done 

func (ctx *ExecutionContext) Done() <-chan struct{}

func (*ExecutionContext) Err 

func (ctx *ExecutionContext) Err() error

func (*ExecutionContext) Send 

func (ctx *ExecutionContext) Send(result *Result) error

Send sends a Result to the Results channel and will exit if the query has been interrupted or aborted.

func (*ExecutionContext) Value 

func (ctx *ExecutionContext) Value(key interface{}) interface{}

type ExecutionOptions 

type ExecutionOptions struct {
	// The database the query is running against.
	Database string

	// The retention policy the query is running against.
	RetentionPolicy string

	// How to determine whether the query is allowed to execute,
	// what resources can be returned in SHOW queries, etc.
	Authorizer Authorizer

	// The requested maximum number of points to return in each result.
	ChunkSize int

	// If this query is being executed in a read-only context.
	ReadOnly bool

	// Node to execute on.
	NodeID uint64

	// Quiet suppresses non-essential output from the query executor.
	Quiet bool

	// AbortCh is a channel that signals when results are no longer desired by the caller.
	AbortCh <-chan struct{}
}

ExecutionOptions contains the options for executing a query.

type Executor 

type Executor struct {
	// Used for executing a statement in the query.
	StatementExecutor StatementExecutor

	// Used for tracking running queries.
	TaskManager *TaskManager

	// Logger to use for all logging.
	// Defaults to discarding all log output.
	Logger *zap.Logger
	// contains filtered or unexported fields
}

Executor executes every statement in an Query.

func NewExecutor 

func NewExecutor() *Executor

NewExecutor returns a new instance of Executor.

func (*Executor) Close 

func (e *Executor) Close() error

Close kills all running queries and prevents new queries from being attached.

func (*Executor) ExecuteQuery 

func (e *Executor) ExecuteQuery(query *influxql.Query, opt ExecutionOptions, closing chan struct{}) <-chan *Result

ExecuteQuery executes each statement within a query.

func (*Executor) Statistics 

func (e *Executor) Statistics(tags map[string]string) []models.Statistic

Statistics returns statistics for periodic monitoring.

func (*Executor) WithLogger 

func (e *Executor) WithLogger(log *zap.Logger)

SetLogOutput sets the writer to which all logs are written. It must not be called after Open is called.

type ExponentialMovingAverageReducer 

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

func NewExponentialMovingAverageReducer 

func NewExponentialMovingAverageReducer(period int, holdPeriod int, warmupType gota.WarmupType) *ExponentialMovingAverageReducer

func (*ExponentialMovingAverageReducer) AggregateFloat 

func (r *ExponentialMovingAverageReducer) AggregateFloat(p *FloatPoint)

func (*ExponentialMovingAverageReducer) AggregateInteger 

func (r *ExponentialMovingAverageReducer) AggregateInteger(p *IntegerPoint)

func (*ExponentialMovingAverageReducer) AggregateUnsigned 

func (r *ExponentialMovingAverageReducer) AggregateUnsigned(p *UnsignedPoint)

func (*ExponentialMovingAverageReducer) Emit 

func (r *ExponentialMovingAverageReducer) Emit() []FloatPoint

type FieldMap 

type FieldMap struct {
	Index int
	Type  influxql.DataType
}

func (FieldMap) Value 

func (f FieldMap) Value(row *Row) interface{}

type FieldMapper 

type FieldMapper struct {
	influxql.FieldMapper
}

FieldMapper is a FieldMapper that wraps another FieldMapper and exposes the functions implemented by the query engine.

func (FieldMapper) CallType 

func (m FieldMapper) CallType(name string, args []influxql.DataType) (influxql.DataType, error)

type FloatBottomReducer 

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

func NewFloatBottomReducer 

func NewFloatBottomReducer(n int) *FloatBottomReducer

func (*FloatBottomReducer) AggregateFloat 

func (r *FloatBottomReducer) AggregateFloat(p *FloatPoint)

func (*FloatBottomReducer) Emit 

func (r *FloatBottomReducer) Emit() []FloatPoint

type FloatBulkPointAggregator 

type FloatBulkPointAggregator interface {
	AggregateFloatBulk(points []FloatPoint)
}

FloatBulkPointAggregator aggregates multiple points at a time.

type FloatCumulativeSumReducer 

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

FloatCumulativeSumReducer cumulates the values from each point.

func NewFloatCumulativeSumReducer 

func NewFloatCumulativeSumReducer() *FloatCumulativeSumReducer

NewFloatCumulativeSumReducer creates a new FloatCumulativeSumReducer.

func (*FloatCumulativeSumReducer) AggregateFloat 

func (r *FloatCumulativeSumReducer) AggregateFloat(p *FloatPoint)

func (*FloatCumulativeSumReducer) Emit 

func (r *FloatCumulativeSumReducer) Emit() []FloatPoint

type FloatDerivativeReducer 

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

FloatDerivativeReducer calculates the derivative of the aggregated points.

func NewFloatDerivativeReducer 

func NewFloatDerivativeReducer(interval Interval, isNonNegative, ascending bool) *FloatDerivativeReducer

NewFloatDerivativeReducer creates a new FloatDerivativeReducer.

func (*FloatDerivativeReducer) AggregateFloat 

func (r *FloatDerivativeReducer) AggregateFloat(p *FloatPoint)

AggregateFloat aggregates a point into the reducer and updates the current window.

func (*FloatDerivativeReducer) Emit 

func (r *FloatDerivativeReducer) Emit() []FloatPoint

Emit emits the derivative of the reducer at the current point.

type FloatDifferenceReducer 

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

FloatDifferenceReducer calculates the derivative of the aggregated points.

func NewFloatDifferenceReducer 

func NewFloatDifferenceReducer(isNonNegative bool) *FloatDifferenceReducer

NewFloatDifferenceReducer creates a new FloatDifferenceReducer.

func (*FloatDifferenceReducer) AggregateFloat 

func (r *FloatDifferenceReducer) AggregateFloat(p *FloatPoint)

AggregateFloat aggregates a point into the reducer and updates the current window.

func (*FloatDifferenceReducer) Emit 

func (r *FloatDifferenceReducer) Emit() []FloatPoint

Emit emits the difference of the reducer at the current point.

type FloatDistinctReducer 

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

FloatDistinctReducer returns the distinct points in a series.

func NewFloatDistinctReducer 

func NewFloatDistinctReducer() *FloatDistinctReducer

NewFloatDistinctReducer creates a new FloatDistinctReducer.

func (*FloatDistinctReducer) AggregateFloat 

func (r *FloatDistinctReducer) AggregateFloat(p *FloatPoint)

AggregateFloat aggregates a point into the reducer.

func (*FloatDistinctReducer) Emit 

func (r *FloatDistinctReducer) Emit() []FloatPoint

Emit emits the distinct points that have been aggregated into the reducer.

type FloatElapsedReducer 

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

FloatElapsedReducer calculates the elapsed of the aggregated points.

func NewFloatElapsedReducer 

func NewFloatElapsedReducer(interval Interval) *FloatElapsedReducer

NewFloatElapsedReducer creates a new FloatElapsedReducer.

func (*FloatElapsedReducer) AggregateFloat 

func (r *FloatElapsedReducer) AggregateFloat(p *FloatPoint)

AggregateFloat aggregates a point into the reducer and updates the current window.

func (*FloatElapsedReducer) Emit 

func (r *FloatElapsedReducer) Emit() []IntegerPoint

Emit emits the elapsed of the reducer at the current point.

type FloatFuncBooleanReducer 

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

FloatFuncBooleanReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewFloatFuncBooleanReducer 

func NewFloatFuncBooleanReducer(fn FloatReduceBooleanFunc, prev *BooleanPoint) *FloatFuncBooleanReducer

NewFloatFuncBooleanReducer creates a new FloatFuncBooleanReducer.

func (*FloatFuncBooleanReducer) AggregateFloat 

func (r *FloatFuncBooleanReducer) AggregateFloat(p *FloatPoint)

AggregateFloat takes a FloatPoint and invokes the reduce function with the current and new point to modify the current point.

func (*FloatFuncBooleanReducer) Emit 

func (r *FloatFuncBooleanReducer) Emit() []BooleanPoint

Emit emits the point that was generated when reducing the points fed in with AggregateFloat.

type FloatFuncIntegerReducer 

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

FloatFuncIntegerReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewFloatFuncIntegerReducer 

func NewFloatFuncIntegerReducer(fn FloatReduceIntegerFunc, prev *IntegerPoint) *FloatFuncIntegerReducer

NewFloatFuncIntegerReducer creates a new FloatFuncIntegerReducer.

func (*FloatFuncIntegerReducer) AggregateFloat 

func (r *FloatFuncIntegerReducer) AggregateFloat(p *FloatPoint)

AggregateFloat takes a FloatPoint and invokes the reduce function with the current and new point to modify the current point.

func (*FloatFuncIntegerReducer) Emit 

func (r *FloatFuncIntegerReducer) Emit() []IntegerPoint

Emit emits the point that was generated when reducing the points fed in with AggregateFloat.

type FloatFuncReducer 

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

FloatFuncReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewFloatFuncReducer 

func NewFloatFuncReducer(fn FloatReduceFunc, prev *FloatPoint) *FloatFuncReducer

NewFloatFuncReducer creates a new FloatFuncFloatReducer.

func (*FloatFuncReducer) AggregateFloat 

func (r *FloatFuncReducer) AggregateFloat(p *FloatPoint)

AggregateFloat takes a FloatPoint and invokes the reduce function with the current and new point to modify the current point.

func (*FloatFuncReducer) Emit 

func (r *FloatFuncReducer) Emit() []FloatPoint

Emit emits the point that was generated when reducing the points fed in with AggregateFloat.

type FloatFuncStringReducer 

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

FloatFuncStringReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewFloatFuncStringReducer 

func NewFloatFuncStringReducer(fn FloatReduceStringFunc, prev *StringPoint) *FloatFuncStringReducer

NewFloatFuncStringReducer creates a new FloatFuncStringReducer.

func (*FloatFuncStringReducer) AggregateFloat 

func (r *FloatFuncStringReducer) AggregateFloat(p *FloatPoint)

AggregateFloat takes a FloatPoint and invokes the reduce function with the current and new point to modify the current point.

func (*FloatFuncStringReducer) Emit 

func (r *FloatFuncStringReducer) Emit() []StringPoint

Emit emits the point that was generated when reducing the points fed in with AggregateFloat.

type FloatFuncUnsignedReducer 

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

FloatFuncUnsignedReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewFloatFuncUnsignedReducer 

func NewFloatFuncUnsignedReducer(fn FloatReduceUnsignedFunc, prev *UnsignedPoint) *FloatFuncUnsignedReducer

NewFloatFuncUnsignedReducer creates a new FloatFuncUnsignedReducer.

func (*FloatFuncUnsignedReducer) AggregateFloat 

func (r *FloatFuncUnsignedReducer) AggregateFloat(p *FloatPoint)

AggregateFloat takes a FloatPoint and invokes the reduce function with the current and new point to modify the current point.

func (*FloatFuncUnsignedReducer) Emit 

func (r *FloatFuncUnsignedReducer) Emit() []UnsignedPoint

Emit emits the point that was generated when reducing the points fed in with AggregateFloat.

type FloatHoltWintersReducer 

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

FloatHoltWintersReducer forecasts a series into the future. This is done using the Holt-Winters damped method.

  1. Using the series the initial values are calculated using a SSE.
  2. The series is forecasted into the future using the iterative relations.

func NewFloatHoltWintersReducer 

func NewFloatHoltWintersReducer(h, m int, includeFitData bool, interval time.Duration) *FloatHoltWintersReducer

NewFloatHoltWintersReducer creates a new FloatHoltWintersReducer.

func (*FloatHoltWintersReducer) AggregateFloat 

func (r *FloatHoltWintersReducer) AggregateFloat(p *FloatPoint)

AggregateFloat aggregates a point into the reducer and updates the current window.

func (*FloatHoltWintersReducer) AggregateInteger 

func (r *FloatHoltWintersReducer) AggregateInteger(p *IntegerPoint)

AggregateInteger aggregates a point into the reducer and updates the current window.

func (*FloatHoltWintersReducer) Emit 

func (r *FloatHoltWintersReducer) Emit() []FloatPoint

Emit returns the points generated by the HoltWinters algorithm.

type FloatIntegralReducer 

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

FloatIntegralReducer calculates the time-integral of the aggregated points.

func NewFloatIntegralReducer 

func NewFloatIntegralReducer(interval Interval, opt IteratorOptions) *FloatIntegralReducer

NewFloatIntegralReducer creates a new FloatIntegralReducer.

func (*FloatIntegralReducer) AggregateFloat 

func (r *FloatIntegralReducer) AggregateFloat(p *FloatPoint)

AggregateFloat aggregates a point into the reducer.

func (*FloatIntegralReducer) Close 

func (r *FloatIntegralReducer) Close() error

Close flushes any in progress points to ensure any remaining points are emitted.

func (*FloatIntegralReducer) Emit 

func (r *FloatIntegralReducer) Emit() []FloatPoint

Emit emits the time-integral of the aggregated points as a single point. InfluxQL convention dictates that outside a group-by-time clause we return a timestamp of zero. Within a group-by-time, we can set the time to ZeroTime and a higher level will change it to the start of the time group.

type FloatIterator 

type FloatIterator interface {
	Iterator
	Next() (*FloatPoint, error)
}

FloatIterator represents a stream of float points.

type FloatMeanReducer 

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

FloatMeanReducer calculates the mean of the aggregated points.

func NewFloatMeanReducer 

func NewFloatMeanReducer() *FloatMeanReducer

NewFloatMeanReducer creates a new FloatMeanReducer.

func (*FloatMeanReducer) AggregateFloat 

func (r *FloatMeanReducer) AggregateFloat(p *FloatPoint)

AggregateFloat aggregates a point into the reducer.

func (*FloatMeanReducer) Emit 

func (r *FloatMeanReducer) Emit() []FloatPoint

Emit emits the mean of the aggregated points as a single point.

type FloatMovingAverageReducer 

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

FloatMovingAverageReducer calculates the moving average of the aggregated points.

func NewFloatMovingAverageReducer 

func NewFloatMovingAverageReducer(n int) *FloatMovingAverageReducer

NewFloatMovingAverageReducer creates a new FloatMovingAverageReducer.

func (*FloatMovingAverageReducer) AggregateFloat 

func (r *FloatMovingAverageReducer) AggregateFloat(p *FloatPoint)

AggregateFloat aggregates a point into the reducer and updates the current window.

func (*FloatMovingAverageReducer) Emit 

func (r *FloatMovingAverageReducer) Emit() []FloatPoint

Emit emits the moving average of the current window. Emit should be called after every call to AggregateFloat and it will produce one point if there is enough data to fill a window, otherwise it will produce zero points.

type FloatPoint 

type FloatPoint struct {
	Name string
	Tags Tags

	Time  int64
	Value float64
	Aux   []interface{}

	// Total number of points that were combined into this point from an aggregate.
	// If this is zero, the point is not the result of an aggregate function.
	Aggregated uint32
	Nil        bool
}

FloatPoint represents a point with a float64 value. DO NOT ADD ADDITIONAL FIELDS TO THIS STRUCT. See TestPoint_Fields in influxql/point_test.go for more details.

func FloatMedianReduceSlice 

func FloatMedianReduceSlice(a []FloatPoint) []FloatPoint

FloatMedianReduceSlice returns the median value within a window.

func FloatModeReduceSlice 

func FloatModeReduceSlice(a []FloatPoint) []FloatPoint

FloatModeReduceSlice returns the mode value within a window.

func FloatStddevReduceSlice 

func FloatStddevReduceSlice(a []FloatPoint) []FloatPoint

FloatStddevReduceSlice returns the stddev value within a window.

func IntegerMedianReduceSlice 

func IntegerMedianReduceSlice(a []IntegerPoint) []FloatPoint

IntegerMedianReduceSlice returns the median value within a window.

func IntegerStddevReduceSlice 

func IntegerStddevReduceSlice(a []IntegerPoint) []FloatPoint

IntegerStddevReduceSlice returns the stddev value within a window.

func UnsignedMedianReduceSlice 

func UnsignedMedianReduceSlice(a []UnsignedPoint) []FloatPoint

UnsignedMedianReduceSlice returns the median value within a window.

func UnsignedStddevReduceSlice 

func UnsignedStddevReduceSlice(a []UnsignedPoint) []FloatPoint

UnsignedStddevReduceSlice returns the stddev value within a window.

func (*FloatPoint) Clone 

func (v *FloatPoint) Clone() *FloatPoint

Clone returns a copy of v.

func (*FloatPoint) CopyTo 

func (v *FloatPoint) CopyTo(other *FloatPoint)

CopyTo makes a deep copy into the point.

type FloatPointAggregator 

type FloatPointAggregator interface {
	AggregateFloat(p *FloatPoint)
}

FloatPointAggregator aggregates points to produce a single point.

type FloatPointDecoder 

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

FloatPointDecoder decodes FloatPoint points from a reader.

func NewFloatPointDecoder 

func NewFloatPointDecoder(ctx context.Context, r io.Reader) *FloatPointDecoder

NewFloatPointDecoder returns a new instance of FloatPointDecoder that reads from r.

func (*FloatPointDecoder) DecodeFloatPoint 

func (dec *FloatPointDecoder) DecodeFloatPoint(p *FloatPoint) error

DecodeFloatPoint reads from the underlying reader and unmarshals into p.

func (*FloatPointDecoder) Stats 

func (dec *FloatPointDecoder) Stats() IteratorStats

Stats returns iterator stats embedded within the stream.

type FloatPointEmitter 

type FloatPointEmitter interface {
	Emit() []FloatPoint
}

FloatPointEmitter produces a single point from an aggregate.

type FloatPointEncoder 

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

FloatPointEncoder encodes FloatPoint points to a writer.

func NewFloatPointEncoder 

func NewFloatPointEncoder(w io.Writer) *FloatPointEncoder

NewFloatPointEncoder returns a new instance of FloatPointEncoder that writes to w.

func (*FloatPointEncoder) EncodeFloatPoint 

func (enc *FloatPointEncoder) EncodeFloatPoint(p *FloatPoint) error

EncodeFloatPoint marshals and writes p to the underlying writer.

type FloatReduceBooleanFunc 

type FloatReduceBooleanFunc func(prev *BooleanPoint, curr *FloatPoint) (t int64, v bool, aux []interface{})

FloatReduceBooleanFunc is the function called by a FloatPoint reducer.

type FloatReduceBooleanSliceFunc 

type FloatReduceBooleanSliceFunc func(a []FloatPoint) []BooleanPoint

FloatReduceBooleanSliceFunc is the function called by a FloatPoint reducer.

type FloatReduceFunc 

type FloatReduceFunc func(prev *FloatPoint, curr *FloatPoint) (t int64, v float64, aux []interface{})

FloatReduceFunc is the function called by a FloatPoint reducer.

type FloatReduceIntegerFunc 

type FloatReduceIntegerFunc func(prev *IntegerPoint, curr *FloatPoint) (t int64, v int64, aux []interface{})

FloatReduceIntegerFunc is the function called by a FloatPoint reducer.

type FloatReduceIntegerSliceFunc 

type FloatReduceIntegerSliceFunc func(a []FloatPoint) []IntegerPoint

FloatReduceIntegerSliceFunc is the function called by a FloatPoint reducer.

type FloatReduceSliceFunc 

type FloatReduceSliceFunc func(a []FloatPoint) []FloatPoint

FloatReduceSliceFunc is the function called by a FloatPoint reducer.

func NewFloatPercentileReduceSliceFunc 

func NewFloatPercentileReduceSliceFunc(percentile float64) FloatReduceSliceFunc

NewFloatPercentileReduceSliceFunc returns the percentile value within a window.

type FloatReduceStringFunc 

type FloatReduceStringFunc func(prev *StringPoint, curr *FloatPoint) (t int64, v string, aux []interface{})

FloatReduceStringFunc is the function called by a FloatPoint reducer.

type FloatReduceStringSliceFunc 

type FloatReduceStringSliceFunc func(a []FloatPoint) []StringPoint

FloatReduceStringSliceFunc is the function called by a FloatPoint reducer.

type FloatReduceUnsignedFunc 

type FloatReduceUnsignedFunc func(prev *UnsignedPoint, curr *FloatPoint) (t int64, v uint64, aux []interface{})

FloatReduceUnsignedFunc is the function called by a FloatPoint reducer.

type FloatReduceUnsignedSliceFunc 

type FloatReduceUnsignedSliceFunc func(a []FloatPoint) []UnsignedPoint

FloatReduceUnsignedSliceFunc is the function called by a FloatPoint reducer.

type FloatSampleReducer 

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

FloatSampleReducer implements a reservoir sampling to calculate a random subset of points

func NewFloatSampleReducer 

func NewFloatSampleReducer(size int) *FloatSampleReducer

NewFloatSampleReducer creates a new FloatSampleReducer

func (*FloatSampleReducer) AggregateFloat 

func (r *FloatSampleReducer) AggregateFloat(p *FloatPoint)

AggregateFloat aggregates a point into the reducer.

func (*FloatSampleReducer) Emit 

func (r *FloatSampleReducer) Emit() []FloatPoint

Emit emits the reservoir sample as many points.

type FloatSliceFuncBooleanReducer 

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

FloatSliceFuncBooleanReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewFloatSliceFuncBooleanReducer 

func NewFloatSliceFuncBooleanReducer(fn FloatReduceBooleanSliceFunc) *FloatSliceFuncBooleanReducer

NewFloatSliceFuncBooleanReducer creates a new FloatSliceFuncBooleanReducer.

func (*FloatSliceFuncBooleanReducer) AggregateFloat 

func (r *FloatSliceFuncBooleanReducer) AggregateFloat(p *FloatPoint)

AggregateFloat copies the FloatPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*FloatSliceFuncBooleanReducer) AggregateFloatBulk 

func (r *FloatSliceFuncBooleanReducer) AggregateFloatBulk(points []FloatPoint)

AggregateFloatBulk performs a bulk copy of FloatPoints into the internal slice. This is a more efficient version of calling AggregateFloat on each point.

func (*FloatSliceFuncBooleanReducer) Emit 

func (r *FloatSliceFuncBooleanReducer) Emit() []BooleanPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type FloatSliceFuncIntegerReducer 

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

FloatSliceFuncIntegerReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewFloatSliceFuncIntegerReducer 

func NewFloatSliceFuncIntegerReducer(fn FloatReduceIntegerSliceFunc) *FloatSliceFuncIntegerReducer

NewFloatSliceFuncIntegerReducer creates a new FloatSliceFuncIntegerReducer.

func (*FloatSliceFuncIntegerReducer) AggregateFloat 

func (r *FloatSliceFuncIntegerReducer) AggregateFloat(p *FloatPoint)

AggregateFloat copies the FloatPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*FloatSliceFuncIntegerReducer) AggregateFloatBulk 

func (r *FloatSliceFuncIntegerReducer) AggregateFloatBulk(points []FloatPoint)

AggregateFloatBulk performs a bulk copy of FloatPoints into the internal slice. This is a more efficient version of calling AggregateFloat on each point.

func (*FloatSliceFuncIntegerReducer) Emit 

func (r *FloatSliceFuncIntegerReducer) Emit() []IntegerPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type FloatSliceFuncReducer 

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

FloatSliceFuncReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewFloatSliceFuncReducer 

func NewFloatSliceFuncReducer(fn FloatReduceSliceFunc) *FloatSliceFuncReducer

NewFloatSliceFuncReducer creates a new FloatSliceFuncReducer.

func (*FloatSliceFuncReducer) AggregateFloat 

func (r *FloatSliceFuncReducer) AggregateFloat(p *FloatPoint)

AggregateFloat copies the FloatPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*FloatSliceFuncReducer) AggregateFloatBulk 

func (r *FloatSliceFuncReducer) AggregateFloatBulk(points []FloatPoint)

AggregateFloatBulk performs a bulk copy of FloatPoints into the internal slice. This is a more efficient version of calling AggregateFloat on each point.

func (*FloatSliceFuncReducer) Emit 

func (r *FloatSliceFuncReducer) Emit() []FloatPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type FloatSliceFuncStringReducer 

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

FloatSliceFuncStringReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewFloatSliceFuncStringReducer 

func NewFloatSliceFuncStringReducer(fn FloatReduceStringSliceFunc) *FloatSliceFuncStringReducer

NewFloatSliceFuncStringReducer creates a new FloatSliceFuncStringReducer.

func (*FloatSliceFuncStringReducer) AggregateFloat 

func (r *FloatSliceFuncStringReducer) AggregateFloat(p *FloatPoint)

AggregateFloat copies the FloatPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*FloatSliceFuncStringReducer) AggregateFloatBulk 

func (r *FloatSliceFuncStringReducer) AggregateFloatBulk(points []FloatPoint)

AggregateFloatBulk performs a bulk copy of FloatPoints into the internal slice. This is a more efficient version of calling AggregateFloat on each point.

func (*FloatSliceFuncStringReducer) Emit 

func (r *FloatSliceFuncStringReducer) Emit() []StringPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type FloatSliceFuncUnsignedReducer 

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

FloatSliceFuncUnsignedReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewFloatSliceFuncUnsignedReducer 

func NewFloatSliceFuncUnsignedReducer(fn FloatReduceUnsignedSliceFunc) *FloatSliceFuncUnsignedReducer

NewFloatSliceFuncUnsignedReducer creates a new FloatSliceFuncUnsignedReducer.

func (*FloatSliceFuncUnsignedReducer) AggregateFloat 

func (r *FloatSliceFuncUnsignedReducer) AggregateFloat(p *FloatPoint)

AggregateFloat copies the FloatPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*FloatSliceFuncUnsignedReducer) AggregateFloatBulk 

func (r *FloatSliceFuncUnsignedReducer) AggregateFloatBulk(points []FloatPoint)

AggregateFloatBulk performs a bulk copy of FloatPoints into the internal slice. This is a more efficient version of calling AggregateFloat on each point.

func (*FloatSliceFuncUnsignedReducer) Emit 

func (r *FloatSliceFuncUnsignedReducer) Emit() []UnsignedPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type FloatSpreadReducer 

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

func NewFloatSpreadReducer 

func NewFloatSpreadReducer() *FloatSpreadReducer

func (*FloatSpreadReducer) AggregateFloat 

func (r *FloatSpreadReducer) AggregateFloat(p *FloatPoint)

func (*FloatSpreadReducer) Emit 

func (r *FloatSpreadReducer) Emit() []FloatPoint

type FloatTopReducer 

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

func NewFloatTopReducer 

func NewFloatTopReducer(n int) *FloatTopReducer

func (*FloatTopReducer) AggregateFloat 

func (r *FloatTopReducer) AggregateFloat(p *FloatPoint)

func (*FloatTopReducer) Emit 

func (r *FloatTopReducer) Emit() []FloatPoint

type FunctionTypeMapper 

type FunctionTypeMapper struct {
	CallTypeMapper
}

FunctionTypeMapper handles the type mapping for all functions implemented by the query engine.

func (FunctionTypeMapper) CallType 

func (m FunctionTypeMapper) CallType(name string, args []influxql.DataType) (influxql.DataType, error)

func (FunctionTypeMapper) MapType 

func (FunctionTypeMapper) MapType(measurement *influxql.Measurement, field string) influxql.DataType

type IntegerBottomReducer 

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

func NewIntegerBottomReducer 

func NewIntegerBottomReducer(n int) *IntegerBottomReducer

func (*IntegerBottomReducer) AggregateInteger 

func (r *IntegerBottomReducer) AggregateInteger(p *IntegerPoint)

func (*IntegerBottomReducer) Emit 

func (r *IntegerBottomReducer) Emit() []IntegerPoint

type IntegerBulkPointAggregator 

type IntegerBulkPointAggregator interface {
	AggregateIntegerBulk(points []IntegerPoint)
}

IntegerBulkPointAggregator aggregates multiple points at a time.

type IntegerCumulativeSumReducer 

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

IntegerCumulativeSumReducer cumulates the values from each point.

func NewIntegerCumulativeSumReducer 

func NewIntegerCumulativeSumReducer() *IntegerCumulativeSumReducer

NewIntegerCumulativeSumReducer creates a new IntegerCumulativeSumReducer.

func (*IntegerCumulativeSumReducer) AggregateInteger 

func (r *IntegerCumulativeSumReducer) AggregateInteger(p *IntegerPoint)

func (*IntegerCumulativeSumReducer) Emit 

func (r *IntegerCumulativeSumReducer) Emit() []IntegerPoint

type IntegerDerivativeReducer 

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

IntegerDerivativeReducer calculates the derivative of the aggregated points.

func NewIntegerDerivativeReducer 

func NewIntegerDerivativeReducer(interval Interval, isNonNegative, ascending bool) *IntegerDerivativeReducer

NewIntegerDerivativeReducer creates a new IntegerDerivativeReducer.

func (*IntegerDerivativeReducer) AggregateInteger 

func (r *IntegerDerivativeReducer) AggregateInteger(p *IntegerPoint)

AggregateInteger aggregates a point into the reducer and updates the current window.

func (*IntegerDerivativeReducer) Emit 

func (r *IntegerDerivativeReducer) Emit() []FloatPoint

Emit emits the derivative of the reducer at the current point.

type IntegerDifferenceReducer 

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

IntegerDifferenceReducer calculates the derivative of the aggregated points.

func NewIntegerDifferenceReducer 

func NewIntegerDifferenceReducer(isNonNegative bool) *IntegerDifferenceReducer

NewIntegerDifferenceReducer creates a new IntegerDifferenceReducer.

func (*IntegerDifferenceReducer) AggregateInteger 

func (r *IntegerDifferenceReducer) AggregateInteger(p *IntegerPoint)

AggregateInteger aggregates a point into the reducer and updates the current window.

func (*IntegerDifferenceReducer) Emit 

func (r *IntegerDifferenceReducer) Emit() []IntegerPoint

Emit emits the difference of the reducer at the current point.

type IntegerDistinctReducer 

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

IntegerDistinctReducer returns the distinct points in a series.

func NewIntegerDistinctReducer 

func NewIntegerDistinctReducer() *IntegerDistinctReducer

NewIntegerDistinctReducer creates a new IntegerDistinctReducer.

func (*IntegerDistinctReducer) AggregateInteger 

func (r *IntegerDistinctReducer) AggregateInteger(p *IntegerPoint)

AggregateInteger aggregates a point into the reducer.

func (*IntegerDistinctReducer) Emit 

func (r *IntegerDistinctReducer) Emit() []IntegerPoint

Emit emits the distinct points that have been aggregated into the reducer.

type IntegerElapsedReducer 

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

IntegerElapsedReducer calculates the elapsed of the aggregated points.

func NewIntegerElapsedReducer 

func NewIntegerElapsedReducer(interval Interval) *IntegerElapsedReducer

NewIntegerElapsedReducer creates a new IntegerElapsedReducer.

func (*IntegerElapsedReducer) AggregateInteger 

func (r *IntegerElapsedReducer) AggregateInteger(p *IntegerPoint)

AggregateInteger aggregates a point into the reducer and updates the current window.

func (*IntegerElapsedReducer) Emit 

func (r *IntegerElapsedReducer) Emit() []IntegerPoint

Emit emits the elapsed of the reducer at the current point.

type IntegerFuncBooleanReducer 

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

IntegerFuncBooleanReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewIntegerFuncBooleanReducer 

func NewIntegerFuncBooleanReducer(fn IntegerReduceBooleanFunc, prev *BooleanPoint) *IntegerFuncBooleanReducer

NewIntegerFuncBooleanReducer creates a new IntegerFuncBooleanReducer.

func (*IntegerFuncBooleanReducer) AggregateInteger 

func (r *IntegerFuncBooleanReducer) AggregateInteger(p *IntegerPoint)

AggregateInteger takes a IntegerPoint and invokes the reduce function with the current and new point to modify the current point.

func (*IntegerFuncBooleanReducer) Emit 

func (r *IntegerFuncBooleanReducer) Emit() []BooleanPoint

Emit emits the point that was generated when reducing the points fed in with AggregateInteger.

type IntegerFuncFloatReducer 

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

IntegerFuncFloatReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewIntegerFuncFloatReducer 

func NewIntegerFuncFloatReducer(fn IntegerReduceFloatFunc, prev *FloatPoint) *IntegerFuncFloatReducer

NewIntegerFuncFloatReducer creates a new IntegerFuncFloatReducer.

func (*IntegerFuncFloatReducer) AggregateInteger 

func (r *IntegerFuncFloatReducer) AggregateInteger(p *IntegerPoint)

AggregateInteger takes a IntegerPoint and invokes the reduce function with the current and new point to modify the current point.

func (*IntegerFuncFloatReducer) Emit 

func (r *IntegerFuncFloatReducer) Emit() []FloatPoint

Emit emits the point that was generated when reducing the points fed in with AggregateInteger.

type IntegerFuncReducer 

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

IntegerFuncReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewIntegerFuncReducer 

func NewIntegerFuncReducer(fn IntegerReduceFunc, prev *IntegerPoint) *IntegerFuncReducer

NewIntegerFuncReducer creates a new IntegerFuncIntegerReducer.

func (*IntegerFuncReducer) AggregateInteger 

func (r *IntegerFuncReducer) AggregateInteger(p *IntegerPoint)

AggregateInteger takes a IntegerPoint and invokes the reduce function with the current and new point to modify the current point.

func (*IntegerFuncReducer) Emit 

func (r *IntegerFuncReducer) Emit() []IntegerPoint

Emit emits the point that was generated when reducing the points fed in with AggregateInteger.

type IntegerFuncStringReducer 

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

IntegerFuncStringReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewIntegerFuncStringReducer 

func NewIntegerFuncStringReducer(fn IntegerReduceStringFunc, prev *StringPoint) *IntegerFuncStringReducer

NewIntegerFuncStringReducer creates a new IntegerFuncStringReducer.

func (*IntegerFuncStringReducer) AggregateInteger 

func (r *IntegerFuncStringReducer) AggregateInteger(p *IntegerPoint)

AggregateInteger takes a IntegerPoint and invokes the reduce function with the current and new point to modify the current point.

func (*IntegerFuncStringReducer) Emit 

func (r *IntegerFuncStringReducer) Emit() []StringPoint

Emit emits the point that was generated when reducing the points fed in with AggregateInteger.

type IntegerFuncUnsignedReducer 

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

IntegerFuncUnsignedReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewIntegerFuncUnsignedReducer 

func NewIntegerFuncUnsignedReducer(fn IntegerReduceUnsignedFunc, prev *UnsignedPoint) *IntegerFuncUnsignedReducer

NewIntegerFuncUnsignedReducer creates a new IntegerFuncUnsignedReducer.

func (*IntegerFuncUnsignedReducer) AggregateInteger 

func (r *IntegerFuncUnsignedReducer) AggregateInteger(p *IntegerPoint)

AggregateInteger takes a IntegerPoint and invokes the reduce function with the current and new point to modify the current point.

func (*IntegerFuncUnsignedReducer) Emit 

func (r *IntegerFuncUnsignedReducer) Emit() []UnsignedPoint

Emit emits the point that was generated when reducing the points fed in with AggregateInteger.

type IntegerIntegralReducer 

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

IntegerIntegralReducer calculates the time-integral of the aggregated points.

func NewIntegerIntegralReducer 

func NewIntegerIntegralReducer(interval Interval, opt IteratorOptions) *IntegerIntegralReducer

NewIntegerIntegralReducer creates a new IntegerIntegralReducer.

func (*IntegerIntegralReducer) AggregateInteger 

func (r *IntegerIntegralReducer) AggregateInteger(p *IntegerPoint)

AggregateInteger aggregates a point into the reducer.

func (*IntegerIntegralReducer) Close 

func (r *IntegerIntegralReducer) Close() error

Close flushes any in progress points to ensure any remaining points are emitted.

func (*IntegerIntegralReducer) Emit 

func (r *IntegerIntegralReducer) Emit() []FloatPoint

Emit emits the time-integral of the aggregated points as a single FLOAT point InfluxQL convention dictates that outside a group-by-time clause we return a timestamp of zero. Within a group-by-time, we can set the time to ZeroTime and a higher level will change it to the start of the time group.

type IntegerIterator 

type IntegerIterator interface {
	Iterator
	Next() (*IntegerPoint, error)
}

IntegerIterator represents a stream of integer points.

type IntegerMeanReducer 

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

IntegerMeanReducer calculates the mean of the aggregated points.

func NewIntegerMeanReducer 

func NewIntegerMeanReducer() *IntegerMeanReducer

NewIntegerMeanReducer creates a new IntegerMeanReducer.

func (*IntegerMeanReducer) AggregateInteger 

func (r *IntegerMeanReducer) AggregateInteger(p *IntegerPoint)

AggregateInteger aggregates a point into the reducer.

func (*IntegerMeanReducer) Emit 

func (r *IntegerMeanReducer) Emit() []FloatPoint

Emit emits the mean of the aggregated points as a single point.

type IntegerMovingAverageReducer 

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

IntegerMovingAverageReducer calculates the moving average of the aggregated points.

func NewIntegerMovingAverageReducer 

func NewIntegerMovingAverageReducer(n int) *IntegerMovingAverageReducer

NewIntegerMovingAverageReducer creates a new IntegerMovingAverageReducer.

func (*IntegerMovingAverageReducer) AggregateInteger 

func (r *IntegerMovingAverageReducer) AggregateInteger(p *IntegerPoint)

AggregateInteger aggregates a point into the reducer and updates the current window.

func (*IntegerMovingAverageReducer) Emit 

func (r *IntegerMovingAverageReducer) Emit() []FloatPoint

Emit emits the moving average of the current window. Emit should be called after every call to AggregateInteger and it will produce one point if there is enough data to fill a window, otherwise it will produce zero points.

type IntegerPoint 

type IntegerPoint struct {
	Name string
	Tags Tags

	Time  int64
	Value int64
	Aux   []interface{}

	// Total number of points that were combined into this point from an aggregate.
	// If this is zero, the point is not the result of an aggregate function.
	Aggregated uint32
	Nil        bool
}

IntegerPoint represents a point with a int64 value. DO NOT ADD ADDITIONAL FIELDS TO THIS STRUCT. See TestPoint_Fields in influxql/point_test.go for more details.

func IntegerModeReduceSlice 

func IntegerModeReduceSlice(a []IntegerPoint) []IntegerPoint

IntegerModeReduceSlice returns the mode value within a window.

func (*IntegerPoint) Clone 

func (v *IntegerPoint) Clone() *IntegerPoint

Clone returns a copy of v.

func (*IntegerPoint) CopyTo 

func (v *IntegerPoint) CopyTo(other *IntegerPoint)

CopyTo makes a deep copy into the point.

type IntegerPointAggregator 

type IntegerPointAggregator interface {
	AggregateInteger(p *IntegerPoint)
}

IntegerPointAggregator aggregates points to produce a single point.

type IntegerPointDecoder 

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

IntegerPointDecoder decodes IntegerPoint points from a reader.

func NewIntegerPointDecoder 

func NewIntegerPointDecoder(ctx context.Context, r io.Reader) *IntegerPointDecoder

NewIntegerPointDecoder returns a new instance of IntegerPointDecoder that reads from r.

func (*IntegerPointDecoder) DecodeIntegerPoint 

func (dec *IntegerPointDecoder) DecodeIntegerPoint(p *IntegerPoint) error

DecodeIntegerPoint reads from the underlying reader and unmarshals into p.

func (*IntegerPointDecoder) Stats 

func (dec *IntegerPointDecoder) Stats() IteratorStats

Stats returns iterator stats embedded within the stream.

type IntegerPointEmitter 

type IntegerPointEmitter interface {
	Emit() []IntegerPoint
}

IntegerPointEmitter produces a single point from an aggregate.

type IntegerPointEncoder 

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

IntegerPointEncoder encodes IntegerPoint points to a writer.

func NewIntegerPointEncoder 

func NewIntegerPointEncoder(w io.Writer) *IntegerPointEncoder

NewIntegerPointEncoder returns a new instance of IntegerPointEncoder that writes to w.

func (*IntegerPointEncoder) EncodeIntegerPoint 

func (enc *IntegerPointEncoder) EncodeIntegerPoint(p *IntegerPoint) error

EncodeIntegerPoint marshals and writes p to the underlying writer.

type IntegerReduceBooleanFunc 

type IntegerReduceBooleanFunc func(prev *BooleanPoint, curr *IntegerPoint) (t int64, v bool, aux []interface{})

IntegerReduceBooleanFunc is the function called by a IntegerPoint reducer.

type IntegerReduceBooleanSliceFunc 

type IntegerReduceBooleanSliceFunc func(a []IntegerPoint) []BooleanPoint

IntegerReduceBooleanSliceFunc is the function called by a IntegerPoint reducer.

type IntegerReduceFloatFunc 

type IntegerReduceFloatFunc func(prev *FloatPoint, curr *IntegerPoint) (t int64, v float64, aux []interface{})

IntegerReduceFloatFunc is the function called by a IntegerPoint reducer.

type IntegerReduceFloatSliceFunc 

type IntegerReduceFloatSliceFunc func(a []IntegerPoint) []FloatPoint

IntegerReduceFloatSliceFunc is the function called by a IntegerPoint reducer.

type IntegerReduceFunc 

type IntegerReduceFunc func(prev *IntegerPoint, curr *IntegerPoint) (t int64, v int64, aux []interface{})

IntegerReduceFunc is the function called by a IntegerPoint reducer.

type IntegerReduceSliceFunc 

type IntegerReduceSliceFunc func(a []IntegerPoint) []IntegerPoint

IntegerReduceSliceFunc is the function called by a IntegerPoint reducer.

func NewIntegerPercentileReduceSliceFunc 

func NewIntegerPercentileReduceSliceFunc(percentile float64) IntegerReduceSliceFunc

NewIntegerPercentileReduceSliceFunc returns the percentile value within a window.

type IntegerReduceStringFunc 

type IntegerReduceStringFunc func(prev *StringPoint, curr *IntegerPoint) (t int64, v string, aux []interface{})

IntegerReduceStringFunc is the function called by a IntegerPoint reducer.

type IntegerReduceStringSliceFunc 

type IntegerReduceStringSliceFunc func(a []IntegerPoint) []StringPoint

IntegerReduceStringSliceFunc is the function called by a IntegerPoint reducer.

type IntegerReduceUnsignedFunc 

type IntegerReduceUnsignedFunc func(prev *UnsignedPoint, curr *IntegerPoint) (t int64, v uint64, aux []interface{})

IntegerReduceUnsignedFunc is the function called by a IntegerPoint reducer.

type IntegerReduceUnsignedSliceFunc 

type IntegerReduceUnsignedSliceFunc func(a []IntegerPoint) []UnsignedPoint

IntegerReduceUnsignedSliceFunc is the function called by a IntegerPoint reducer.

type IntegerSampleReducer 

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

IntegerSampleReducer implements a reservoir sampling to calculate a random subset of points

func NewIntegerSampleReducer 

func NewIntegerSampleReducer(size int) *IntegerSampleReducer

NewIntegerSampleReducer creates a new IntegerSampleReducer

func (*IntegerSampleReducer) AggregateInteger 

func (r *IntegerSampleReducer) AggregateInteger(p *IntegerPoint)

AggregateInteger aggregates a point into the reducer.

func (*IntegerSampleReducer) Emit 

func (r *IntegerSampleReducer) Emit() []IntegerPoint

Emit emits the reservoir sample as many points.

type IntegerSliceFuncBooleanReducer 

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

IntegerSliceFuncBooleanReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewIntegerSliceFuncBooleanReducer 

func NewIntegerSliceFuncBooleanReducer(fn IntegerReduceBooleanSliceFunc) *IntegerSliceFuncBooleanReducer

NewIntegerSliceFuncBooleanReducer creates a new IntegerSliceFuncBooleanReducer.

func (*IntegerSliceFuncBooleanReducer) AggregateInteger 

func (r *IntegerSliceFuncBooleanReducer) AggregateInteger(p *IntegerPoint)

AggregateInteger copies the IntegerPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*IntegerSliceFuncBooleanReducer) AggregateIntegerBulk 

func (r *IntegerSliceFuncBooleanReducer) AggregateIntegerBulk(points []IntegerPoint)

AggregateIntegerBulk performs a bulk copy of IntegerPoints into the internal slice. This is a more efficient version of calling AggregateInteger on each point.

func (*IntegerSliceFuncBooleanReducer) Emit 

func (r *IntegerSliceFuncBooleanReducer) Emit() []BooleanPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type IntegerSliceFuncFloatReducer 

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

IntegerSliceFuncFloatReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewIntegerSliceFuncFloatReducer 

func NewIntegerSliceFuncFloatReducer(fn IntegerReduceFloatSliceFunc) *IntegerSliceFuncFloatReducer

NewIntegerSliceFuncFloatReducer creates a new IntegerSliceFuncFloatReducer.

func (*IntegerSliceFuncFloatReducer) AggregateInteger 

func (r *IntegerSliceFuncFloatReducer) AggregateInteger(p *IntegerPoint)

AggregateInteger copies the IntegerPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*IntegerSliceFuncFloatReducer) AggregateIntegerBulk 

func (r *IntegerSliceFuncFloatReducer) AggregateIntegerBulk(points []IntegerPoint)

AggregateIntegerBulk performs a bulk copy of IntegerPoints into the internal slice. This is a more efficient version of calling AggregateInteger on each point.

func (*IntegerSliceFuncFloatReducer) Emit 

func (r *IntegerSliceFuncFloatReducer) Emit() []FloatPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type IntegerSliceFuncReducer 

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

IntegerSliceFuncReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewIntegerSliceFuncReducer 

func NewIntegerSliceFuncReducer(fn IntegerReduceSliceFunc) *IntegerSliceFuncReducer

NewIntegerSliceFuncReducer creates a new IntegerSliceFuncReducer.

func (*IntegerSliceFuncReducer) AggregateInteger 

func (r *IntegerSliceFuncReducer) AggregateInteger(p *IntegerPoint)

AggregateInteger copies the IntegerPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*IntegerSliceFuncReducer) AggregateIntegerBulk 

func (r *IntegerSliceFuncReducer) AggregateIntegerBulk(points []IntegerPoint)

AggregateIntegerBulk performs a bulk copy of IntegerPoints into the internal slice. This is a more efficient version of calling AggregateInteger on each point.

func (*IntegerSliceFuncReducer) Emit 

func (r *IntegerSliceFuncReducer) Emit() []IntegerPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type IntegerSliceFuncStringReducer 

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

IntegerSliceFuncStringReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewIntegerSliceFuncStringReducer 

func NewIntegerSliceFuncStringReducer(fn IntegerReduceStringSliceFunc) *IntegerSliceFuncStringReducer

NewIntegerSliceFuncStringReducer creates a new IntegerSliceFuncStringReducer.

func (*IntegerSliceFuncStringReducer) AggregateInteger 

func (r *IntegerSliceFuncStringReducer) AggregateInteger(p *IntegerPoint)

AggregateInteger copies the IntegerPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*IntegerSliceFuncStringReducer) AggregateIntegerBulk 

func (r *IntegerSliceFuncStringReducer) AggregateIntegerBulk(points []IntegerPoint)

AggregateIntegerBulk performs a bulk copy of IntegerPoints into the internal slice. This is a more efficient version of calling AggregateInteger on each point.

func (*IntegerSliceFuncStringReducer) Emit 

func (r *IntegerSliceFuncStringReducer) Emit() []StringPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type IntegerSliceFuncUnsignedReducer 

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

IntegerSliceFuncUnsignedReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewIntegerSliceFuncUnsignedReducer 

func NewIntegerSliceFuncUnsignedReducer(fn IntegerReduceUnsignedSliceFunc) *IntegerSliceFuncUnsignedReducer

NewIntegerSliceFuncUnsignedReducer creates a new IntegerSliceFuncUnsignedReducer.

func (*IntegerSliceFuncUnsignedReducer) AggregateInteger 

func (r *IntegerSliceFuncUnsignedReducer) AggregateInteger(p *IntegerPoint)

AggregateInteger copies the IntegerPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*IntegerSliceFuncUnsignedReducer) AggregateIntegerBulk 

func (r *IntegerSliceFuncUnsignedReducer) AggregateIntegerBulk(points []IntegerPoint)

AggregateIntegerBulk performs a bulk copy of IntegerPoints into the internal slice. This is a more efficient version of calling AggregateInteger on each point.

func (*IntegerSliceFuncUnsignedReducer) Emit 

func (r *IntegerSliceFuncUnsignedReducer) Emit() []UnsignedPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type IntegerSpreadReducer 

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

func NewIntegerSpreadReducer 

func NewIntegerSpreadReducer() *IntegerSpreadReducer

func (*IntegerSpreadReducer) AggregateInteger 

func (r *IntegerSpreadReducer) AggregateInteger(p *IntegerPoint)

func (*IntegerSpreadReducer) Emit 

func (r *IntegerSpreadReducer) Emit() []IntegerPoint

type IntegerTopReducer 

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

func NewIntegerTopReducer 

func NewIntegerTopReducer(n int) *IntegerTopReducer

func (*IntegerTopReducer) AggregateInteger 

func (r *IntegerTopReducer) AggregateInteger(p *IntegerPoint)

func (*IntegerTopReducer) Emit 

func (r *IntegerTopReducer) Emit() []IntegerPoint

type Interval 

type Interval struct {
	Duration time.Duration
	Offset   time.Duration
}

Interval represents a repeating interval for a query.

func (Interval) IsZero 

func (i Interval) IsZero() bool

IsZero returns true if the interval has no duration.

type Iterator 

type Iterator interface {
	Stats() IteratorStats
	Close() error
}

Iterator represents a generic interface for all Iterators. Most iterator operations are done on the typed sub-interfaces.

func NewCallIterator 

func NewCallIterator(input Iterator, opt IteratorOptions) (Iterator, error)

NewCallIterator returns a new iterator for a Call.

func NewCloseInterruptIterator 

func NewCloseInterruptIterator(input Iterator, closing <-chan struct{}) Iterator

NewCloseInterruptIterator returns an iterator that will invoke the Close() method on an iterator when the passed-in channel has been closed.

func NewDedupeIterator 

func NewDedupeIterator(input Iterator) Iterator

NewDedupeIterator returns an iterator that only outputs unique points. This iterator maintains a serialized copy of each row so it is inefficient to use on large datasets. It is intended for small datasets such as meta queries.

func NewDistinctIterator 

func NewDistinctIterator(input Iterator, opt IteratorOptions) (Iterator, error)

NewDistinctIterator returns an iterator for operating on a distinct() call.

func NewFillIterator 

func NewFillIterator(input Iterator, expr influxql.Expr, opt IteratorOptions) Iterator

NewFillIterator returns an iterator that fills in missing points in an aggregate.

func NewFilterIterator 

func NewFilterIterator(input Iterator, cond influxql.Expr, opt IteratorOptions) Iterator

NewFilterIterator returns an iterator that filters the points based on the condition. This iterator is not nearly as efficient as filtering points within the query engine and is only used when filtering subqueries.

func NewInterruptIterator 

func NewInterruptIterator(input Iterator, closing <-chan struct{}) Iterator

NewInterruptIterator returns an iterator that will stop producing output when the passed-in channel is closed.

func NewIntervalIterator 

func NewIntervalIterator(input Iterator, opt IteratorOptions) Iterator

NewIntervalIterator returns an iterator that sets the time on each point to the interval.

func NewIteratorMapper 

func NewIteratorMapper(cur Cursor, driver IteratorMap, fields []IteratorMap, opt IteratorOptions) Iterator

func NewLimitIterator 

func NewLimitIterator(input Iterator, opt IteratorOptions) Iterator

NewLimitIterator returns an iterator that limits the number of points per grouping.

func NewMedianIterator 

func NewMedianIterator(input Iterator, opt IteratorOptions) (Iterator, error)

NewMedianIterator returns an iterator for operating on a median() call.

func NewMergeIterator 

func NewMergeIterator(inputs []Iterator, opt IteratorOptions) Iterator

NewMergeIterator returns an iterator to merge itrs into one. Inputs must either be merge iterators or only contain a single name/tag in sorted order. The iterator will output all points by window, name/tag, then time. This iterator is useful when you need all of the points for an interval.

func NewModeIterator 

func NewModeIterator(input Iterator, opt IteratorOptions) (Iterator, error)

newModeIterator returns an iterator for operating on a mode() call.

func NewParallelMergeIterator 

func NewParallelMergeIterator(inputs []Iterator, opt IteratorOptions, parallelism int) Iterator

NewParallelMergeIterator returns an iterator that breaks input iterators into groups and processes them in parallel.

func NewReaderIterator 

func NewReaderIterator(ctx context.Context, r io.Reader, typ influxql.DataType, stats IteratorStats) Iterator

NewReaderIterator returns an iterator that streams from a reader.

func NewSampleIterator 

func NewSampleIterator(input Iterator, opt IteratorOptions, size int) (Iterator, error)

NewSampleIterator returns an iterator for operating on a sample() call (exported for use in test).

func NewSortedMergeIterator 

func NewSortedMergeIterator(inputs []Iterator, opt IteratorOptions) Iterator

NewSortedMergeIterator returns an iterator to merge itrs into one. Inputs must either be sorted merge iterators or only contain a single name/tag in sorted order. The iterator will output all points by name/tag, then time. This iterator is useful when you need all points for a name/tag to be in order.

func NewTagSubsetIterator 

func NewTagSubsetIterator(input Iterator, opt IteratorOptions) Iterator

NewTagSubsetIterator will strip each of the points to a subset of the tag key values for each point it processes.

type IteratorCost 

type IteratorCost struct {
	// The total number of shards that are touched by this query.
	NumShards int64

	// The total number of non-unique series that are accessed by this query.
	// This number matches the number of cursors created by the query since
	// one cursor is created for every series.
	NumSeries int64

	// CachedValues returns the number of cached values that may be read by this
	// query.
	CachedValues int64

	// The total number of non-unique files that may be accessed by this query.
	// This will count the number of files accessed by each series so files
	// will likely be double counted.
	NumFiles int64

	// The number of blocks that had the potential to be accessed.
	BlocksRead int64

	// The amount of data that can be potentially read.
	BlockSize int64
}

IteratorCost contains statistics retrieved for explaining what potential cost may be incurred by instantiating an iterator.

func (IteratorCost) Combine 

func (c IteratorCost) Combine(other IteratorCost) IteratorCost

Combine combines the results of two IteratorCost structures into one.

type IteratorCreator 

type IteratorCreator interface {
	// Creates a simple iterator for use in an InfluxQL query.
	CreateIterator(ctx context.Context, source *influxql.Measurement, opt IteratorOptions) (Iterator, error)

	// Determines the potential cost for creating an iterator.
	IteratorCost(source *influxql.Measurement, opt IteratorOptions) (IteratorCost, error)
}

IteratorCreator is an interface to create Iterators.

type IteratorEncoder 

type IteratorEncoder struct {

	// Frequency with which stats are emitted.
	StatsInterval time.Duration
	// contains filtered or unexported fields
}

IteratorEncoder is an encoder for encoding an iterator's points to w.

func NewIteratorEncoder 

func NewIteratorEncoder(w io.Writer) *IteratorEncoder

NewIteratorEncoder encodes an iterator's points to w.

func (*IteratorEncoder) EncodeIterator 

func (enc *IteratorEncoder) EncodeIterator(itr Iterator) error

EncodeIterator encodes and writes all of itr's points to the underlying writer.

func (*IteratorEncoder) EncodeTrace 

func (enc *IteratorEncoder) EncodeTrace(trace *tracing.Trace) error

type IteratorMap 

type IteratorMap interface {
	Value(row *Row) interface{}
}

type IteratorOptions 

type IteratorOptions struct {
	// Expression to iterate for.
	// This can be VarRef or a Call.
	Expr influxql.Expr

	// Auxilary tags or values to also retrieve for the point.
	Aux []influxql.VarRef

	// Data sources from which to receive data. This is only used for encoding
	// measurements over RPC and is no longer used in the open source version.
	Sources []influxql.Source

	// Group by interval and tags.
	Interval   Interval
	Dimensions []string            // The final dimensions of the query (stays the same even in subqueries).
	GroupBy    map[string]struct{} // Dimensions to group points by in intermediate iterators.
	Location   *time.Location

	// Fill options.
	Fill      influxql.FillOption
	FillValue interface{}

	// Condition to filter by.
	Condition influxql.Expr

	// Time range for the iterator.
	StartTime int64
	EndTime   int64

	// Sorted in time ascending order if true.
	Ascending bool

	// Limits the number of points per series.
	Limit, Offset int

	// Limits the number of series.
	SLimit, SOffset int

	// Removes the measurement name. Useful for meta queries.
	StripName bool

	// Removes duplicate rows from raw queries.
	Dedupe bool

	// Determines if this is a query for raw data or an aggregate/selector.
	Ordered bool

	// Limits on the creation of iterators.
	MaxSeriesN int

	// If this channel is set and is closed, the iterator should try to exit
	// and close as soon as possible.
	InterruptCh <-chan struct{}

	// Authorizer can limit access to data
	Authorizer Authorizer
}

IteratorOptions is an object passed to CreateIterator to specify creation options.

func (IteratorOptions) DerivativeInterval 

func (opt IteratorOptions) DerivativeInterval() Interval

DerivativeInterval returns the time interval for the derivative function.

func (IteratorOptions) ElapsedInterval 

func (opt IteratorOptions) ElapsedInterval() Interval

ElapsedInterval returns the time interval for the elapsed function.

func (IteratorOptions) GetDimensions 

func (opt IteratorOptions) GetDimensions() []string

GetDimensions retrieves the dimensions for this query.

func (IteratorOptions) IntegralInterval 

func (opt IteratorOptions) IntegralInterval() Interval

IntegralInterval returns the time interval for the integral function.

func (*IteratorOptions) MarshalBinary 

func (opt *IteratorOptions) MarshalBinary() ([]byte, error)

MarshalBinary encodes opt into a binary format.

func (IteratorOptions) MergeSorted 

func (opt IteratorOptions) MergeSorted() bool

MergeSorted returns true if the options require a sorted merge.

func (IteratorOptions) SeekTime 

func (opt IteratorOptions) SeekTime() int64

SeekTime returns the time the iterator should start from. For ascending iterators this is the start time, for descending iterators it's the end time.

func (IteratorOptions) StopTime 

func (opt IteratorOptions) StopTime() int64

StopTime returns the time the iterator should end at. For ascending iterators this is the end time, for descending iterators it's the start time.

func (*IteratorOptions) UnmarshalBinary 

func (opt *IteratorOptions) UnmarshalBinary(buf []byte) error

UnmarshalBinary decodes from a binary format in to opt.

func (IteratorOptions) Window 

func (opt IteratorOptions) Window(t int64) (start, end int64)

Window returns the time window [start,end) that t falls within.

func (*IteratorOptions) Zone 

func (opt *IteratorOptions) Zone(ns int64) (string, int64)

Zone returns the zone information for the given time. The offset is in nanoseconds.

type IteratorScanner 

type IteratorScanner interface {
	// Peek retrieves information about the next point. It returns a timestamp, the name, and the tags.
	Peek() (int64, string, Tags)

	// ScanAt will take a time, name, and tags and scan the point that matches those into the map.
	ScanAt(ts int64, name string, tags Tags, values map[string]interface{})

	// Stats returns the IteratorStats from the Iterator.
	Stats() IteratorStats

	// Err returns an error that was encountered while scanning.
	Err() error

	io.Closer
}

IteratorScanner is used to scan the results of an iterator into a map.

func NewIteratorScanner 

func NewIteratorScanner(input Iterator, keys []influxql.VarRef, defaultValue interface{}) IteratorScanner

NewIteratorScanner produces an IteratorScanner for the Iterator.

type IteratorStats 

type IteratorStats struct {
	SeriesN int // series represented
	PointN  int // points returned
}

IteratorStats represents statistics about an iterator. Some statistics are available immediately upon iterator creation while some are derived as the iterator processes data.

func (*IteratorStats) Add 

func (s *IteratorStats) Add(other IteratorStats)

Add aggregates fields from s and other together. Overwrites s.

type Iterators 

type Iterators []Iterator

Iterators represents a list of iterators.

func (Iterators) Close 

func (a Iterators) Close() error

Close closes all iterators.

func (Iterators) Merge 

func (a Iterators) Merge(opt IteratorOptions) (Iterator, error)

Merge combines all iterators into a single iterator. A sorted merge iterator or a merge iterator can be used based on opt.

func (Iterators) Stats 

func (a Iterators) Stats() IteratorStats

Stats returns the aggregation of all iterator stats.

type KaufmansAdaptiveMovingAverageReducer 

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

func NewKaufmansAdaptiveMovingAverageReducer 

func NewKaufmansAdaptiveMovingAverageReducer(period int, holdPeriod int) *KaufmansAdaptiveMovingAverageReducer

func (*KaufmansAdaptiveMovingAverageReducer) AggregateFloat 

func (r *KaufmansAdaptiveMovingAverageReducer) AggregateFloat(p *FloatPoint)

func (*KaufmansAdaptiveMovingAverageReducer) AggregateInteger 

func (r *KaufmansAdaptiveMovingAverageReducer) AggregateInteger(p *IntegerPoint)

func (*KaufmansAdaptiveMovingAverageReducer) AggregateUnsigned 

func (r *KaufmansAdaptiveMovingAverageReducer) AggregateUnsigned(p *UnsignedPoint)

func (*KaufmansAdaptiveMovingAverageReducer) Emit 

func (r *KaufmansAdaptiveMovingAverageReducer) Emit() []FloatPoint

type KaufmansEfficiencyRatioReducer 

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

func NewKaufmansEfficiencyRatioReducer 

func NewKaufmansEfficiencyRatioReducer(period int, holdPeriod int) *KaufmansEfficiencyRatioReducer

func (*KaufmansEfficiencyRatioReducer) AggregateFloat 

func (r *KaufmansEfficiencyRatioReducer) AggregateFloat(p *FloatPoint)

func (*KaufmansEfficiencyRatioReducer) AggregateInteger 

func (r *KaufmansEfficiencyRatioReducer) AggregateInteger(p *IntegerPoint)

func (*KaufmansEfficiencyRatioReducer) AggregateUnsigned 

func (r *KaufmansEfficiencyRatioReducer) AggregateUnsigned(p *UnsignedPoint)

func (*KaufmansEfficiencyRatioReducer) Emit 

func (r *KaufmansEfficiencyRatioReducer) Emit() []FloatPoint

type MathTypeMapper 

type MathTypeMapper struct{}

func (MathTypeMapper) CallType 

func (MathTypeMapper) CallType(name string, args []influxql.DataType) (influxql.DataType, error)

func (MathTypeMapper) MapType 

func (MathTypeMapper) MapType(measurement *influxql.Measurement, field string) influxql.DataType

type MathValuer 

type MathValuer struct{}

func (MathValuer) Call 

func (v MathValuer) Call(name string, args []interface{}) (interface{}, bool)

func (MathValuer) Value 

func (MathValuer) Value(key string) (interface{}, bool)

type Message 

type Message struct {
	Level string `json:"level"`
	Text  string `json:"text"`
}

Message represents a user-facing message to be included with the result.

func ReadOnlyWarning 

func ReadOnlyWarning(stmt string) *Message

ReadOnlyWarning generates a warning message that tells the user the command they are using is being used for writing in a read only context.

This is a temporary method while to be used while transitioning to read only operations for issue #6290.

type Monitor 

type Monitor interface {
	// Monitor starts a new goroutine that will monitor a query. The function
	// will be passed in a channel to signal when the query has been finished
	// normally. If the function returns with an error and the query is still
	// running, the query will be terminated.
	Monitor(fn MonitorFunc)
}

Monitor monitors the status of a query and returns whether the query should be aborted with an error.

func MonitorFromContext 

func MonitorFromContext(ctx context.Context) Monitor

MonitorFromContext returns a Monitor embedded within the Context if one exists.

type MonitorFunc 

type MonitorFunc func(<-chan struct{}) error

MonitorFunc is a function that will be called to check if a query is currently healthy. If the query needs to be interrupted for some reason, the error should be returned by this function.

func PointLimitMonitor 

func PointLimitMonitor(cur Cursor, interval time.Duration, limit int) MonitorFunc

PointLimitMonitor is a query monitor that exits when the number of points emitted exceeds a threshold.

type NullMap 

type NullMap struct{}

func (NullMap) Value 

func (NullMap) Value(row *Row) interface{}

type Point 

type Point interface {
	// contains filtered or unexported methods
}

Point represents a value in a series that occurred at a given time.

type PointDecoder 

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

PointDecoder decodes generic points from a reader.

func NewPointDecoder 

func NewPointDecoder(r io.Reader) *PointDecoder

NewPointDecoder returns a new instance of PointDecoder that reads from r.

func (*PointDecoder) DecodePoint 

func (dec *PointDecoder) DecodePoint(p *Point) error

DecodePoint reads from the underlying reader and unmarshals into p.

func (*PointDecoder) Stats 

func (dec *PointDecoder) Stats() IteratorStats

Stats returns iterator stats embedded within the stream.

type Points 

type Points []Point

Points represents a list of points.

func (Points) Clone 

func (a Points) Clone() []Point

Clone returns a deep copy of a.

type PreparedStatement 

type PreparedStatement interface {
	// Select creates the Iterators that will be used to read the query.
	Select(ctx context.Context) (Cursor, error)

	// Explain outputs the explain plan for this statement.
	Explain() (string, error)

	// Close closes the resources associated with this prepared statement.
	// This must be called as the mapped shards may hold open resources such
	// as network connections.
	Close() error
}

Select is a prepared statement that is ready to be executed.

func Prepare 

func Prepare(stmt *influxql.SelectStatement, shardMapper ShardMapper, opt SelectOptions) (PreparedStatement, error)

Prepare will compile the statement with the default compile options and then prepare the query.

type QueryInfo 

type QueryInfo struct {
	ID       uint64        `json:"id"`
	Query    string        `json:"query"`
	Database string        `json:"database"`
	Duration time.Duration `json:"duration"`
	Status   TaskStatus    `json:"status"`
}

QueryInfo represents the information for a query.

type RelativeStrengthIndexReducer 

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

func NewRelativeStrengthIndexReducer 

func NewRelativeStrengthIndexReducer(period int, holdPeriod int, warmupType gota.WarmupType) *RelativeStrengthIndexReducer

func (*RelativeStrengthIndexReducer) AggregateFloat 

func (r *RelativeStrengthIndexReducer) AggregateFloat(p *FloatPoint)

func (*RelativeStrengthIndexReducer) AggregateInteger 

func (r *RelativeStrengthIndexReducer) AggregateInteger(p *IntegerPoint)

func (*RelativeStrengthIndexReducer) AggregateUnsigned 

func (r *RelativeStrengthIndexReducer) AggregateUnsigned(p *UnsignedPoint)

func (*RelativeStrengthIndexReducer) Emit 

func (r *RelativeStrengthIndexReducer) Emit() []FloatPoint

type Result 

type Result struct {
	// StatementID is just the statement's position in the query. It's used
	// to combine statement results if they're being buffered in memory.
	StatementID int
	Series      models.Rows
	Messages    []*Message
	Partial     bool
	Err         error
}

Result represents a resultset returned from a single statement. Rows represents a list of rows that can be sorted consistently by name/tag.

func (*Result) MarshalJSON 

func (r *Result) MarshalJSON() ([]byte, error)

MarshalJSON encodes the result into JSON.

func (*Result) UnmarshalJSON 

func (r *Result) UnmarshalJSON(b []byte) error

UnmarshalJSON decodes the data into the Result struct

type Row 

type Row struct {
	// Time returns the time for this row. If the cursor was created to
	// return time as one of the values, the time will also be included as
	// a time.Time in the appropriate column within Values.
	// This ensures that time is always present in the Row structure
	// even if it hasn't been requested in the output.
	Time int64

	// Series contains the series metadata for this row.
	Series Series

	// Values contains the values within the current row.
	Values []interface{}
}

Row represents a single row returned by the query engine.

type SelectOptions 

type SelectOptions struct {
	// Authorizer is used to limit access to data
	Authorizer Authorizer

	// Node to exclusively read from.
	// If zero, all nodes are used.
	NodeID uint64

	// Maximum number of concurrent series.
	MaxSeriesN int

	// Maximum number of points to read from the query.
	// This requires the passed in context to have a Monitor that is
	// created using WithMonitor.
	MaxPointN int

	// Maximum number of buckets for a statement.
	MaxBucketsN int
}

SelectOptions are options that customize the select call.

type Series 

type Series struct {
	// Name is the measurement name.
	Name string

	// Tags for the series.
	Tags Tags
	// contains filtered or unexported fields
}

Series represents the metadata about a series.

func (Series) Equal 

func (s Series) Equal(other Series) bool

Equal checks to see if the Series are identical.

func (Series) SameSeries 

func (s Series) SameSeries(other Series) bool

SameSeries checks if this is the same series as another one. It does not necessarily check for equality so this is different from checking to see if the name and tags are the same. It checks whether the two are part of the same series in the response.

type ShardGroup 

type ShardGroup interface {
	IteratorCreator
	influxql.FieldMapper
	io.Closer
}

ShardGroup represents a shard or a collection of shards that can be accessed for creating iterators. When creating iterators, the resource used for reading the iterators should be separate from the resource used to map the shards. When the ShardGroup is closed, it should not close any resources associated with the created Iterator. Those resources belong to the Iterator and will be closed when the Iterator itself is closed. The query engine operates under this assumption and will close the shard group after creating the iterators, but before the iterators are actually read.

type ShardMapper 

type ShardMapper interface {
	MapShards(sources influxql.Sources, t influxql.TimeRange, opt SelectOptions) (ShardGroup, error)
}

ShardMapper retrieves and maps shards into an IteratorCreator that can later be used for executing queries.

type Statement 

type Statement interface {
	// Prepare prepares the statement by mapping shards and finishing the creation
	// of the query plan.
	Prepare(shardMapper ShardMapper, opt SelectOptions) (PreparedStatement, error)
}

Statement is a compiled query statement.

func Compile 

func Compile(stmt *influxql.SelectStatement, opt CompileOptions) (Statement, error)

type StatementExecutor 

type StatementExecutor interface {
	// ExecuteStatement executes a statement. Results should be sent to the
	// results channel in the ExecutionContext.
	ExecuteStatement(stmt influxql.Statement, ctx *ExecutionContext) error
}

StatementExecutor executes a statement within the Executor.

type StatementNormalizer 

type StatementNormalizer interface {
	// NormalizeStatement adds a default database and policy to the
	// measurements in the statement.
	NormalizeStatement(stmt influxql.Statement, database, retentionPolicy string) error
}

StatementNormalizer normalizes a statement before it is executed.

type Statistics 

type Statistics struct {
	ActiveQueries          int64
	ExecutedQueries        int64
	FinishedQueries        int64
	QueryExecutionDuration int64
	RecoveredPanics        int64
}

Statistics keeps statistics related to the Executor.

type StringBulkPointAggregator 

type StringBulkPointAggregator interface {
	AggregateStringBulk(points []StringPoint)
}

StringBulkPointAggregator aggregates multiple points at a time.

type StringDistinctReducer 

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

StringDistinctReducer returns the distinct points in a series.

func NewStringDistinctReducer 

func NewStringDistinctReducer() *StringDistinctReducer

NewStringDistinctReducer creates a new StringDistinctReducer.

func (*StringDistinctReducer) AggregateString 

func (r *StringDistinctReducer) AggregateString(p *StringPoint)

AggregateString aggregates a point into the reducer.

func (*StringDistinctReducer) Emit 

func (r *StringDistinctReducer) Emit() []StringPoint

Emit emits the distinct points that have been aggregated into the reducer.

type StringElapsedReducer 

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

StringElapsedReducer calculates the elapsed of the aggregated points.

func NewStringElapsedReducer 

func NewStringElapsedReducer(interval Interval) *StringElapsedReducer

NewStringElapsedReducer creates a new StringElapsedReducer.

func (*StringElapsedReducer) AggregateString 

func (r *StringElapsedReducer) AggregateString(p *StringPoint)

AggregateString aggregates a point into the reducer and updates the current window.

func (*StringElapsedReducer) Emit 

func (r *StringElapsedReducer) Emit() []IntegerPoint

Emit emits the elapsed of the reducer at the current point.

type StringFuncBooleanReducer 

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

StringFuncBooleanReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewStringFuncBooleanReducer 

func NewStringFuncBooleanReducer(fn StringReduceBooleanFunc, prev *BooleanPoint) *StringFuncBooleanReducer

NewStringFuncBooleanReducer creates a new StringFuncBooleanReducer.

func (*StringFuncBooleanReducer) AggregateString 

func (r *StringFuncBooleanReducer) AggregateString(p *StringPoint)

AggregateString takes a StringPoint and invokes the reduce function with the current and new point to modify the current point.

func (*StringFuncBooleanReducer) Emit 

func (r *StringFuncBooleanReducer) Emit() []BooleanPoint

Emit emits the point that was generated when reducing the points fed in with AggregateString.

type StringFuncFloatReducer 

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

StringFuncFloatReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewStringFuncFloatReducer 

func NewStringFuncFloatReducer(fn StringReduceFloatFunc, prev *FloatPoint) *StringFuncFloatReducer

NewStringFuncFloatReducer creates a new StringFuncFloatReducer.

func (*StringFuncFloatReducer) AggregateString 

func (r *StringFuncFloatReducer) AggregateString(p *StringPoint)

AggregateString takes a StringPoint and invokes the reduce function with the current and new point to modify the current point.

func (*StringFuncFloatReducer) Emit 

func (r *StringFuncFloatReducer) Emit() []FloatPoint

Emit emits the point that was generated when reducing the points fed in with AggregateString.

type StringFuncIntegerReducer 

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

StringFuncIntegerReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewStringFuncIntegerReducer 

func NewStringFuncIntegerReducer(fn StringReduceIntegerFunc, prev *IntegerPoint) *StringFuncIntegerReducer

NewStringFuncIntegerReducer creates a new StringFuncIntegerReducer.

func (*StringFuncIntegerReducer) AggregateString 

func (r *StringFuncIntegerReducer) AggregateString(p *StringPoint)

AggregateString takes a StringPoint and invokes the reduce function with the current and new point to modify the current point.

func (*StringFuncIntegerReducer) Emit 

func (r *StringFuncIntegerReducer) Emit() []IntegerPoint

Emit emits the point that was generated when reducing the points fed in with AggregateString.

type StringFuncReducer 

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

StringFuncReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewStringFuncReducer 

func NewStringFuncReducer(fn StringReduceFunc, prev *StringPoint) *StringFuncReducer

NewStringFuncReducer creates a new StringFuncStringReducer.

func (*StringFuncReducer) AggregateString 

func (r *StringFuncReducer) AggregateString(p *StringPoint)

AggregateString takes a StringPoint and invokes the reduce function with the current and new point to modify the current point.

func (*StringFuncReducer) Emit 

func (r *StringFuncReducer) Emit() []StringPoint

Emit emits the point that was generated when reducing the points fed in with AggregateString.

type StringFuncUnsignedReducer 

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

StringFuncUnsignedReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewStringFuncUnsignedReducer 

func NewStringFuncUnsignedReducer(fn StringReduceUnsignedFunc, prev *UnsignedPoint) *StringFuncUnsignedReducer

NewStringFuncUnsignedReducer creates a new StringFuncUnsignedReducer.

func (*StringFuncUnsignedReducer) AggregateString 

func (r *StringFuncUnsignedReducer) AggregateString(p *StringPoint)

AggregateString takes a StringPoint and invokes the reduce function with the current and new point to modify the current point.

func (*StringFuncUnsignedReducer) Emit 

func (r *StringFuncUnsignedReducer) Emit() []UnsignedPoint

Emit emits the point that was generated when reducing the points fed in with AggregateString.

type StringIterator 

type StringIterator interface {
	Iterator
	Next() (*StringPoint, error)
}

StringIterator represents a stream of string points.

type StringPoint 

type StringPoint struct {
	Name string
	Tags Tags

	Time  int64
	Value string
	Aux   []interface{}

	// Total number of points that were combined into this point from an aggregate.
	// If this is zero, the point is not the result of an aggregate function.
	Aggregated uint32
	Nil        bool
}

StringPoint represents a point with a string value. DO NOT ADD ADDITIONAL FIELDS TO THIS STRUCT. See TestPoint_Fields in influxql/point_test.go for more details.

func StringModeReduceSlice 

func StringModeReduceSlice(a []StringPoint) []StringPoint

StringModeReduceSlice returns the mode value within a window.

func (*StringPoint) Clone 

func (v *StringPoint) Clone() *StringPoint

Clone returns a copy of v.

func (*StringPoint) CopyTo 

func (v *StringPoint) CopyTo(other *StringPoint)

CopyTo makes a deep copy into the point.

type StringPointAggregator 

type StringPointAggregator interface {
	AggregateString(p *StringPoint)
}

StringPointAggregator aggregates points to produce a single point.

type StringPointDecoder 

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

StringPointDecoder decodes StringPoint points from a reader.

func NewStringPointDecoder 

func NewStringPointDecoder(ctx context.Context, r io.Reader) *StringPointDecoder

NewStringPointDecoder returns a new instance of StringPointDecoder that reads from r.

func (*StringPointDecoder) DecodeStringPoint 

func (dec *StringPointDecoder) DecodeStringPoint(p *StringPoint) error

DecodeStringPoint reads from the underlying reader and unmarshals into p.

func (*StringPointDecoder) Stats 

func (dec *StringPointDecoder) Stats() IteratorStats

Stats returns iterator stats embedded within the stream.

type StringPointEmitter 

type StringPointEmitter interface {
	Emit() []StringPoint
}

StringPointEmitter produces a single point from an aggregate.

type StringPointEncoder 

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

StringPointEncoder encodes StringPoint points to a writer.

func NewStringPointEncoder 

func NewStringPointEncoder(w io.Writer) *StringPointEncoder

NewStringPointEncoder returns a new instance of StringPointEncoder that writes to w.

func (*StringPointEncoder) EncodeStringPoint 

func (enc *StringPointEncoder) EncodeStringPoint(p *StringPoint) error

EncodeStringPoint marshals and writes p to the underlying writer.

type StringReduceBooleanFunc 

type StringReduceBooleanFunc func(prev *BooleanPoint, curr *StringPoint) (t int64, v bool, aux []interface{})

StringReduceBooleanFunc is the function called by a StringPoint reducer.

type StringReduceBooleanSliceFunc 

type StringReduceBooleanSliceFunc func(a []StringPoint) []BooleanPoint

StringReduceBooleanSliceFunc is the function called by a StringPoint reducer.

type StringReduceFloatFunc 

type StringReduceFloatFunc func(prev *FloatPoint, curr *StringPoint) (t int64, v float64, aux []interface{})

StringReduceFloatFunc is the function called by a StringPoint reducer.

type StringReduceFloatSliceFunc 

type StringReduceFloatSliceFunc func(a []StringPoint) []FloatPoint

StringReduceFloatSliceFunc is the function called by a StringPoint reducer.

type StringReduceFunc 

type StringReduceFunc func(prev *StringPoint, curr *StringPoint) (t int64, v string, aux []interface{})

StringReduceFunc is the function called by a StringPoint reducer.

type StringReduceIntegerFunc 

type StringReduceIntegerFunc func(prev *IntegerPoint, curr *StringPoint) (t int64, v int64, aux []interface{})

StringReduceIntegerFunc is the function called by a StringPoint reducer.

type StringReduceIntegerSliceFunc 

type StringReduceIntegerSliceFunc func(a []StringPoint) []IntegerPoint

StringReduceIntegerSliceFunc is the function called by a StringPoint reducer.

type StringReduceSliceFunc 

type StringReduceSliceFunc func(a []StringPoint) []StringPoint

StringReduceSliceFunc is the function called by a StringPoint reducer.

type StringReduceUnsignedFunc 

type StringReduceUnsignedFunc func(prev *UnsignedPoint, curr *StringPoint) (t int64, v uint64, aux []interface{})

StringReduceUnsignedFunc is the function called by a StringPoint reducer.

type StringReduceUnsignedSliceFunc 

type StringReduceUnsignedSliceFunc func(a []StringPoint) []UnsignedPoint

StringReduceUnsignedSliceFunc is the function called by a StringPoint reducer.

type StringSampleReducer 

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

StringSampleReducer implements a reservoir sampling to calculate a random subset of points

func NewStringSampleReducer 

func NewStringSampleReducer(size int) *StringSampleReducer

NewStringSampleReducer creates a new StringSampleReducer

func (*StringSampleReducer) AggregateString 

func (r *StringSampleReducer) AggregateString(p *StringPoint)

AggregateString aggregates a point into the reducer.

func (*StringSampleReducer) Emit 

func (r *StringSampleReducer) Emit() []StringPoint

Emit emits the reservoir sample as many points.

type StringSliceFuncBooleanReducer 

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

StringSliceFuncBooleanReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewStringSliceFuncBooleanReducer 

func NewStringSliceFuncBooleanReducer(fn StringReduceBooleanSliceFunc) *StringSliceFuncBooleanReducer

NewStringSliceFuncBooleanReducer creates a new StringSliceFuncBooleanReducer.

func (*StringSliceFuncBooleanReducer) AggregateString 

func (r *StringSliceFuncBooleanReducer) AggregateString(p *StringPoint)

AggregateString copies the StringPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*StringSliceFuncBooleanReducer) AggregateStringBulk 

func (r *StringSliceFuncBooleanReducer) AggregateStringBulk(points []StringPoint)

AggregateStringBulk performs a bulk copy of StringPoints into the internal slice. This is a more efficient version of calling AggregateString on each point.

func (*StringSliceFuncBooleanReducer) Emit 

func (r *StringSliceFuncBooleanReducer) Emit() []BooleanPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type StringSliceFuncFloatReducer 

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

StringSliceFuncFloatReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewStringSliceFuncFloatReducer 

func NewStringSliceFuncFloatReducer(fn StringReduceFloatSliceFunc) *StringSliceFuncFloatReducer

NewStringSliceFuncFloatReducer creates a new StringSliceFuncFloatReducer.

func (*StringSliceFuncFloatReducer) AggregateString 

func (r *StringSliceFuncFloatReducer) AggregateString(p *StringPoint)

AggregateString copies the StringPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*StringSliceFuncFloatReducer) AggregateStringBulk 

func (r *StringSliceFuncFloatReducer) AggregateStringBulk(points []StringPoint)

AggregateStringBulk performs a bulk copy of StringPoints into the internal slice. This is a more efficient version of calling AggregateString on each point.

func (*StringSliceFuncFloatReducer) Emit 

func (r *StringSliceFuncFloatReducer) Emit() []FloatPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type StringSliceFuncIntegerReducer 

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

StringSliceFuncIntegerReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewStringSliceFuncIntegerReducer 

func NewStringSliceFuncIntegerReducer(fn StringReduceIntegerSliceFunc) *StringSliceFuncIntegerReducer

NewStringSliceFuncIntegerReducer creates a new StringSliceFuncIntegerReducer.

func (*StringSliceFuncIntegerReducer) AggregateString 

func (r *StringSliceFuncIntegerReducer) AggregateString(p *StringPoint)

AggregateString copies the StringPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*StringSliceFuncIntegerReducer) AggregateStringBulk 

func (r *StringSliceFuncIntegerReducer) AggregateStringBulk(points []StringPoint)

AggregateStringBulk performs a bulk copy of StringPoints into the internal slice. This is a more efficient version of calling AggregateString on each point.

func (*StringSliceFuncIntegerReducer) Emit 

func (r *StringSliceFuncIntegerReducer) Emit() []IntegerPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type StringSliceFuncReducer 

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

StringSliceFuncReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewStringSliceFuncReducer 

func NewStringSliceFuncReducer(fn StringReduceSliceFunc) *StringSliceFuncReducer

NewStringSliceFuncReducer creates a new StringSliceFuncReducer.

func (*StringSliceFuncReducer) AggregateString 

func (r *StringSliceFuncReducer) AggregateString(p *StringPoint)

AggregateString copies the StringPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*StringSliceFuncReducer) AggregateStringBulk 

func (r *StringSliceFuncReducer) AggregateStringBulk(points []StringPoint)

AggregateStringBulk performs a bulk copy of StringPoints into the internal slice. This is a more efficient version of calling AggregateString on each point.

func (*StringSliceFuncReducer) Emit 

func (r *StringSliceFuncReducer) Emit() []StringPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type StringSliceFuncUnsignedReducer 

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

StringSliceFuncUnsignedReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewStringSliceFuncUnsignedReducer 

func NewStringSliceFuncUnsignedReducer(fn StringReduceUnsignedSliceFunc) *StringSliceFuncUnsignedReducer

NewStringSliceFuncUnsignedReducer creates a new StringSliceFuncUnsignedReducer.

func (*StringSliceFuncUnsignedReducer) AggregateString 

func (r *StringSliceFuncUnsignedReducer) AggregateString(p *StringPoint)

AggregateString copies the StringPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*StringSliceFuncUnsignedReducer) AggregateStringBulk 

func (r *StringSliceFuncUnsignedReducer) AggregateStringBulk(points []StringPoint)

AggregateStringBulk performs a bulk copy of StringPoints into the internal slice. This is a more efficient version of calling AggregateString on each point.

func (*StringSliceFuncUnsignedReducer) Emit 

func (r *StringSliceFuncUnsignedReducer) Emit() []UnsignedPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type TagMap 

type TagMap string

func (TagMap) Value 

func (s TagMap) Value(row *Row) interface{}

type TagSet 

type TagSet struct {
	Tags       map[string]string
	Filters    []influxql.Expr
	SeriesKeys []string
	Key        []byte
}

TagSet is a fundamental concept within the query system. It represents a composite series, composed of multiple individual series that share a set of tag attributes.

func LimitTagSets 

func LimitTagSets(a []*TagSet, slimit, soffset int) []*TagSet

LimitTagSets returns a tag set list with SLIMIT and SOFFSET applied.

func (*TagSet) AddFilter 

func (t *TagSet) AddFilter(key string, filter influxql.Expr)

AddFilter adds a series-level filter to the Tagset.

func (*TagSet) Len 

func (t *TagSet) Len() int

func (*TagSet) Less 

func (t *TagSet) Less(i, j int) bool

func (*TagSet) Reverse 

func (t *TagSet) Reverse()

Reverse reverses the order of series keys and filters in the TagSet.

func (*TagSet) Swap 

func (t *TagSet) Swap(i, j int)

type Tags 

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

Tags represent a map of keys and values. It memoizes its key so it can be used efficiently during query execution.

func NewTags 

func NewTags(m map[string]string) Tags

NewTags returns a new instance of Tags.

func (Tags) Equal 

func (t Tags) Equal(other Tags) bool

Equal compares if the Tags are equal to each other.

func (*Tags) Equals 

func (t *Tags) Equals(other *Tags) bool

Equals returns true if t equals other.

func (Tags) ID 

func (t Tags) ID() string

ID returns the string identifier for the tags.

func (Tags) KeyValues 

func (t Tags) KeyValues() map[string]string

KeyValues returns the underlying map for the tags.

func (*Tags) Keys 

func (t *Tags) Keys() []string

Keys returns a sorted list of all keys on the tag.

func (*Tags) Subset 

func (t *Tags) Subset(keys []string) Tags

Subset returns a new tags object with a subset of the keys.

func (*Tags) Value 

func (t *Tags) Value(k string) string

Value returns the value for a given key.

func (*Tags) Values 

func (t *Tags) Values() []string

Values returns a sorted list of all values on the tag.

type Task 

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

Task is the internal data structure for managing queries. For the public use data structure that gets returned, see Task.

func (*Task) Error 

func (q *Task) Error() error

Error returns any asynchronous error that may have occured while executing the query.

func (*Task) Monitor 

func (q *Task) Monitor(fn MonitorFunc)

Monitor starts a new goroutine that will monitor a query. The function will be passed in a channel to signal when the query has been finished normally. If the function returns with an error and the query is still running, the query will be terminated.

type TaskManager 

type TaskManager struct {
	// Query execution timeout.
	QueryTimeout time.Duration

	// Log queries if they are slower than this time.
	// If zero, slow queries will never be logged.
	LogQueriesAfter time.Duration

	// Maximum number of concurrent queries.
	MaxConcurrentQueries int

	// Logger to use for all logging.
	// Defaults to discarding all log output.
	Logger *zap.Logger
	// contains filtered or unexported fields
}

TaskManager takes care of all aspects related to managing running queries.

func NewTaskManager 

func NewTaskManager() *TaskManager

NewTaskManager creates a new TaskManager.

func (*TaskManager) AttachQuery 

func (t *TaskManager) AttachQuery(q *influxql.Query, opt ExecutionOptions, interrupt <-chan struct{}) (*ExecutionContext, func(), error)

AttachQuery attaches a running query to be managed by the TaskManager. Returns the query id of the newly attached query or an error if it was unable to assign a query id or attach the query to the TaskManager. This function also returns a channel that will be closed when this query finishes running.

After a query finishes running, the system is free to reuse a query id.

func (*TaskManager) Close 

func (t *TaskManager) Close() error

Close kills all running queries and prevents new queries from being attached.

func (*TaskManager) DetachQuery 

func (t *TaskManager) DetachQuery(qid uint64) error

DetachQuery removes a query from the query table. If the query is not in the killed state, this will also close the related channel.

func (*TaskManager) ExecuteStatement 

func (t *TaskManager) ExecuteStatement(stmt influxql.Statement, ctx *ExecutionContext) error

ExecuteStatement executes a statement containing one of the task management queries.

func (*TaskManager) KillQuery 

func (t *TaskManager) KillQuery(qid uint64) error

KillQuery enters a query into the killed state and closes the channel from the TaskManager. This method can be used to forcefully terminate a running query.

func (*TaskManager) Queries 

func (t *TaskManager) Queries() []QueryInfo

Queries returns a list of all running queries with information about them.

type TaskStatus 

type TaskStatus int
const (
	// RunningTask is set when the task is running.
	RunningTask TaskStatus = iota + 1

	// KilledTask is set when the task is killed, but resources are still
	// being used.
	KilledTask
)

func (TaskStatus) MarshalJSON 

func (t TaskStatus) MarshalJSON() ([]byte, error)

func (TaskStatus) String 

func (t TaskStatus) String() string

func (*TaskStatus) UnmarshalJSON 

func (t *TaskStatus) UnmarshalJSON(data []byte) error

type TripleExponentialDerivativeReducer 

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

func NewTripleExponentialDerivativeReducer 

func NewTripleExponentialDerivativeReducer(period int, holdPeriod int, warmupType gota.WarmupType) *TripleExponentialDerivativeReducer

func (*TripleExponentialDerivativeReducer) AggregateFloat 

func (r *TripleExponentialDerivativeReducer) AggregateFloat(p *FloatPoint)

func (*TripleExponentialDerivativeReducer) AggregateInteger 

func (r *TripleExponentialDerivativeReducer) AggregateInteger(p *IntegerPoint)

func (*TripleExponentialDerivativeReducer) AggregateUnsigned 

func (r *TripleExponentialDerivativeReducer) AggregateUnsigned(p *UnsignedPoint)

func (*TripleExponentialDerivativeReducer) Emit 

func (r *TripleExponentialDerivativeReducer) Emit() []FloatPoint

type TripleExponentialMovingAverageReducer 

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

func NewTripleExponentialMovingAverageReducer 

func NewTripleExponentialMovingAverageReducer(period int, holdPeriod int, warmupType gota.WarmupType) *TripleExponentialMovingAverageReducer

func (*TripleExponentialMovingAverageReducer) AggregateFloat 

func (r *TripleExponentialMovingAverageReducer) AggregateFloat(p *FloatPoint)

func (*TripleExponentialMovingAverageReducer) AggregateInteger 

func (r *TripleExponentialMovingAverageReducer) AggregateInteger(p *IntegerPoint)

func (*TripleExponentialMovingAverageReducer) AggregateUnsigned 

func (r *TripleExponentialMovingAverageReducer) AggregateUnsigned(p *UnsignedPoint)

func (*TripleExponentialMovingAverageReducer) Emit 

func (r *TripleExponentialMovingAverageReducer) Emit() []FloatPoint

type UnsignedBottomReducer 

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

func NewUnsignedBottomReducer 

func NewUnsignedBottomReducer(n int) *UnsignedBottomReducer

func (*UnsignedBottomReducer) AggregateUnsigned 

func (r *UnsignedBottomReducer) AggregateUnsigned(p *UnsignedPoint)

func (*UnsignedBottomReducer) Emit 

func (r *UnsignedBottomReducer) Emit() []UnsignedPoint

type UnsignedBulkPointAggregator 

type UnsignedBulkPointAggregator interface {
	AggregateUnsignedBulk(points []UnsignedPoint)
}

UnsignedBulkPointAggregator aggregates multiple points at a time.

type UnsignedCumulativeSumReducer 

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

UnsignedCumulativeSumReducer cumulates the values from each point.

func NewUnsignedCumulativeSumReducer 

func NewUnsignedCumulativeSumReducer() *UnsignedCumulativeSumReducer

NewUnsignedCumulativeSumReducer creates a new UnsignedCumulativeSumReducer.

func (*UnsignedCumulativeSumReducer) AggregateUnsigned 

func (r *UnsignedCumulativeSumReducer) AggregateUnsigned(p *UnsignedPoint)

func (*UnsignedCumulativeSumReducer) Emit 

func (r *UnsignedCumulativeSumReducer) Emit() []UnsignedPoint

type UnsignedDerivativeReducer 

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

UnsignedDerivativeReducer calculates the derivative of the aggregated points.

func NewUnsignedDerivativeReducer 

func NewUnsignedDerivativeReducer(interval Interval, isNonNegative, ascending bool) *UnsignedDerivativeReducer

NewUnsignedDerivativeReducer creates a new UnsignedDerivativeReducer.

func (*UnsignedDerivativeReducer) AggregateUnsigned 

func (r *UnsignedDerivativeReducer) AggregateUnsigned(p *UnsignedPoint)

AggregateUnsigned aggregates a point into the reducer and updates the current window.

func (*UnsignedDerivativeReducer) Emit 

func (r *UnsignedDerivativeReducer) Emit() []FloatPoint

Emit emits the derivative of the reducer at the current point.

type UnsignedDifferenceReducer 

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

UnsignedDifferenceReducer calculates the derivative of the aggregated points.

func NewUnsignedDifferenceReducer 

func NewUnsignedDifferenceReducer(isNonNegative bool) *UnsignedDifferenceReducer

NewUnsignedDifferenceReducer creates a new UnsignedDifferenceReducer.

func (*UnsignedDifferenceReducer) AggregateUnsigned 

func (r *UnsignedDifferenceReducer) AggregateUnsigned(p *UnsignedPoint)

AggregateUnsigned aggregates a point into the reducer and updates the current window.

func (*UnsignedDifferenceReducer) Emit 

func (r *UnsignedDifferenceReducer) Emit() []UnsignedPoint

Emit emits the difference of the reducer at the current point.

type UnsignedDistinctReducer 

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

UnsignedDistinctReducer returns the distinct points in a series.

func NewUnsignedDistinctReducer 

func NewUnsignedDistinctReducer() *UnsignedDistinctReducer

NewUnsignedDistinctReducer creates a new UnsignedDistinctReducer.

func (*UnsignedDistinctReducer) AggregateUnsigned 

func (r *UnsignedDistinctReducer) AggregateUnsigned(p *UnsignedPoint)

AggregateUnsigned aggregates a point into the reducer.

func (*UnsignedDistinctReducer) Emit 

func (r *UnsignedDistinctReducer) Emit() []UnsignedPoint

Emit emits the distinct points that have been aggregated into the reducer.

type UnsignedElapsedReducer 

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

UnsignedElapsedReducer calculates the elapsed of the aggregated points.

func NewUnsignedElapsedReducer 

func NewUnsignedElapsedReducer(interval Interval) *UnsignedElapsedReducer

NewUnsignedElapsedReducer creates a new UnsignedElapsedReducer.

func (*UnsignedElapsedReducer) AggregateUnsigned 

func (r *UnsignedElapsedReducer) AggregateUnsigned(p *UnsignedPoint)

AggregateUnsigned aggregates a point into the reducer and updates the current window.

func (*UnsignedElapsedReducer) Emit 

func (r *UnsignedElapsedReducer) Emit() []IntegerPoint

Emit emits the elapsed of the reducer at the current point.

type UnsignedFuncBooleanReducer 

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

UnsignedFuncBooleanReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewUnsignedFuncBooleanReducer 

func NewUnsignedFuncBooleanReducer(fn UnsignedReduceBooleanFunc, prev *BooleanPoint) *UnsignedFuncBooleanReducer

NewUnsignedFuncBooleanReducer creates a new UnsignedFuncBooleanReducer.

func (*UnsignedFuncBooleanReducer) AggregateUnsigned 

func (r *UnsignedFuncBooleanReducer) AggregateUnsigned(p *UnsignedPoint)

AggregateUnsigned takes a UnsignedPoint and invokes the reduce function with the current and new point to modify the current point.

func (*UnsignedFuncBooleanReducer) Emit 

func (r *UnsignedFuncBooleanReducer) Emit() []BooleanPoint

Emit emits the point that was generated when reducing the points fed in with AggregateUnsigned.

type UnsignedFuncFloatReducer 

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

UnsignedFuncFloatReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewUnsignedFuncFloatReducer 

func NewUnsignedFuncFloatReducer(fn UnsignedReduceFloatFunc, prev *FloatPoint) *UnsignedFuncFloatReducer

NewUnsignedFuncFloatReducer creates a new UnsignedFuncFloatReducer.

func (*UnsignedFuncFloatReducer) AggregateUnsigned 

func (r *UnsignedFuncFloatReducer) AggregateUnsigned(p *UnsignedPoint)

AggregateUnsigned takes a UnsignedPoint and invokes the reduce function with the current and new point to modify the current point.

func (*UnsignedFuncFloatReducer) Emit 

func (r *UnsignedFuncFloatReducer) Emit() []FloatPoint

Emit emits the point that was generated when reducing the points fed in with AggregateUnsigned.

type UnsignedFuncIntegerReducer 

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

UnsignedFuncIntegerReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewUnsignedFuncIntegerReducer 

func NewUnsignedFuncIntegerReducer(fn UnsignedReduceIntegerFunc, prev *IntegerPoint) *UnsignedFuncIntegerReducer

NewUnsignedFuncIntegerReducer creates a new UnsignedFuncIntegerReducer.

func (*UnsignedFuncIntegerReducer) AggregateUnsigned 

func (r *UnsignedFuncIntegerReducer) AggregateUnsigned(p *UnsignedPoint)

AggregateUnsigned takes a UnsignedPoint and invokes the reduce function with the current and new point to modify the current point.

func (*UnsignedFuncIntegerReducer) Emit 

func (r *UnsignedFuncIntegerReducer) Emit() []IntegerPoint

Emit emits the point that was generated when reducing the points fed in with AggregateUnsigned.

type UnsignedFuncReducer 

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

UnsignedFuncReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewUnsignedFuncReducer 

func NewUnsignedFuncReducer(fn UnsignedReduceFunc, prev *UnsignedPoint) *UnsignedFuncReducer

NewUnsignedFuncReducer creates a new UnsignedFuncUnsignedReducer.

func (*UnsignedFuncReducer) AggregateUnsigned 

func (r *UnsignedFuncReducer) AggregateUnsigned(p *UnsignedPoint)

AggregateUnsigned takes a UnsignedPoint and invokes the reduce function with the current and new point to modify the current point.

func (*UnsignedFuncReducer) Emit 

func (r *UnsignedFuncReducer) Emit() []UnsignedPoint

Emit emits the point that was generated when reducing the points fed in with AggregateUnsigned.

type UnsignedFuncStringReducer 

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

UnsignedFuncStringReducer is a reducer that reduces the passed in points to a single point using a reduce function.

func NewUnsignedFuncStringReducer 

func NewUnsignedFuncStringReducer(fn UnsignedReduceStringFunc, prev *StringPoint) *UnsignedFuncStringReducer

NewUnsignedFuncStringReducer creates a new UnsignedFuncStringReducer.

func (*UnsignedFuncStringReducer) AggregateUnsigned 

func (r *UnsignedFuncStringReducer) AggregateUnsigned(p *UnsignedPoint)

AggregateUnsigned takes a UnsignedPoint and invokes the reduce function with the current and new point to modify the current point.

func (*UnsignedFuncStringReducer) Emit 

func (r *UnsignedFuncStringReducer) Emit() []StringPoint

Emit emits the point that was generated when reducing the points fed in with AggregateUnsigned.

type UnsignedIntegralReducer 

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

IntegerIntegralReducer calculates the time-integral of the aggregated points.

func NewUnsignedIntegralReducer 

func NewUnsignedIntegralReducer(interval Interval, opt IteratorOptions) *UnsignedIntegralReducer

NewUnsignedIntegralReducer creates a new UnsignedIntegralReducer.

func (*UnsignedIntegralReducer) AggregateUnsigned 

func (r *UnsignedIntegralReducer) AggregateUnsigned(p *UnsignedPoint)

AggregateUnsigned aggregates a point into the reducer.

func (*UnsignedIntegralReducer) Close 

func (r *UnsignedIntegralReducer) Close() error

Close flushes any in progress points to ensure any remaining points are emitted.

func (*UnsignedIntegralReducer) Emit 

func (r *UnsignedIntegralReducer) Emit() []FloatPoint

Emit emits the time-integral of the aggregated points as a single FLOAT point InfluxQL convention dictates that outside a group-by-time clause we return a timestamp of zero. Within a group-by-time, we can set the time to ZeroTime and a higher level will change it to the start of the time group.

type UnsignedIterator 

type UnsignedIterator interface {
	Iterator
	Next() (*UnsignedPoint, error)
}

UnsignedIterator represents a stream of unsigned points.

type UnsignedMeanReducer 

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

UnsignedMeanReducer calculates the mean of the aggregated points.

func NewUnsignedMeanReducer 

func NewUnsignedMeanReducer() *UnsignedMeanReducer

NewUnsignedMeanReducer creates a new UnsignedMeanReducer.

func (*UnsignedMeanReducer) AggregateUnsigned 

func (r *UnsignedMeanReducer) AggregateUnsigned(p *UnsignedPoint)

AggregateUnsigned aggregates a point into the reducer.

func (*UnsignedMeanReducer) Emit 

func (r *UnsignedMeanReducer) Emit() []FloatPoint

Emit emits the mean of the aggregated points as a single point.

type UnsignedMovingAverageReducer 

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

UnsignedMovingAverageReducer calculates the moving average of the aggregated points.

func NewUnsignedMovingAverageReducer 

func NewUnsignedMovingAverageReducer(n int) *UnsignedMovingAverageReducer

NewUnsignedMovingAverageReducer creates a new UnsignedMovingAverageReducer.

func (*UnsignedMovingAverageReducer) AggregateUnsigned 

func (r *UnsignedMovingAverageReducer) AggregateUnsigned(p *UnsignedPoint)

AggregateUnsigned aggregates a point into the reducer and updates the current window.

func (*UnsignedMovingAverageReducer) Emit 

func (r *UnsignedMovingAverageReducer) Emit() []FloatPoint

Emit emits the moving average of the current window. Emit should be called after every call to AggregateUnsigned and it will produce one point if there is enough data to fill a window, otherwise it will produce zero points.

type UnsignedPoint 

type UnsignedPoint struct {
	Name string
	Tags Tags

	Time  int64
	Value uint64
	Aux   []interface{}

	// Total number of points that were combined into this point from an aggregate.
	// If this is zero, the point is not the result of an aggregate function.
	Aggregated uint32
	Nil        bool
}

UnsignedPoint represents a point with a uint64 value. DO NOT ADD ADDITIONAL FIELDS TO THIS STRUCT. See TestPoint_Fields in influxql/point_test.go for more details.

func UnsignedModeReduceSlice 

func UnsignedModeReduceSlice(a []UnsignedPoint) []UnsignedPoint

UnsignedModeReduceSlice returns the mode value within a window.

func (*UnsignedPoint) Clone 

func (v *UnsignedPoint) Clone() *UnsignedPoint

Clone returns a copy of v.

func (*UnsignedPoint) CopyTo 

func (v *UnsignedPoint) CopyTo(other *UnsignedPoint)

CopyTo makes a deep copy into the point.

type UnsignedPointAggregator 

type UnsignedPointAggregator interface {
	AggregateUnsigned(p *UnsignedPoint)
}

UnsignedPointAggregator aggregates points to produce a single point.

type UnsignedPointDecoder 

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

UnsignedPointDecoder decodes UnsignedPoint points from a reader.

func NewUnsignedPointDecoder 

func NewUnsignedPointDecoder(ctx context.Context, r io.Reader) *UnsignedPointDecoder

NewUnsignedPointDecoder returns a new instance of UnsignedPointDecoder that reads from r.

func (*UnsignedPointDecoder) DecodeUnsignedPoint 

func (dec *UnsignedPointDecoder) DecodeUnsignedPoint(p *UnsignedPoint) error

DecodeUnsignedPoint reads from the underlying reader and unmarshals into p.

func (*UnsignedPointDecoder) Stats 

func (dec *UnsignedPointDecoder) Stats() IteratorStats

Stats returns iterator stats embedded within the stream.

type UnsignedPointEmitter 

type UnsignedPointEmitter interface {
	Emit() []UnsignedPoint
}

UnsignedPointEmitter produces a single point from an aggregate.

type UnsignedPointEncoder 

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

UnsignedPointEncoder encodes UnsignedPoint points to a writer.

func NewUnsignedPointEncoder 

func NewUnsignedPointEncoder(w io.Writer) *UnsignedPointEncoder

NewUnsignedPointEncoder returns a new instance of UnsignedPointEncoder that writes to w.

func (*UnsignedPointEncoder) EncodeUnsignedPoint 

func (enc *UnsignedPointEncoder) EncodeUnsignedPoint(p *UnsignedPoint) error

EncodeUnsignedPoint marshals and writes p to the underlying writer.

type UnsignedReduceBooleanFunc 

type UnsignedReduceBooleanFunc func(prev *BooleanPoint, curr *UnsignedPoint) (t int64, v bool, aux []interface{})

UnsignedReduceBooleanFunc is the function called by a UnsignedPoint reducer.

type UnsignedReduceBooleanSliceFunc 

type UnsignedReduceBooleanSliceFunc func(a []UnsignedPoint) []BooleanPoint

UnsignedReduceBooleanSliceFunc is the function called by a UnsignedPoint reducer.

type UnsignedReduceFloatFunc 

type UnsignedReduceFloatFunc func(prev *FloatPoint, curr *UnsignedPoint) (t int64, v float64, aux []interface{})

UnsignedReduceFloatFunc is the function called by a UnsignedPoint reducer.

type UnsignedReduceFloatSliceFunc 

type UnsignedReduceFloatSliceFunc func(a []UnsignedPoint) []FloatPoint

UnsignedReduceFloatSliceFunc is the function called by a UnsignedPoint reducer.

type UnsignedReduceFunc 

type UnsignedReduceFunc func(prev *UnsignedPoint, curr *UnsignedPoint) (t int64, v uint64, aux []interface{})

UnsignedReduceFunc is the function called by a UnsignedPoint reducer.

type UnsignedReduceIntegerFunc 

type UnsignedReduceIntegerFunc func(prev *IntegerPoint, curr *UnsignedPoint) (t int64, v int64, aux []interface{})

UnsignedReduceIntegerFunc is the function called by a UnsignedPoint reducer.

type UnsignedReduceIntegerSliceFunc 

type UnsignedReduceIntegerSliceFunc func(a []UnsignedPoint) []IntegerPoint

UnsignedReduceIntegerSliceFunc is the function called by a UnsignedPoint reducer.

type UnsignedReduceSliceFunc 

type UnsignedReduceSliceFunc func(a []UnsignedPoint) []UnsignedPoint

UnsignedReduceSliceFunc is the function called by a UnsignedPoint reducer.

func NewUnsignedPercentileReduceSliceFunc 

func NewUnsignedPercentileReduceSliceFunc(percentile float64) UnsignedReduceSliceFunc

NewUnsignedPercentileReduceSliceFunc returns the percentile value within a window.

type UnsignedReduceStringFunc 

type UnsignedReduceStringFunc func(prev *StringPoint, curr *UnsignedPoint) (t int64, v string, aux []interface{})

UnsignedReduceStringFunc is the function called by a UnsignedPoint reducer.

type UnsignedReduceStringSliceFunc 

type UnsignedReduceStringSliceFunc func(a []UnsignedPoint) []StringPoint

UnsignedReduceStringSliceFunc is the function called by a UnsignedPoint reducer.

type UnsignedSampleReducer 

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

UnsignedSampleReducer implements a reservoir sampling to calculate a random subset of points

func NewUnsignedSampleReducer 

func NewUnsignedSampleReducer(size int) *UnsignedSampleReducer

NewUnsignedSampleReducer creates a new UnsignedSampleReducer

func (*UnsignedSampleReducer) AggregateUnsigned 

func (r *UnsignedSampleReducer) AggregateUnsigned(p *UnsignedPoint)

AggregateUnsigned aggregates a point into the reducer.

func (*UnsignedSampleReducer) Emit 

func (r *UnsignedSampleReducer) Emit() []UnsignedPoint

Emit emits the reservoir sample as many points.

type UnsignedSliceFuncBooleanReducer 

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

UnsignedSliceFuncBooleanReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewUnsignedSliceFuncBooleanReducer 

func NewUnsignedSliceFuncBooleanReducer(fn UnsignedReduceBooleanSliceFunc) *UnsignedSliceFuncBooleanReducer

NewUnsignedSliceFuncBooleanReducer creates a new UnsignedSliceFuncBooleanReducer.

func (*UnsignedSliceFuncBooleanReducer) AggregateUnsigned 

func (r *UnsignedSliceFuncBooleanReducer) AggregateUnsigned(p *UnsignedPoint)

AggregateUnsigned copies the UnsignedPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*UnsignedSliceFuncBooleanReducer) AggregateUnsignedBulk 

func (r *UnsignedSliceFuncBooleanReducer) AggregateUnsignedBulk(points []UnsignedPoint)

AggregateUnsignedBulk performs a bulk copy of UnsignedPoints into the internal slice. This is a more efficient version of calling AggregateUnsigned on each point.

func (*UnsignedSliceFuncBooleanReducer) Emit 

func (r *UnsignedSliceFuncBooleanReducer) Emit() []BooleanPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type UnsignedSliceFuncFloatReducer 

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

UnsignedSliceFuncFloatReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewUnsignedSliceFuncFloatReducer 

func NewUnsignedSliceFuncFloatReducer(fn UnsignedReduceFloatSliceFunc) *UnsignedSliceFuncFloatReducer

NewUnsignedSliceFuncFloatReducer creates a new UnsignedSliceFuncFloatReducer.

func (*UnsignedSliceFuncFloatReducer) AggregateUnsigned 

func (r *UnsignedSliceFuncFloatReducer) AggregateUnsigned(p *UnsignedPoint)

AggregateUnsigned copies the UnsignedPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*UnsignedSliceFuncFloatReducer) AggregateUnsignedBulk 

func (r *UnsignedSliceFuncFloatReducer) AggregateUnsignedBulk(points []UnsignedPoint)

AggregateUnsignedBulk performs a bulk copy of UnsignedPoints into the internal slice. This is a more efficient version of calling AggregateUnsigned on each point.

func (*UnsignedSliceFuncFloatReducer) Emit 

func (r *UnsignedSliceFuncFloatReducer) Emit() []FloatPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type UnsignedSliceFuncIntegerReducer 

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

UnsignedSliceFuncIntegerReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewUnsignedSliceFuncIntegerReducer 

func NewUnsignedSliceFuncIntegerReducer(fn UnsignedReduceIntegerSliceFunc) *UnsignedSliceFuncIntegerReducer

NewUnsignedSliceFuncIntegerReducer creates a new UnsignedSliceFuncIntegerReducer.

func (*UnsignedSliceFuncIntegerReducer) AggregateUnsigned 

func (r *UnsignedSliceFuncIntegerReducer) AggregateUnsigned(p *UnsignedPoint)

AggregateUnsigned copies the UnsignedPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*UnsignedSliceFuncIntegerReducer) AggregateUnsignedBulk 

func (r *UnsignedSliceFuncIntegerReducer) AggregateUnsignedBulk(points []UnsignedPoint)

AggregateUnsignedBulk performs a bulk copy of UnsignedPoints into the internal slice. This is a more efficient version of calling AggregateUnsigned on each point.

func (*UnsignedSliceFuncIntegerReducer) Emit 

func (r *UnsignedSliceFuncIntegerReducer) Emit() []IntegerPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type UnsignedSliceFuncReducer 

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

UnsignedSliceFuncReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewUnsignedSliceFuncReducer 

func NewUnsignedSliceFuncReducer(fn UnsignedReduceSliceFunc) *UnsignedSliceFuncReducer

NewUnsignedSliceFuncReducer creates a new UnsignedSliceFuncReducer.

func (*UnsignedSliceFuncReducer) AggregateUnsigned 

func (r *UnsignedSliceFuncReducer) AggregateUnsigned(p *UnsignedPoint)

AggregateUnsigned copies the UnsignedPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*UnsignedSliceFuncReducer) AggregateUnsignedBulk 

func (r *UnsignedSliceFuncReducer) AggregateUnsignedBulk(points []UnsignedPoint)

AggregateUnsignedBulk performs a bulk copy of UnsignedPoints into the internal slice. This is a more efficient version of calling AggregateUnsigned on each point.

func (*UnsignedSliceFuncReducer) Emit 

func (r *UnsignedSliceFuncReducer) Emit() []UnsignedPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type UnsignedSliceFuncStringReducer 

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

UnsignedSliceFuncStringReducer is a reducer that aggregates the passed in points and then invokes the function to reduce the points when they are emitted.

func NewUnsignedSliceFuncStringReducer 

func NewUnsignedSliceFuncStringReducer(fn UnsignedReduceStringSliceFunc) *UnsignedSliceFuncStringReducer

NewUnsignedSliceFuncStringReducer creates a new UnsignedSliceFuncStringReducer.

func (*UnsignedSliceFuncStringReducer) AggregateUnsigned 

func (r *UnsignedSliceFuncStringReducer) AggregateUnsigned(p *UnsignedPoint)

AggregateUnsigned copies the UnsignedPoint into the internal slice to be passed to the reduce function when Emit is called.

func (*UnsignedSliceFuncStringReducer) AggregateUnsignedBulk 

func (r *UnsignedSliceFuncStringReducer) AggregateUnsignedBulk(points []UnsignedPoint)

AggregateUnsignedBulk performs a bulk copy of UnsignedPoints into the internal slice. This is a more efficient version of calling AggregateUnsigned on each point.

func (*UnsignedSliceFuncStringReducer) Emit 

func (r *UnsignedSliceFuncStringReducer) Emit() []StringPoint

Emit invokes the reduce function on the aggregated points to generate the aggregated points. This method does not clear the points from the internal slice.

type UnsignedSpreadReducer 

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

func NewUnsignedSpreadReducer 

func NewUnsignedSpreadReducer() *UnsignedSpreadReducer

func (*UnsignedSpreadReducer) AggregateUnsigned 

func (r *UnsignedSpreadReducer) AggregateUnsigned(p *UnsignedPoint)

func (*UnsignedSpreadReducer) Emit 

func (r *UnsignedSpreadReducer) Emit() []UnsignedPoint

type UnsignedTopReducer 

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

func NewUnsignedTopReducer 

func NewUnsignedTopReducer(n int) *UnsignedTopReducer

func (*UnsignedTopReducer) AggregateUnsigned 

func (r *UnsignedTopReducer) AggregateUnsigned(p *UnsignedPoint)

func (*UnsignedTopReducer) Emit 

func (r *UnsignedTopReducer) Emit() []UnsignedPoint

Source Files

View all Source files

Directories

Path Synopsis
Package query is a generated protocol buffer package.
 Package query is a generated protocol buffer package.
gota
Package neldermead is an implementation of the Nelder-Mead optimization method.
 Package neldermead is an implementation of the Nelder-Mead optimization method.

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.