query

package

Go to main page

Versions in this module

v1

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