query

package

Go to main page

Versions in this module

v1

v1.6.204

Sep 21, 2018

v1.6.203

Sep 21, 2018

v1.6.202

Sep 21, 2018

v1.6.201

Aug 28, 2018

v1.6.1

Aug 4, 2018

v1.6.1-exp-tr

Aug 6, 2018

v1.6.1-exp-2-tr

Aug 9, 2018

v1.6.0

Jun 28, 2018

Changes in this version

+ var DefaultTypeMapper = influxql.MultiTypeMapper(FunctionTypeMapper{}, MathTypeMapper{})

+ var NullFloat interface{} = (*float64)(nil)

+ var SkipDefault = interface{}(0)

+ func DrainCursor(cur Cursor) error

+ type CallTypeMapper struct

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

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

+ type ChandeMomentumOscillatorReducer struct

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

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

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

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

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

+ type Cursor interface

+ Close func() error

+ Columns func() []influxql.VarRef

+ Err func() error

+ Scan func(row *Row) bool

+ Stats func() IteratorStats

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

+ type DoubleExponentialMovingAverageReducer struct

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

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

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

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

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

type ExecutionContext

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

+ func (ctx *ExecutionContext) Err() error

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

type ExecutionOptions

+ RetentionPolicy string

+ type Executor struct

+ Logger *zap.Logger

+ StatementExecutor StatementExecutor

+ TaskManager *TaskManager

+ func NewExecutor() *Executor

+ func (e *Executor) Close() error

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

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

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

+ type ExponentialMovingAverageReducer struct

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

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

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

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

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

type FieldMap

+ Index int

+ Type influxql.DataType

+ type FieldMapper struct

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

+ type FloatSpreadReducer struct

+ func NewFloatSpreadReducer() *FloatSpreadReducer

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

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

+ type FunctionTypeMapper struct

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

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

+ type IntegerSpreadReducer struct

+ func NewIntegerSpreadReducer() *IntegerSpreadReducer

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

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

type IteratorOptions

+ func (opt IteratorOptions) StopTime() int64

+ type IteratorScanner interface

+ Err func() error

+ Peek func() (int64, string, Tags)

+ ScanAt func(ts int64, name string, tags Tags, values map[string]interface{})

+ Stats func() IteratorStats

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

+ type KaufmansAdaptiveMovingAverageReducer struct

+ func NewKaufmansAdaptiveMovingAverageReducer(period int, holdPeriod int) *KaufmansAdaptiveMovingAverageReducer

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

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

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

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

+ type KaufmansEfficiencyRatioReducer struct

+ func NewKaufmansEfficiencyRatioReducer(period int, holdPeriod int) *KaufmansEfficiencyRatioReducer

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

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

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

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

+ type MathTypeMapper struct

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

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

+ type MathValuer struct

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

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

+ type Monitor interface

+ Monitor func(fn MonitorFunc)

+ func MonitorFromContext(ctx context.Context) Monitor

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

+ type RelativeStrengthIndexReducer struct

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

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

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

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

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

+ type Row struct

+ Series Series

+ Time int64

+ Values []interface{}

type SelectOptions

+ MaxPointN int

+ type Series struct

+ Name string

+ Tags Tags

+ func (s Series) Equal(other Series) bool

+ func (s Series) SameSeries(other Series) bool

+ type Statistics struct

+ ActiveQueries int64

+ ExecutedQueries int64

+ FinishedQueries int64

+ QueryExecutionDuration int64

+ RecoveredPanics int64

+ type Task struct

+ func (q *Task) Error() error

+ func (q *Task) Monitor(fn MonitorFunc)

+ type TripleExponentialDerivativeReducer struct

+ func NewTripleExponentialDerivativeReducer(period int, holdPeriod int, warmupType gota.WarmupType) *TripleExponentialDerivativeReducer

+ func (r *TripleExponentialDerivativeReducer) AggregateFloat(p *FloatPoint)

+ func (r *TripleExponentialDerivativeReducer) AggregateInteger(p *IntegerPoint)

+ func (r *TripleExponentialDerivativeReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *TripleExponentialDerivativeReducer) Emit() []FloatPoint

+ type TripleExponentialMovingAverageReducer struct

+ func NewTripleExponentialMovingAverageReducer(period int, holdPeriod int, warmupType gota.WarmupType) *TripleExponentialMovingAverageReducer

+ func (r *TripleExponentialMovingAverageReducer) AggregateFloat(p *FloatPoint)

+ func (r *TripleExponentialMovingAverageReducer) AggregateInteger(p *IntegerPoint)

+ func (r *TripleExponentialMovingAverageReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *TripleExponentialMovingAverageReducer) Emit() []FloatPoint

+ type UnsignedSpreadReducer struct

+ func NewUnsignedSpreadReducer() *UnsignedSpreadReducer

+ func (r *UnsignedSpreadReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *UnsignedSpreadReducer) Emit() []UnsignedPoint

v1.5.3

May 25, 2018

Changes in this version

type QueryInfo

+ Status TaskStatus

type TaskStatus

+ func (t *TaskStatus) UnmarshalJSON(data []byte) error

+ func (t TaskStatus) MarshalJSON() ([]byte, error)

v1.5.2

Apr 12, 2018

v1.5.1

Mar 20, 2018

v1.5.0

Mar 6, 2018

Changes in this version

+ func AuthorizerIsOpen(a Authorizer) bool

v1.4.2

Nov 15, 2017

v1.4.1

Nov 14, 2017

v1.4.0

Nov 13, 2017

Changes in this version

+ const DefaultQueryTimeout

+ const DefaultStatsInterval

+ const PanicCrashEnv

+ const WarningLevel

+ const ZeroTime

+ var ErrAlreadyKilled = errors.New("already killed")

+ var ErrInvalidQuery = errors.New("invalid query")

+ var ErrNotExecuted = errors.New("not executed")

+ var ErrQueryAborted = errors.New("query aborted")

+ var ErrQueryEngineShutdown = errors.New("query engine shutdown")

+ var ErrQueryInterrupted = errors.New("query interrupted")

+ var ErrQueryTimeoutLimitExceeded = errors.New("query-timeout limit exceeded")

+ var ErrUnknownCall = errors.New("unknown call")

+ func AggregateBooleanPoints(a BooleanPointAggregator, points []BooleanPoint)

+ func AggregateFloatPoints(a FloatPointAggregator, points []FloatPoint)

+ func AggregateIntegerPoints(a IntegerPointAggregator, points []IntegerPoint)

+ func AggregateStringPoints(a StringPointAggregator, points []StringPoint)

+ func AggregateUnsignedPoints(a UnsignedPointAggregator, points []UnsignedPoint)

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

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

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

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

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

+ func DrainIterator(itr Iterator)

+ func DrainIterators(itrs []Iterator)

+ func ErrDatabaseNotFound(name string) error

+ func ErrMaxConcurrentQueriesLimitExceeded(n, limit int) error

+ func ErrMaxSelectPointsLimitExceeded(n, limit int) error

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type Authorizer interface

+ AuthorizeDatabase func(p influxql.Privilege, name string) bool

+ AuthorizeQuery func(database string, query *influxql.Query) error

+ AuthorizeSeriesRead func(database string, measurement []byte, tags models.Tags) bool

+ AuthorizeSeriesWrite func(database string, measurement []byte, tags models.Tags) bool

+ type AuxIterator interface

+ Background func()

+ Iterator func(name string, typ influxql.DataType) Iterator

+ Start func()

+ func NewAuxIterator(input Iterator, opt IteratorOptions) AuxIterator

+ type BooleanBulkPointAggregator interface

+ AggregateBooleanBulk func(points []BooleanPoint)

+ type BooleanDistinctReducer struct

+ func NewBooleanDistinctReducer() *BooleanDistinctReducer

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

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

+ type BooleanElapsedReducer struct

+ func NewBooleanElapsedReducer(interval Interval) *BooleanElapsedReducer

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

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

+ type BooleanFuncFloatReducer struct

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

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

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

+ type BooleanFuncIntegerReducer struct

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

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

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

+ type BooleanFuncReducer struct

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

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

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

+ type BooleanFuncStringReducer struct

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

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

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

+ type BooleanFuncUnsignedReducer struct

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

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

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

+ type BooleanIterator interface

+ Next func() (*BooleanPoint, error)

+ type BooleanPoint struct

+ Aggregated uint32

+ Aux []interface{}

+ Name string

+ Nil bool

+ Tags Tags

+ Time int64

+ Value bool

+ func BooleanModeReduceSlice(a []BooleanPoint) []BooleanPoint

+ func (v *BooleanPoint) Clone() *BooleanPoint

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

+ type BooleanPointAggregator interface

+ AggregateBoolean func(p *BooleanPoint)

+ type BooleanPointDecoder struct

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

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

+ func (dec *BooleanPointDecoder) Stats() IteratorStats

+ type BooleanPointEmitter interface

+ Emit func() []BooleanPoint

+ type BooleanPointEncoder struct

+ func NewBooleanPointEncoder(w io.Writer) *BooleanPointEncoder

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

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

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

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

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

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

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

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

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

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

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

+ type BooleanSampleReducer struct

+ func NewBooleanSampleReducer(size int) *BooleanSampleReducer

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

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

+ type BooleanSliceFuncFloatReducer struct

+ func NewBooleanSliceFuncFloatReducer(fn BooleanReduceFloatSliceFunc) *BooleanSliceFuncFloatReducer

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

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

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

+ type BooleanSliceFuncIntegerReducer struct

+ func NewBooleanSliceFuncIntegerReducer(fn BooleanReduceIntegerSliceFunc) *BooleanSliceFuncIntegerReducer

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

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

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

+ type BooleanSliceFuncReducer struct

+ func NewBooleanSliceFuncReducer(fn BooleanReduceSliceFunc) *BooleanSliceFuncReducer

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

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

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

+ type BooleanSliceFuncStringReducer struct

+ func NewBooleanSliceFuncStringReducer(fn BooleanReduceStringSliceFunc) *BooleanSliceFuncStringReducer

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

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

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

+ type BooleanSliceFuncUnsignedReducer struct

+ func NewBooleanSliceFuncUnsignedReducer(fn BooleanReduceUnsignedSliceFunc) *BooleanSliceFuncUnsignedReducer

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

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

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

+ type CompileOptions struct

+ Now time.Time

+ type Emitter struct

+ Columns []string

+ EmitName string

+ Location *time.Location

+ OmitTime bool

+ func NewEmitter(itrs []Iterator, ascending bool, chunkSize int) *Emitter

+ func (e *Emitter) Close() error

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

+ type ExecutionContext struct

+ InterruptCh <-chan struct{}

+ Log zap.Logger

+ Query *QueryTask

+ QueryID uint64

+ Results chan *Result

+ StatementID int

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

+ type ExecutionOptions struct

+ AbortCh <-chan struct{}

+ Authorizer Authorizer

+ ChunkSize int

+ Database string

+ NodeID uint64

+ Quiet bool

+ ReadOnly bool

+ type FieldMap int

+ func (i FieldMap) Value(tags Tags, buf []interface{}) interface{}

+ type FloatBottomReducer struct

+ func NewFloatBottomReducer(n int) *FloatBottomReducer

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

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

+ type FloatBulkPointAggregator interface

+ AggregateFloatBulk func(points []FloatPoint)

+ type FloatCumulativeSumReducer struct

+ func NewFloatCumulativeSumReducer() *FloatCumulativeSumReducer

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

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

+ type FloatDerivativeReducer struct

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

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

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

+ type FloatDifferenceReducer struct

+ func NewFloatDifferenceReducer(isNonNegative bool) *FloatDifferenceReducer

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

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

+ type FloatDistinctReducer struct

+ func NewFloatDistinctReducer() *FloatDistinctReducer

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

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

+ type FloatElapsedReducer struct

+ func NewFloatElapsedReducer(interval Interval) *FloatElapsedReducer

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

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

+ type FloatFuncBooleanReducer struct

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

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

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

+ type FloatFuncIntegerReducer struct

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

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

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

+ type FloatFuncReducer struct

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

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

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

+ type FloatFuncStringReducer struct

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

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

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

+ type FloatFuncUnsignedReducer struct

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

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

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

+ type FloatHoltWintersReducer struct

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

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

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

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

+ type FloatIntegralReducer struct

+ func NewFloatIntegralReducer(interval Interval, opt IteratorOptions) *FloatIntegralReducer

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

+ func (r *FloatIntegralReducer) Close() error

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

+ type FloatIterator interface

+ Next func() (*FloatPoint, error)

+ type FloatMeanReducer struct

+ func NewFloatMeanReducer() *FloatMeanReducer

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

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

+ type FloatMovingAverageReducer struct

+ func NewFloatMovingAverageReducer(n int) *FloatMovingAverageReducer

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

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

+ type FloatPoint struct

+ Aggregated uint32

+ Aux []interface{}

+ Name string

+ Nil bool

+ Tags Tags

+ Time int64

+ Value float64

+ func FloatMedianReduceSlice(a []FloatPoint) []FloatPoint

+ func FloatModeReduceSlice(a []FloatPoint) []FloatPoint

+ func FloatSpreadReduceSlice(a []FloatPoint) []FloatPoint

+ func FloatStddevReduceSlice(a []FloatPoint) []FloatPoint

+ func IntegerMedianReduceSlice(a []IntegerPoint) []FloatPoint

+ func IntegerStddevReduceSlice(a []IntegerPoint) []FloatPoint

+ func UnsignedMedianReduceSlice(a []UnsignedPoint) []FloatPoint

+ func UnsignedStddevReduceSlice(a []UnsignedPoint) []FloatPoint

+ func (v *FloatPoint) Clone() *FloatPoint

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

+ type FloatPointAggregator interface

+ AggregateFloat func(p *FloatPoint)

+ type FloatPointDecoder struct

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

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

+ func (dec *FloatPointDecoder) Stats() IteratorStats

+ type FloatPointEmitter interface

+ Emit func() []FloatPoint

+ type FloatPointEncoder struct

+ func NewFloatPointEncoder(w io.Writer) *FloatPointEncoder

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

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

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

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

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

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

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

+ func NewFloatPercentileReduceSliceFunc(percentile float64) FloatReduceSliceFunc

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

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

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

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

+ type FloatSampleReducer struct

+ func NewFloatSampleReducer(size int) *FloatSampleReducer

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

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

+ type FloatSliceFuncBooleanReducer struct

+ func NewFloatSliceFuncBooleanReducer(fn FloatReduceBooleanSliceFunc) *FloatSliceFuncBooleanReducer

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

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

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

+ type FloatSliceFuncIntegerReducer struct

+ func NewFloatSliceFuncIntegerReducer(fn FloatReduceIntegerSliceFunc) *FloatSliceFuncIntegerReducer

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

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

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

+ type FloatSliceFuncReducer struct

+ func NewFloatSliceFuncReducer(fn FloatReduceSliceFunc) *FloatSliceFuncReducer

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

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

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

+ type FloatSliceFuncStringReducer struct

+ func NewFloatSliceFuncStringReducer(fn FloatReduceStringSliceFunc) *FloatSliceFuncStringReducer

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

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

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

+ type FloatSliceFuncUnsignedReducer struct

+ func NewFloatSliceFuncUnsignedReducer(fn FloatReduceUnsignedSliceFunc) *FloatSliceFuncUnsignedReducer

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

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

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

+ type FloatTopReducer struct

+ func NewFloatTopReducer(n int) *FloatTopReducer

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

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

+ type IntegerBottomReducer struct

+ func NewIntegerBottomReducer(n int) *IntegerBottomReducer

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

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

+ type IntegerBulkPointAggregator interface

+ AggregateIntegerBulk func(points []IntegerPoint)

+ type IntegerCumulativeSumReducer struct

+ func NewIntegerCumulativeSumReducer() *IntegerCumulativeSumReducer

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

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

+ type IntegerDerivativeReducer struct

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

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

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

+ type IntegerDifferenceReducer struct

+ func NewIntegerDifferenceReducer(isNonNegative bool) *IntegerDifferenceReducer

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

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

+ type IntegerDistinctReducer struct

+ func NewIntegerDistinctReducer() *IntegerDistinctReducer

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

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

+ type IntegerElapsedReducer struct

+ func NewIntegerElapsedReducer(interval Interval) *IntegerElapsedReducer

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

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

+ type IntegerFuncBooleanReducer struct

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

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

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

+ type IntegerFuncFloatReducer struct

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

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

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

+ type IntegerFuncReducer struct

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

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

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

+ type IntegerFuncStringReducer struct

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

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

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

+ type IntegerFuncUnsignedReducer struct

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

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

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

+ type IntegerIntegralReducer struct

+ func NewIntegerIntegralReducer(interval Interval, opt IteratorOptions) *IntegerIntegralReducer

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

+ func (r *IntegerIntegralReducer) Close() error

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

+ type IntegerIterator interface

+ Next func() (*IntegerPoint, error)

+ type IntegerMeanReducer struct

+ func NewIntegerMeanReducer() *IntegerMeanReducer

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

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

+ type IntegerMovingAverageReducer struct

+ func NewIntegerMovingAverageReducer(n int) *IntegerMovingAverageReducer

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

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

+ type IntegerPoint struct

+ Aggregated uint32

+ Aux []interface{}

+ Name string

+ Nil bool

+ Tags Tags

+ Time int64

+ Value int64

+ func IntegerModeReduceSlice(a []IntegerPoint) []IntegerPoint

+ func IntegerSpreadReduceSlice(a []IntegerPoint) []IntegerPoint

+ func (v *IntegerPoint) Clone() *IntegerPoint

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

+ type IntegerPointAggregator interface

+ AggregateInteger func(p *IntegerPoint)

+ type IntegerPointDecoder struct

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

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

+ func (dec *IntegerPointDecoder) Stats() IteratorStats

+ type IntegerPointEmitter interface

+ Emit func() []IntegerPoint

+ type IntegerPointEncoder struct

+ func NewIntegerPointEncoder(w io.Writer) *IntegerPointEncoder

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

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

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

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

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

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

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

+ func NewIntegerPercentileReduceSliceFunc(percentile float64) IntegerReduceSliceFunc

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

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

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

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

+ type IntegerSampleReducer struct

+ func NewIntegerSampleReducer(size int) *IntegerSampleReducer

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

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

+ type IntegerSliceFuncBooleanReducer struct

+ func NewIntegerSliceFuncBooleanReducer(fn IntegerReduceBooleanSliceFunc) *IntegerSliceFuncBooleanReducer

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

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

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

+ type IntegerSliceFuncFloatReducer struct

+ func NewIntegerSliceFuncFloatReducer(fn IntegerReduceFloatSliceFunc) *IntegerSliceFuncFloatReducer

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

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

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

+ type IntegerSliceFuncReducer struct

+ func NewIntegerSliceFuncReducer(fn IntegerReduceSliceFunc) *IntegerSliceFuncReducer

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

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

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

+ type IntegerSliceFuncStringReducer struct

+ func NewIntegerSliceFuncStringReducer(fn IntegerReduceStringSliceFunc) *IntegerSliceFuncStringReducer

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

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

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

+ type IntegerSliceFuncUnsignedReducer struct

+ func NewIntegerSliceFuncUnsignedReducer(fn IntegerReduceUnsignedSliceFunc) *IntegerSliceFuncUnsignedReducer

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

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

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

+ type IntegerTopReducer struct

+ func NewIntegerTopReducer(n int) *IntegerTopReducer

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

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

+ type Interval struct

+ Duration time.Duration

+ Offset time.Duration

+ func (i Interval) IsZero() bool

+ type Iterator interface

+ Close func() error

+ Stats func() IteratorStats

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

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

+ func NewDedupeIterator(input Iterator) Iterator

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

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

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

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

+ func NewIntervalIterator(input Iterator, opt IteratorOptions) Iterator

+ func NewIteratorMapper(itrs []Iterator, driver IteratorMap, fields []IteratorMap, opt IteratorOptions) Iterator

+ func NewLimitIterator(input Iterator, opt IteratorOptions) Iterator

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

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

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

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

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

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

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

+ func Select(ctx context.Context, stmt *influxql.SelectStatement, shardMapper ShardMapper, ...) ([]Iterator, []string, error)

+ type IteratorCost struct

+ BlockSize int64

+ BlocksRead int64

+ CachedValues int64

+ NumFiles int64

+ NumSeries int64

+ NumShards int64

+ func (c IteratorCost) Combine(other IteratorCost) IteratorCost

+ type IteratorCreator interface

+ CreateIterator func(ctx context.Context, source *influxql.Measurement, opt IteratorOptions) (Iterator, error)

+ IteratorCost func(source *influxql.Measurement, opt IteratorOptions) (IteratorCost, error)

+ type IteratorEncoder struct

+ StatsInterval time.Duration

+ func NewIteratorEncoder(w io.Writer) *IteratorEncoder

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

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

+ type IteratorMap interface

+ Value func(tags Tags, buf []interface{}) interface{}

+ type IteratorOptions struct

+ Ascending bool

+ Authorizer Authorizer

+ Aux []influxql.VarRef

+ Condition influxql.Expr

+ Dedupe bool

+ Dimensions []string

+ EndTime int64

+ Expr influxql.Expr

+ Fill influxql.FillOption

+ FillValue interface{}

+ GroupBy map[string]struct{}

+ InterruptCh <-chan struct{}

+ Interval Interval

+ Limit int

+ Location *time.Location

+ MaxSeriesN int

+ Offset int

+ Ordered bool

+ SLimit int

+ SOffset int

+ Sources []influxql.Source

+ StartTime int64

+ StripName bool

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

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

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

+ func (opt IteratorOptions) DerivativeInterval() Interval

+ func (opt IteratorOptions) ElapsedInterval() Interval

+ func (opt IteratorOptions) GetDimensions() []string

+ func (opt IteratorOptions) IntegralInterval() Interval

+ func (opt IteratorOptions) MergeSorted() bool

+ func (opt IteratorOptions) SeekTime() int64

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

+ type IteratorStats struct

+ PointN int

+ SeriesN int

+ func (s *IteratorStats) Add(other IteratorStats)

+ type Iterators []Iterator

+ func (a Iterators) Close() error

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

+ func (a Iterators) Stats() IteratorStats

+ type Message struct

+ Level string

+ Text string

+ func ReadOnlyWarning(stmt string) *Message

+ type NullMap struct

+ func (NullMap) Value(tags Tags, buf []interface{}) interface{}

+ type OpenAuthorizer struct

+ func (_ OpenAuthorizer) AuthorizeDatabase(influxql.Privilege, string) bool

+ func (_ OpenAuthorizer) AuthorizeQuery(_ string, _ *influxql.Query) error

+ func (_ OpenAuthorizer) AuthorizeSeriesRead(database string, measurement []byte, tags models.Tags) bool

+ func (_ OpenAuthorizer) AuthorizeSeriesWrite(database string, measurement []byte, tags models.Tags) bool

+ type Point interface

+ type PointDecoder struct

+ func NewPointDecoder(r io.Reader) *PointDecoder

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

+ func (dec *PointDecoder) Stats() IteratorStats

+ type Points []Point

+ func (a Points) Clone() []Point

+ type PreparedStatement interface

+ Close func() error

+ Explain func() (string, error)

+ Select func(ctx context.Context) ([]Iterator, []string, error)

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

+ type QueryExecutor struct

+ Logger zap.Logger

+ StatementExecutor StatementExecutor

+ TaskManager *TaskManager

+ func NewQueryExecutor() *QueryExecutor

+ func (e *QueryExecutor) Close() error

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

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

+ func (e *QueryExecutor) WithLogger(log zap.Logger)

+ type QueryInfo struct

+ Database string

+ Duration time.Duration

+ ID uint64

+ Query string

+ type QueryMonitorFunc func(<-chan struct{}) error

+ func PointLimitMonitor(itrs Iterators, interval time.Duration, limit int) QueryMonitorFunc

+ type QueryStatistics struct

+ ActiveQueries int64

+ ExecutedQueries int64

+ FinishedQueries int64

+ QueryExecutionDuration int64

+ RecoveredPanics int64

+ type QueryTask struct

+ func (q *QueryTask) Error() error

+ func (q *QueryTask) Monitor(fn QueryMonitorFunc)

+ type Result struct

+ Err error

+ Messages []*Message

+ Partial bool

+ Series models.Rows

+ StatementID int

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

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

+ type SelectOptions struct

+ Authorizer Authorizer

+ InterruptCh <-chan struct{}

+ MaxBucketsN int

+ MaxSeriesN int

+ NodeID uint64

+ type ShardGroup interface

+ type ShardMapper interface

+ MapShards func(sources influxql.Sources, t influxql.TimeRange, opt SelectOptions) (ShardGroup, error)

+ type Statement interface

+ Prepare func(shardMapper ShardMapper, opt SelectOptions) (PreparedStatement, error)

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

+ type StatementExecutor interface

+ ExecuteStatement func(stmt influxql.Statement, ctx ExecutionContext) error

+ type StatementNormalizer interface

+ NormalizeStatement func(stmt influxql.Statement, database string) error

+ type StringBulkPointAggregator interface

+ AggregateStringBulk func(points []StringPoint)

+ type StringDistinctReducer struct

+ func NewStringDistinctReducer() *StringDistinctReducer

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

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

+ type StringElapsedReducer struct

+ func NewStringElapsedReducer(interval Interval) *StringElapsedReducer

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

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

+ type StringFuncBooleanReducer struct

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

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

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

+ type StringFuncFloatReducer struct

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

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

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

+ type StringFuncIntegerReducer struct

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

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

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

+ type StringFuncReducer struct

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

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

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

+ type StringFuncUnsignedReducer struct

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

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

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

+ type StringIterator interface

+ Next func() (*StringPoint, error)

+ type StringPoint struct

+ Aggregated uint32

+ Aux []interface{}

+ Name string

+ Nil bool

+ Tags Tags

+ Time int64

+ Value string

+ func StringModeReduceSlice(a []StringPoint) []StringPoint

+ func (v *StringPoint) Clone() *StringPoint

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

+ type StringPointAggregator interface

+ AggregateString func(p *StringPoint)

+ type StringPointDecoder struct

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

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

+ func (dec *StringPointDecoder) Stats() IteratorStats

+ type StringPointEmitter interface

+ Emit func() []StringPoint

+ type StringPointEncoder struct

+ func NewStringPointEncoder(w io.Writer) *StringPointEncoder

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

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

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

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

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

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

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

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

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

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

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

+ type StringSampleReducer struct

+ func NewStringSampleReducer(size int) *StringSampleReducer

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

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

+ type StringSliceFuncBooleanReducer struct

+ func NewStringSliceFuncBooleanReducer(fn StringReduceBooleanSliceFunc) *StringSliceFuncBooleanReducer

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

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

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

+ type StringSliceFuncFloatReducer struct

+ func NewStringSliceFuncFloatReducer(fn StringReduceFloatSliceFunc) *StringSliceFuncFloatReducer

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

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

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

+ type StringSliceFuncIntegerReducer struct

+ func NewStringSliceFuncIntegerReducer(fn StringReduceIntegerSliceFunc) *StringSliceFuncIntegerReducer

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

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

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

+ type StringSliceFuncReducer struct

+ func NewStringSliceFuncReducer(fn StringReduceSliceFunc) *StringSliceFuncReducer

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

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

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

+ type StringSliceFuncUnsignedReducer struct

+ func NewStringSliceFuncUnsignedReducer(fn StringReduceUnsignedSliceFunc) *StringSliceFuncUnsignedReducer

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

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

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

+ type TagMap string

+ func (s TagMap) Value(tags Tags, buf []interface{}) interface{}

+ type TagSet struct

+ Filters []influxql.Expr

+ Key []byte

+ SeriesKeys []string

+ Tags map[string]string

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

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

+ func (t *TagSet) Len() int

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

+ func (t *TagSet) Reverse()

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

+ type Tags struct

+ func NewTags(m map[string]string) Tags

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

+ func (t *Tags) Keys() []string

+ func (t *Tags) Subset(keys []string) Tags

+ func (t *Tags) Value(k string) string

+ func (t *Tags) Values() []string

+ func (t Tags) Equal(other Tags) bool

+ func (t Tags) ID() string

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

+ type TaskManager struct

+ LogQueriesAfter time.Duration

+ Logger zap.Logger

+ MaxConcurrentQueries int

+ QueryTimeout time.Duration

+ func NewTaskManager() *TaskManager

+ func (t *TaskManager) AttachQuery(q *influxql.Query, database string, interrupt <-chan struct{}) (uint64, *QueryTask, error)

+ func (t *TaskManager) Close() error

+ func (t *TaskManager) DetachQuery(qid uint64) error

+ func (t *TaskManager) ExecuteStatement(stmt influxql.Statement, ctx ExecutionContext) error

+ func (t *TaskManager) KillQuery(qid uint64) error

+ func (t *TaskManager) Queries() []QueryInfo

+ type TaskStatus int

+ const KilledTask

+ const RunningTask

+ func (t TaskStatus) String() string

+ type UnsignedBottomReducer struct

+ func NewUnsignedBottomReducer(n int) *UnsignedBottomReducer

+ func (r *UnsignedBottomReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *UnsignedBottomReducer) Emit() []UnsignedPoint

+ type UnsignedBulkPointAggregator interface

+ AggregateUnsignedBulk func(points []UnsignedPoint)

+ type UnsignedCumulativeSumReducer struct

+ func NewUnsignedCumulativeSumReducer() *UnsignedCumulativeSumReducer

+ func (r *UnsignedCumulativeSumReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *UnsignedCumulativeSumReducer) Emit() []UnsignedPoint

+ type UnsignedDerivativeReducer struct

+ func NewUnsignedDerivativeReducer(interval Interval, isNonNegative, ascending bool) *UnsignedDerivativeReducer

+ func (r *UnsignedDerivativeReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *UnsignedDerivativeReducer) Emit() []FloatPoint

+ type UnsignedDifferenceReducer struct

+ func NewUnsignedDifferenceReducer(isNonNegative bool) *UnsignedDifferenceReducer

+ func (r *UnsignedDifferenceReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *UnsignedDifferenceReducer) Emit() []UnsignedPoint

+ type UnsignedDistinctReducer struct

+ func NewUnsignedDistinctReducer() *UnsignedDistinctReducer

+ func (r *UnsignedDistinctReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *UnsignedDistinctReducer) Emit() []UnsignedPoint

+ type UnsignedElapsedReducer struct

+ func NewUnsignedElapsedReducer(interval Interval) *UnsignedElapsedReducer

+ func (r *UnsignedElapsedReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *UnsignedElapsedReducer) Emit() []IntegerPoint

+ type UnsignedFuncBooleanReducer struct

+ func NewUnsignedFuncBooleanReducer(fn UnsignedReduceBooleanFunc, prev *BooleanPoint) *UnsignedFuncBooleanReducer

+ func (r *UnsignedFuncBooleanReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *UnsignedFuncBooleanReducer) Emit() []BooleanPoint

+ type UnsignedFuncFloatReducer struct

+ func NewUnsignedFuncFloatReducer(fn UnsignedReduceFloatFunc, prev *FloatPoint) *UnsignedFuncFloatReducer

+ func (r *UnsignedFuncFloatReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *UnsignedFuncFloatReducer) Emit() []FloatPoint

+ type UnsignedFuncIntegerReducer struct

+ func NewUnsignedFuncIntegerReducer(fn UnsignedReduceIntegerFunc, prev *IntegerPoint) *UnsignedFuncIntegerReducer

+ func (r *UnsignedFuncIntegerReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *UnsignedFuncIntegerReducer) Emit() []IntegerPoint

+ type UnsignedFuncReducer struct

+ func NewUnsignedFuncReducer(fn UnsignedReduceFunc, prev *UnsignedPoint) *UnsignedFuncReducer

+ func (r *UnsignedFuncReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *UnsignedFuncReducer) Emit() []UnsignedPoint

+ type UnsignedFuncStringReducer struct

+ func NewUnsignedFuncStringReducer(fn UnsignedReduceStringFunc, prev *StringPoint) *UnsignedFuncStringReducer

+ func (r *UnsignedFuncStringReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *UnsignedFuncStringReducer) Emit() []StringPoint

+ type UnsignedIntegralReducer struct

+ func NewUnsignedIntegralReducer(interval Interval, opt IteratorOptions) *UnsignedIntegralReducer

+ func (r *UnsignedIntegralReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *UnsignedIntegralReducer) Close() error

+ func (r *UnsignedIntegralReducer) Emit() []FloatPoint

+ type UnsignedIterator interface

+ Next func() (*UnsignedPoint, error)

+ type UnsignedMeanReducer struct

+ func NewUnsignedMeanReducer() *UnsignedMeanReducer

+ func (r *UnsignedMeanReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *UnsignedMeanReducer) Emit() []FloatPoint

+ type UnsignedMovingAverageReducer struct

+ func NewUnsignedMovingAverageReducer(n int) *UnsignedMovingAverageReducer

+ func (r *UnsignedMovingAverageReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *UnsignedMovingAverageReducer) Emit() []FloatPoint

+ type UnsignedPoint struct

+ Aggregated uint32

+ Aux []interface{}

+ Name string

+ Nil bool

+ Tags Tags

+ Time int64

+ Value uint64

+ func UnsignedModeReduceSlice(a []UnsignedPoint) []UnsignedPoint

+ func UnsignedSpreadReduceSlice(a []UnsignedPoint) []UnsignedPoint

+ func (v *UnsignedPoint) Clone() *UnsignedPoint

+ func (v *UnsignedPoint) CopyTo(other *UnsignedPoint)

+ type UnsignedPointAggregator interface

+ AggregateUnsigned func(p *UnsignedPoint)

+ type UnsignedPointDecoder struct

+ func NewUnsignedPointDecoder(ctx context.Context, r io.Reader) *UnsignedPointDecoder

+ func (dec *UnsignedPointDecoder) DecodeUnsignedPoint(p *UnsignedPoint) error

+ func (dec *UnsignedPointDecoder) Stats() IteratorStats

+ type UnsignedPointEmitter interface

+ Emit func() []UnsignedPoint

+ type UnsignedPointEncoder struct

+ func NewUnsignedPointEncoder(w io.Writer) *UnsignedPointEncoder

+ func (enc *UnsignedPointEncoder) EncodeUnsignedPoint(p *UnsignedPoint) error

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

+ type UnsignedReduceBooleanSliceFunc func(a []UnsignedPoint) []BooleanPoint

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

+ type UnsignedReduceFloatSliceFunc func(a []UnsignedPoint) []FloatPoint

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

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

+ type UnsignedReduceIntegerSliceFunc func(a []UnsignedPoint) []IntegerPoint

+ type UnsignedReduceSliceFunc func(a []UnsignedPoint) []UnsignedPoint

+ func NewUnsignedPercentileReduceSliceFunc(percentile float64) UnsignedReduceSliceFunc

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

+ type UnsignedReduceStringSliceFunc func(a []UnsignedPoint) []StringPoint

+ type UnsignedSampleReducer struct

+ func NewUnsignedSampleReducer(size int) *UnsignedSampleReducer

+ func (r *UnsignedSampleReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *UnsignedSampleReducer) Emit() []UnsignedPoint

+ type UnsignedSliceFuncBooleanReducer struct

+ func NewUnsignedSliceFuncBooleanReducer(fn UnsignedReduceBooleanSliceFunc) *UnsignedSliceFuncBooleanReducer

+ func (r *UnsignedSliceFuncBooleanReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *UnsignedSliceFuncBooleanReducer) AggregateUnsignedBulk(points []UnsignedPoint)

+ func (r *UnsignedSliceFuncBooleanReducer) Emit() []BooleanPoint

+ type UnsignedSliceFuncFloatReducer struct

+ func NewUnsignedSliceFuncFloatReducer(fn UnsignedReduceFloatSliceFunc) *UnsignedSliceFuncFloatReducer

+ func (r *UnsignedSliceFuncFloatReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *UnsignedSliceFuncFloatReducer) AggregateUnsignedBulk(points []UnsignedPoint)

+ func (r *UnsignedSliceFuncFloatReducer) Emit() []FloatPoint

+ type UnsignedSliceFuncIntegerReducer struct

+ func NewUnsignedSliceFuncIntegerReducer(fn UnsignedReduceIntegerSliceFunc) *UnsignedSliceFuncIntegerReducer

+ func (r *UnsignedSliceFuncIntegerReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *UnsignedSliceFuncIntegerReducer) AggregateUnsignedBulk(points []UnsignedPoint)

+ func (r *UnsignedSliceFuncIntegerReducer) Emit() []IntegerPoint

+ type UnsignedSliceFuncReducer struct

+ func NewUnsignedSliceFuncReducer(fn UnsignedReduceSliceFunc) *UnsignedSliceFuncReducer

+ func (r *UnsignedSliceFuncReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *UnsignedSliceFuncReducer) AggregateUnsignedBulk(points []UnsignedPoint)

+ func (r *UnsignedSliceFuncReducer) Emit() []UnsignedPoint

+ type UnsignedSliceFuncStringReducer struct

+ func NewUnsignedSliceFuncStringReducer(fn UnsignedReduceStringSliceFunc) *UnsignedSliceFuncStringReducer

+ func (r *UnsignedSliceFuncStringReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *UnsignedSliceFuncStringReducer) AggregateUnsignedBulk(points []UnsignedPoint)

+ func (r *UnsignedSliceFuncStringReducer) Emit() []StringPoint

+ type UnsignedTopReducer struct

+ func NewUnsignedTopReducer(n int) *UnsignedTopReducer

+ func (r *UnsignedTopReducer) AggregateUnsigned(p *UnsignedPoint)

+ func (r *UnsignedTopReducer) Emit() []UnsignedPoint

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL