influxql

Aug 23, 2017

Changes in this version

type NowValuer

+ Location *time.Location

+ func (v *NowValuer) Zone() *time.Location

+ type ZoneValuer interface

+ Zone func() *time.Location

Jun 21, 2017

Changes in this version

+ type Authorizer interface

+ AuthorizeDatabase func(p Privilege, name string) bool

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

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

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

type Emitter

+ Location *time.Location

type ExecutionOptions

+ Authorizer Authorizer

+ type FloatBottomReducer struct

+ func NewFloatBottomReducer(n int) *FloatBottomReducer

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

+ func (r *FloatBottomReducer) 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 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 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 IntegerTopReducer struct

+ func NewIntegerTopReducer(n int) *IntegerTopReducer

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

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

type IteratorOptions

+ Authorizer Authorizer

+ Location *time.Location

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

+ func (opt IteratorOptions) IntegralInterval() Interval

+ type NullMap struct

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

+ type OpenAuthorizer struct

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

+ func (_ OpenAuthorizer) AuthorizeQuery(_ string, _ *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 SelectOptions

+ Authorizer Authorizer

type SelectStatement

+ Location *time.Location

type Token

+ const BITWISE_AND

+ const BITWISE_OR

+ const BITWISE_XOR

+ const COMMENT

+ const MOD

Mar 8, 2017

Changes in this version

type DataType

+ func (d DataType) LessThan(other DataType) bool

+ type FieldMap int

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

+ type IteratorMap interface

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

+ type TagMap string

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

type TagSet

+ func (t *TagSet) Reverse()

Jan 24, 2017

Changes in this version

+ func FieldDimensions(sources Sources, m FieldMapper) (fields map[string]DataType, dimensions map[string]struct{}, err error)

+ func IsSelector(expr Expr) bool

type BooleanPoint

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

type DataType

+ func EvalType(expr Expr, sources Sources, typmap TypeMapper) DataType

+ type FieldMapper interface

+ FieldDimensions func(m *Measurement) (fields map[string]DataType, dimensions map[string]struct{}, err error)

type FloatPoint

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

type IntegerPoint

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

type Iterator

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

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

type IteratorOptions

+ GroupBy map[string]struct{}

+ MaxSeriesN int

+ Ordered bool

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

type QueryExecutor

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

type Result

+ Partial bool

type SelectStatement

+ func (s *SelectStatement) FieldExprByName(name string) (int, Expr)

+ func (s *SelectStatement) HasSelector() bool

+ func (s *SelectStatement) Reduce(valuer Valuer) *SelectStatement

+ func (s *SelectStatement) RewriteTimeCondition(now time.Time) error

type Sources

+ func (a Sources) Measurements() []*Measurement

type StringPoint

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

+ type SubQuery struct

+ Statement *SelectStatement

+ func (s *SubQuery) String() string

+ type TypeMapper interface

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

Apr 28, 2017

Changes in this version

type AlterRetentionPolicyStatement

+ func (s *AlterRetentionPolicyStatement) DefaultDatabase() string

type CreateRetentionPolicyStatement

+ func (s *CreateRetentionPolicyStatement) DefaultDatabase() string

type CreateSubscriptionStatement

+ func (s *CreateSubscriptionStatement) DefaultDatabase() string

type DeleteStatement

+ func (s *DeleteStatement) DefaultDatabase() string

type DropContinuousQueryStatement

+ func (s *DropContinuousQueryStatement) DefaultDatabase() string

type DropRetentionPolicyStatement

+ func (s *DropRetentionPolicyStatement) DefaultDatabase() string

type DropSubscriptionStatement

+ func (s *DropSubscriptionStatement) DefaultDatabase() string

type GrantStatement

+ func (s *GrantStatement) DefaultDatabase() string

type RevokeStatement

+ func (s *RevokeStatement) DefaultDatabase() string

type ShowFieldKeysStatement

+ func (s *ShowFieldKeysStatement) DefaultDatabase() string

type ShowMeasurementsStatement

+ func (s *ShowMeasurementsStatement) DefaultDatabase() string

type ShowRetentionPoliciesStatement

+ func (s *ShowRetentionPoliciesStatement) DefaultDatabase() string

type ShowSeriesStatement

+ func (s *ShowSeriesStatement) DefaultDatabase() string

type ShowTagKeysStatement

+ func (s *ShowTagKeysStatement) DefaultDatabase() string

type ShowTagValuesStatement

+ func (s *ShowTagValuesStatement) DefaultDatabase() string

Nov 11, 2016

Changes in this version

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

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

+ func ErrMaxConcurrentQueriesLimitExceeded(n, limit int) error

+ func ErrMaxSelectPointsLimitExceeded(n, limit int) error

+ type BooleanSampleReducer struct

+ func NewBooleanSampleReducer(size int) *BooleanSampleReducer

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

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

type ExecutionContext

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

type ExecutionOptions

+ AbortCh <-chan struct{}

type FillOption

+ const LinearFill

+ type FloatCumulativeSumReducer struct

+ func NewFloatCumulativeSumReducer() *FloatCumulativeSumReducer

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

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

+ type FloatSampleReducer struct

+ func NewFloatSampleReducer(size int) *FloatSampleReducer

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

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

+ type IntegerCumulativeSumReducer struct

+ func NewIntegerCumulativeSumReducer() *IntegerCumulativeSumReducer

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

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

+ type IntegerSampleReducer struct

+ func NewIntegerSampleReducer(size int) *IntegerSampleReducer

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

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

type Iterator

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

type QueryStatistics

+ ExecutedQueries int64

+ FinishedQueries int64

type SelectStatement

+ func (s *SelectStatement) RewriteRegexConditions()

type ShowFieldKeysStatement

+ Database string

type ShowMeasurementsStatement

+ Database string

type ShowSeriesStatement

+ Database string

type ShowTagKeysStatement

+ Database string

type ShowTagValuesStatement

+ Database string

+ type StringSampleReducer struct

+ func NewStringSampleReducer(size int) *StringSampleReducer

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

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

Sep 26, 2016

Changes in this version

type StringLiteral

+ func (l *StringLiteral) IsTimeLiteral() bool

+ func (l *StringLiteral) ToTimeLiteral() (*TimeLiteral, error)

Sep 7, 2016

Changes in this version

+ const AnyField

+ const Tag

+ var ErrInvalidTime = errors.New("invalid timestamp string")

type BooleanPoint

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

+ type ExecutionOptions struct

+ ChunkSize int

+ Database string

+ NodeID uint64

+ Quiet bool

+ ReadOnly bool

+ 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 FloatPoint

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

type IntegerPoint

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

type Iterator

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

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

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

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

type Iterators

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

type KillQueryStatement

+ Host string

+ type ListLiteral struct

+ Vals []string

+ func (s *ListLiteral) String() string

type Parser

+ func (p *Parser) SetParams(params map[string]interface{})

type QueryExecutor

+ TaskManager *TaskManager

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

+ type QueryInfo struct

+ Database string

+ Duration time.Duration

+ ID uint64

+ Query string

+ type QueryStatistics struct

+ ActiveQueries int64

+ QueryExecutionDuration int64

type SelectOptions

+ MaxSeriesN int

+ NodeID uint64

type SelectStatement

+ func (s *SelectStatement) RewriteFields(ic IteratorCreator) (*SelectStatement, error)

type ShowTagValuesStatement

+ Op Token

+ TagKeyExpr Literal

type Sources

+ func (a Sources) Filter(database, retentionPolicy string) []Source

+ type StatementNormalizer interface

+ NormalizeStatement func(stmt Statement, database string) error

type StringPoint

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

+ type TaskManager struct

+ LogQueriesAfter time.Duration

+ Logger *log.Logger

+ MaxConcurrentQueries int

+ QueryTimeout time.Duration

+ func NewTaskManager() *TaskManager

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

+ func (t *TaskManager) Close() error

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

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

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

type Token

+ const BOUNDPARAM

+ const DOUBLECOLON

type VarRef

+ Type DataType

+ type VarRefs []VarRef

+ func (a VarRefs) Len() int

+ func (a VarRefs) Less(i, j int) bool

+ func (a VarRefs) Strings() []string

+ func (a VarRefs) Swap(i, j int)

type Wildcard

+ Type Token

May 11, 2016

Changes in this version

+ const DefaultQueryTimeout

+ const WarningLevel

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

+ 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 Sanitize(query string) string

+ 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 DeleteSeriesStatement struct

+ Condition Expr

+ Sources Sources

+ func (s *DeleteSeriesStatement) String() string

+ func (s DeleteSeriesStatement) RequiredPrivileges() ExecutionPrivileges

+ type ExecutionContext struct

+ ChunkSize int

+ Database string

+ InterruptCh <-chan struct{}

+ Log *log.Logger

+ Query *QueryTask

+ QueryID uint64

+ ReadOnly bool

+ Results chan *Result

+ StatementID int

+ 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() *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 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() *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 IteratorOptions

+ func (opt IteratorOptions) ElapsedInterval() Interval

+ type Message struct

+ Level string

+ Text string

+ func ReadOnlyWarning(stmt string) *Message

type Points

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

type QueryExecutor

+ LogQueriesAfter time.Duration

+ Logger *log.Logger

+ MaxConcurrentQueries int

+ QueryTimeout time.Duration

+ StatementExecutor StatementExecutor

+ func NewQueryExecutor() *QueryExecutor

+ func (e *QueryExecutor) Close() error

+ func (e *QueryExecutor) SetLogOutput(w io.Writer)

+ type QueryTask struct

+ func (q *QueryTask) Error() error

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

type Result

+ Messages []*Message

type SelectStatement

+ TimeAlias string

+ func (s *SelectStatement) GroupByOffset(opt *IteratorOptions) (time.Duration, error)

+ func (s *SelectStatement) TimeFieldName() string

+ type StatementExecutor interface

+ ExecuteStatement func(stmt Statement, ctx *ExecutionContext) error

+ NormalizeStatement func(stmt Statement, database string) error

+ 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 TagSet

+ func (t *TagSet) Len() int

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

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

Apr 4, 2016

Changes in this version

+ const DefaultStatsInterval

+ var ErrMaxConcurrentQueriesReached = errors.New("max concurrent queries reached")

+ var ErrMaxPointsReached = errors.New("max number of points reached")

+ var ErrNoQueryManager = errors.New("no query manager available")

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

+ var ErrQueryManagerShutdown = errors.New("query manager shutdown")

+ var ErrQueryTimeoutReached = errors.New("query timeout reached")

+ func ExecuteShowQueriesStatement(qm QueryManager, q *ShowQueriesStatement) (models.Rows, error)

type AlterRetentionPolicyStatement

+ ShardGroupDuration *time.Duration

type BooleanPointDecoder

+ func (dec *BooleanPointDecoder) Stats() IteratorStats

type CreateDatabaseStatement

+ RetentionPolicyShardGroupDuration time.Duration

type CreateRetentionPolicyStatement

+ ShardGroupDuration time.Duration

+ type DropShardStatement struct

+ ID uint64

+ Meta bool

+ func (s *DropShardStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *DropShardStatement) String() string

+ type FloatMovingAverageReducer struct

+ func NewFloatMovingAverageReducer(n int) *FloatMovingAverageReducer

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

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

type FloatPoint

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

type FloatPointDecoder

+ func (dec *FloatPointDecoder) Stats() IteratorStats

+ type IntegerLiteral struct

+ Val int64

+ func (l *IntegerLiteral) String() string

+ type IntegerMovingAverageReducer struct

+ func NewIntegerMovingAverageReducer(n int) *IntegerMovingAverageReducer

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

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

type IntegerPoint

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

type IntegerPointDecoder

+ func (dec *IntegerPointDecoder) Stats() IteratorStats

type Iterator

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

+ Stats func() IteratorStats

type IteratorCreator

+ ExpandSources func(sources Sources) (Sources, error)

type IteratorCreators

+ func (a IteratorCreators) ExpandSources(sources Sources) (Sources, error)

type IteratorEncoder

+ StatsInterval time.Duration

type IteratorOptions

+ InterruptCh <-chan struct{}

+ type IteratorStats struct

+ PointN int

+ SeriesN int

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

type Iterators

+ func (a Iterators) Stats() IteratorStats

+ type KillQueryStatement struct

+ QueryID uint64

+ func (s *KillQueryStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *KillQueryStatement) String() string

type PointDecoder

+ func (dec *PointDecoder) Stats() IteratorStats

+ type QueryError struct

+ func (q *QueryError) Error() error

+ type QueryManager interface

+ AttachQuery func(params *QueryParams) (qid uint64, closing <-chan struct{}, err error)

+ Close func() error

+ KillQuery func(qid uint64) error

+ MonitorQuery func(qid uint64, fn QueryMonitorFunc) error

+ Queries func() []QueryTaskInfo

+ func DefaultQueryManager(maxQueries int) QueryManager

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

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

+ type QueryParams struct

+ Database string

+ Error *QueryError

+ InterruptCh <-chan struct{}

+ Query *Query

+ Timeout time.Duration

+ type QueryTaskInfo struct

+ Database string

+ Duration time.Duration

+ ID uint64

+ Query string

type SelectOptions

+ InterruptCh <-chan struct{}

+ type ShowQueriesStatement struct

+ func (s *ShowQueriesStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *ShowQueriesStatement) String() string

type Sources

+ func (a Sources) HasRegex() bool

type StringPointDecoder

+ func (dec *StringPointDecoder) Stats() IteratorStats

type Token

+ const INTEGER

+ const KILL

Mar 22, 2016

Changes in this version

+ const MaxTime

+ const MinTime

+ const ZeroTime

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

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

+ 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 BinaryExprName(expr *BinaryExpr) string

+ 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 ContainsVarRef(expr Expr) bool

+ func ErrDatabaseNotFound(name string) error

+ func ErrMeasurementNotFound(name string) error

+ func ExprNames(expr Expr) []string

+ 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 IsSystemName(name string) bool

+ 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{})

+ type AuxIterator interface

+ Background func()

+ Iterator func(name string) Iterator

+ Start func()

+ func NewAuxIterator(input Iterator, seriesKeys SeriesList, opt IteratorOptions) AuxIterator

+ type BooleanBulkPointAggregator interface

+ AggregateBooleanBulk func(points []BooleanPoint)

+ type BooleanFuncFloatReducer struct

+ func NewBooleanFuncFloatReducer(fn BooleanReduceFloatFunc) *BooleanFuncFloatReducer

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

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

+ type BooleanFuncIntegerReducer struct

+ func NewBooleanFuncIntegerReducer(fn BooleanReduceIntegerFunc) *BooleanFuncIntegerReducer

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

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

+ type BooleanFuncReducer struct

+ func NewBooleanFuncReducer(fn BooleanReduceFunc) *BooleanFuncReducer

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

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

+ type BooleanFuncStringReducer struct

+ func NewBooleanFuncStringReducer(fn BooleanReduceStringFunc) *BooleanFuncStringReducer

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

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

+ type BooleanIterator interface

+ Next func() *BooleanPoint

+ type BooleanPoint struct

+ Aggregated uint32

+ Aux []interface{}

+ Name string

+ Nil bool

+ Tags Tags

+ Time int64

+ Value bool

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

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

+ type BooleanPointAggregator interface

+ AggregateBoolean func(p *BooleanPoint)

+ type BooleanPointDecoder struct

+ func NewBooleanPointDecoder(r io.Reader) *BooleanPointDecoder

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

+ 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 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 DataType

+ func InspectDataTypes(a []interface{}) []DataType

+ type Emitter struct

+ Columns []string

+ OmitTime bool

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

+ func (e *Emitter) Close() error

+ func (e *Emitter) Emit() *models.Row

type Expr

+ func MustParseExpr(s string) Expr

+ func RewriteExpr(expr Expr, fn func(Expr) Expr) Expr

+ type FloatBulkPointAggregator interface

+ AggregateFloatBulk func(points []FloatPoint)

+ type FloatFuncBooleanReducer struct

+ func NewFloatFuncBooleanReducer(fn FloatReduceBooleanFunc) *FloatFuncBooleanReducer

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

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

+ type FloatFuncIntegerReducer struct

+ func NewFloatFuncIntegerReducer(fn FloatReduceIntegerFunc) *FloatFuncIntegerReducer

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

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

+ type FloatFuncReducer struct

+ func NewFloatFuncReducer(fn FloatReduceFunc) *FloatFuncReducer

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

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

+ type FloatFuncStringReducer struct

+ func NewFloatFuncStringReducer(fn FloatReduceStringFunc) *FloatFuncStringReducer

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

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

+ type FloatIterator interface

+ Next func() *FloatPoint

+ type FloatMeanReducer struct

+ func NewFloatMeanReducer() *FloatMeanReducer

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

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

+ type FloatPoint struct

+ Aggregated uint32

+ Aux []interface{}

+ Name string

+ Nil bool

+ Tags Tags

+ Time int64

+ Value float64

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

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

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

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

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

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

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

+ type FloatPointAggregator interface

+ AggregateFloat func(p *FloatPoint)

+ type FloatPointDecoder struct

+ func NewFloatPointDecoder(r io.Reader) *FloatPointDecoder

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

+ 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 NewFloatBottomReduceSliceFunc(n int, tags []int, interval Interval) FloatReduceSliceFunc

+ func NewFloatDerivativeReduceSliceFunc(interval Interval, isNonNegative bool) FloatReduceSliceFunc

+ func NewFloatPercentileReduceSliceFunc(percentile float64) FloatReduceSliceFunc

+ func NewFloatTopReduceSliceFunc(n int, tags []int, interval Interval) FloatReduceSliceFunc

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

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

+ 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 IntegerBulkPointAggregator interface

+ AggregateIntegerBulk func(points []IntegerPoint)

+ type IntegerFuncBooleanReducer struct

+ func NewIntegerFuncBooleanReducer(fn IntegerReduceBooleanFunc) *IntegerFuncBooleanReducer

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

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

+ type IntegerFuncFloatReducer struct

+ func NewIntegerFuncFloatReducer(fn IntegerReduceFloatFunc) *IntegerFuncFloatReducer

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

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

+ type IntegerFuncReducer struct

+ func NewIntegerFuncReducer(fn IntegerReduceFunc) *IntegerFuncReducer

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

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

+ type IntegerFuncStringReducer struct

+ func NewIntegerFuncStringReducer(fn IntegerReduceStringFunc) *IntegerFuncStringReducer

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

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

+ type IntegerIterator interface

+ Next func() *IntegerPoint

+ type IntegerMeanReducer struct

+ func NewIntegerMeanReducer() *IntegerMeanReducer

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

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

+ type IntegerPoint struct

+ Aggregated uint32

+ Aux []interface{}

+ Name string

+ Nil bool

+ Tags Tags

+ Time int64

+ Value int64

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

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

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

+ type IntegerPointAggregator interface

+ AggregateInteger func(p *IntegerPoint)

+ type IntegerPointDecoder struct

+ func NewIntegerPointDecoder(r io.Reader) *IntegerPointDecoder

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

+ 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

+ func NewIntegerDerivativeReduceSliceFunc(interval Interval, isNonNegative bool) IntegerReduceFloatSliceFunc

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

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

+ func NewIntegerBottomReduceSliceFunc(n int, tags []int, interval Interval) IntegerReduceSliceFunc

+ func NewIntegerPercentileReduceSliceFunc(percentile float64) IntegerReduceSliceFunc

+ func NewIntegerTopReduceSliceFunc(n int, tags []int, interval Interval) IntegerReduceSliceFunc

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

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

+ 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 Interval struct

+ Duration time.Duration

+ Offset time.Duration

+ func (i Interval) IsZero() bool

type Iterator

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

+ func NewDedupeIterator(input Iterator) Iterator

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

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

+ func NewIntervalIterator(input Iterator, opt IteratorOptions) Iterator

+ func NewLimitIterator(input Iterator, opt IteratorOptions) Iterator

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

+ func NewReaderIterator(r io.Reader) (Iterator, error)

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

+ func Select(stmt *SelectStatement, ic IteratorCreator, sopt *SelectOptions) ([]Iterator, error)

+ Close func() error

+ type IteratorCreator interface

+ CreateIterator func(opt IteratorOptions) (Iterator, error)

+ FieldDimensions func(sources Sources) (fields, dimensions map[string]struct{}, err error)

+ SeriesKeys func(opt IteratorOptions) (SeriesList, error)

+ type IteratorCreators []IteratorCreator

+ func (a IteratorCreators) Close() error

+ func (a IteratorCreators) CreateIterator(opt IteratorOptions) (Iterator, error)

+ func (a IteratorCreators) FieldDimensions(sources Sources) (fields, dimensions map[string]struct{}, err error)

+ func (a IteratorCreators) SeriesKeys(opt IteratorOptions) (SeriesList, error)

+ type IteratorEncoder struct

+ func NewIteratorEncoder(w io.Writer) *IteratorEncoder

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

+ type IteratorOptions struct

+ Ascending bool

+ Aux []string

+ Condition Expr

+ Dedupe bool

+ Dimensions []string

+ EndTime int64

+ Expr Expr

+ Fill FillOption

+ FillValue interface{}

+ Interval Interval

+ Limit int

+ Offset int

+ SLimit int

+ SOffset int

+ Sources []Source

+ StartTime int64

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

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

+ func (opt IteratorOptions) DerivativeInterval() Interval

+ func (opt IteratorOptions) MergeSorted() bool

+ func (opt IteratorOptions) SeekTime() int64

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

+ type Iterators []Iterator

+ func (a Iterators) Close() error

+ type Literal interface

+ type Point interface

+ type PointDecoder struct

+ func NewPointDecoder(r io.Reader) *PointDecoder

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

+ type Points []Point

+ type QueryExecutor interface

+ ExecuteQuery func(query *Query, database string, chunkSize int, closing chan struct{}) <-chan *Result

+ type SelectOptions struct

+ MaxTime time.Time

+ MinTime time.Time

type SelectStatement

+ Dedupe bool

+ OmitTime bool

+ func (s *SelectStatement) RewriteTimeFields()

+ type Series struct

+ Aux []DataType

+ Name string

+ Tags Tags

+ func (s *Series) Combine(other *Series)

+ func (s *Series) ID() string

+ type SeriesList []Series

+ func (a *SeriesList) UnmarshalBinary(buf []byte) error

+ func (a SeriesList) Len() int

+ func (a SeriesList) Less(i, j int) bool

+ func (a SeriesList) MarshalBinary() ([]byte, error)

+ func (a SeriesList) Swap(i, j int)

type Sources

+ func (a *Sources) UnmarshalBinary(buf []byte) error

+ func (a Sources) HasSystemSource() bool

+ func (a Sources) MarshalBinary() ([]byte, error)

+ func (a Sources) Names() []string

type Statement

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

+ type StringBulkPointAggregator interface

+ AggregateStringBulk func(points []StringPoint)

+ type StringFuncBooleanReducer struct

+ func NewStringFuncBooleanReducer(fn StringReduceBooleanFunc) *StringFuncBooleanReducer

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

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

+ type StringFuncFloatReducer struct

+ func NewStringFuncFloatReducer(fn StringReduceFloatFunc) *StringFuncFloatReducer

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

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

+ type StringFuncIntegerReducer struct

+ func NewStringFuncIntegerReducer(fn StringReduceIntegerFunc) *StringFuncIntegerReducer

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

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

+ type StringFuncReducer struct

+ func NewStringFuncReducer(fn StringReduceFunc) *StringFuncReducer

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

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

+ type StringIterator interface

+ Next func() *StringPoint

+ type StringPoint struct

+ Aggregated uint32

+ Aux []interface{}

+ Name string

+ Nil bool

+ Tags Tags

+ Time int64

+ Value string

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

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

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

+ type StringPointAggregator interface

+ AggregateString func(p *StringPoint)

+ type StringPointDecoder struct

+ func NewStringPointDecoder(r io.Reader) *StringPointDecoder

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

+ 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 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 TagSet

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

+ 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) ID() string

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

type Token

+ const DURATIONVAL

Feb 4, 2016

Changes in this version

type CreateContinuousQueryStatement

+ ResampleEvery time.Duration

+ ResampleFor time.Duration

type DropServerStatement

+ Meta bool

type Token

+ const DATA

+ const EVERY

+ const META

+ const RESAMPLE

Dec 8, 2015

Changes in this version

type CreateDatabaseStatement

+ RetentionPolicyCreate bool

+ RetentionPolicyDuration time.Duration

+ RetentionPolicyName string

+ RetentionPolicyReplication int

type SelectStatement

+ func (s *SelectStatement) HasSimpleCount() bool

+ type ShowShardGroupsStatement struct

+ func (s *ShowShardGroupsStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *ShowShardGroupsStatement) String() string

type Token

+ const GROUPS

+ const NAME

+ const SHARD

Nov 17, 2015

Changes in this version

+ func EvalBool(expr Expr, m map[string]interface{}) bool

+ func HasTimeExpr(expr Expr) bool

+ func OnlyTimeExpr(expr Expr) bool

+ type CreateSubscriptionStatement struct

+ Database string

+ Destinations []string

+ Mode string

+ Name string

+ RetentionPolicy string

+ func (s *CreateSubscriptionStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *CreateSubscriptionStatement) String() string

type DropDatabaseStatement

+ IfExists bool

+ type DropServerStatement struct

+ Force bool

+ NodeID uint64

+ func (s *DropServerStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *DropServerStatement) String() string

+ type DropSubscriptionStatement struct

+ Database string

+ Name string

+ RetentionPolicy string

+ func (s *DropSubscriptionStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *DropSubscriptionStatement) String() string

type SelectStatement

+ func (s *SelectStatement) FunctionCallsByPosition() [][]*Call

+ func (s *SelectStatement) LimitTagSets(a []*TagSet) []*TagSet

+ func (s *SelectStatement) SourceNames() []string

+ func (s *SelectStatement) TimeAscending() bool

type ShowDiagnosticsStatement

+ Module string

type ShowMeasurementsStatement

+ Source Source

type ShowStatsStatement

+ Module string

+ type ShowSubscriptionsStatement struct

+ func (s *ShowSubscriptionsStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *ShowSubscriptionsStatement) String() string

type ShowTagKeysStatement

+ SLimit int

+ SOffset int

type Token

+ const ANY

+ const DESTINATIONS

+ const FORCE

+ const SERVER

+ const SUBSCRIPTION

+ const SUBSCRIPTIONS

Sep 14, 2015

Changes in this version

+ func MapTop(itr Iterator, c *Call) interface

+ func ReduceTop(values []interface{}, c *Call) interface

type Call

+ func (c *Call) Fields() []string

type CreateDatabaseStatement

+ IfNotExists bool

type Iterator

+ TMin func() int64

+ Tags func() map[string]string

type Measurement

+ IsTarget bool

+ type PositionPoint struct

+ Tags map[string]string

+ Time int64

+ Value interface{}

+ type PositionPoints []PositionPoint

type SelectStatement

+ func (s *SelectStatement) ColumnNames() []string

+ func (s *SelectStatement) HasTimeFieldSpecified() bool

+ type ShowShardsStatement struct

+ func (s *ShowShardsStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *ShowShardsStatement) String() string

type Token

+ const COLON

+ const NOT

+ const SHARDS

Aug 26, 2015

Changes in this version

type Fields

+ func (a Fields) AliasNames() []string

+ func (a Fields) Names() []string

type Row

+ func (r *Row) SameSeries(o *Row) bool

type SelectStatement

+ func (s *SelectStatement) HasDimensionWildcard() bool

+ func (s *SelectStatement) HasFieldWildcard() bool

+ func (s *SelectStatement) NamesInDimension() []string

Jul 24, 2015

Changes in this version

+ func TimeRangeAsEpochNano(expr Expr) (min, max int64)

type CreateUserStatement

+ Admin bool

type ExecutionPrivilege

+ Admin bool

+ type GrantAdminStatement struct

+ User string

+ func (s *GrantAdminStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *GrantAdminStatement) String() string

+ type Processor func(values []interface{}) interface

+ func GetProcessor(expr Expr, startIndex int) (Processor, int)

+ type RevokeAdminStatement struct

+ User string

+ func (s *RevokeAdminStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *RevokeAdminStatement) String() string

Jul 2, 2015

Changes in this version

type DataType

+ func (d DataType) String() string

+ type ShowGrantsForUserStatement struct

+ Name string

+ func (s *ShowGrantsForUserStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *ShowGrantsForUserStatement) String() string

type Token

+ const GRANTS

Jun 11, 2015

Changes in this version

+ const Boolean

+ const DateFormat

+ const DateTimeFormat

+ const Duration

+ const Float

+ const IgnoredChunkSize

+ const Integer

+ const MaxGroupByPoints

+ const SelectColumnCountWithOneValue

+ const String

+ const Time

+ const Unknown

+ var ErrInvalidDuration = errors.New("invalid duration")

+ func Eval(expr Expr, m map[string]interface{}) interface

+ func FormatDuration(d time.Duration) string

+ func IdentNeedsQuotes(ident string) bool

+ func IsNumeric(c *Call) bool

+ func IsRegexOp(t Token) bool

+ func MapCount(itr Iterator) interface

+ func MapCountDistinct(itr Iterator) interface

+ func MapDistinct(itr Iterator) interface

+ func MapEcho(itr Iterator) interface

+ func MapFirst(itr Iterator) interface

+ func MapLast(itr Iterator) interface

+ func MapMax(itr Iterator) interface

+ func MapMean(itr Iterator) interface

+ func MapMin(itr Iterator) interface

+ func MapRawQuery(itr Iterator) interface

+ func MapSpread(itr Iterator) interface

+ func MapStddev(itr Iterator) interface

+ func MapSum(itr Iterator) interface

+ func MatchSource(sources Sources, name string) string

+ func ParseDuration(s string) (time.Duration, error)

+ func QuoteIdent(segments ...string) string

+ func QuoteString(s string) string

+ func ReduceCountDistinct(values []interface{}) interface

+ func ReduceDistinct(values []interface{}) interface

+ func ReduceFirst(values []interface{}) interface

+ func ReduceLast(values []interface{}) interface

+ func ReduceMax(values []interface{}) interface

+ func ReduceMean(values []interface{}) interface

+ func ReduceMedian(values []interface{}) interface

+ func ReduceMin(values []interface{}) interface

+ func ReduceSpread(values []interface{}) interface

+ func ReduceStddev(values []interface{}) interface

+ func ReduceSum(values []interface{}) interface

+ func ScanBareIdent(r io.RuneScanner) string

+ func ScanDelimited(r io.RuneScanner, start, end rune, escapes map[rune]rune, escapesPassThru bool) ([]byte, error)

+ func ScanString(r io.RuneScanner) (string, error)

+ func TimeRange(expr Expr) (min, max time.Time)

+ func Walk(v Visitor, node Node)

+ func WalkFunc(node Node, fn func(Node))

+ type AlterRetentionPolicyStatement struct

+ Database string

+ Default bool

+ Duration *time.Duration

+ Name string

+ Replication *int

+ func (s *AlterRetentionPolicyStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *AlterRetentionPolicyStatement) String() string

+ type BinaryExpr struct

+ LHS Expr

+ Op Token

+ RHS Expr

+ func (e *BinaryExpr) String() string

+ type BooleanLiteral struct

+ Val bool

+ func (l *BooleanLiteral) String() string

+ type Call struct

+ Args []Expr

+ Name string

+ func (c *Call) String() string

+ type CreateContinuousQueryStatement struct

+ Database string

+ Name string

+ Source *SelectStatement

+ func (s *CreateContinuousQueryStatement) DefaultDatabase() string

+ func (s *CreateContinuousQueryStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *CreateContinuousQueryStatement) String() string

+ type CreateDatabaseStatement struct

+ Name string

+ func (s *CreateDatabaseStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *CreateDatabaseStatement) String() string

+ type CreateRetentionPolicyStatement struct

+ Database string

+ Default bool

+ Duration time.Duration

+ Name string

+ Replication int

+ func (s *CreateRetentionPolicyStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *CreateRetentionPolicyStatement) String() string

+ type CreateUserStatement struct

+ Name string

+ Password string

+ Privilege *Privilege

+ func (s *CreateUserStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *CreateUserStatement) String() string

+ type DB interface

+ Begin func() (Tx, error)

+ type DataType int

+ func InspectDataType(v interface{}) DataType

+ type DeleteStatement struct

+ Condition Expr

+ Source Source

+ func (s *DeleteStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *DeleteStatement) String() string

+ type Dimension struct

+ Expr Expr

+ func (d *Dimension) String() string

+ type Dimensions []*Dimension

+ func (a Dimensions) Normalize() (time.Duration, []string, error)

+ func (a Dimensions) String() string

+ type Distinct struct

+ Val string

+ func (d *Distinct) NewCall() *Call

+ func (d *Distinct) String() string

+ type DropContinuousQueryStatement struct

+ Database string

+ Name string

+ func (s *DropContinuousQueryStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *DropContinuousQueryStatement) String() string

+ type DropDatabaseStatement struct

+ Name string

+ func (s *DropDatabaseStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *DropDatabaseStatement) String() string

+ type DropMeasurementStatement struct

+ Name string

+ func (s *DropMeasurementStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *DropMeasurementStatement) String() string

+ type DropRetentionPolicyStatement struct

+ Database string

+ Name string

+ func (s *DropRetentionPolicyStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *DropRetentionPolicyStatement) String() string

+ type DropSeriesStatement struct

+ Condition Expr

+ Sources Sources

+ func (s *DropSeriesStatement) String() string

+ func (s DropSeriesStatement) RequiredPrivileges() ExecutionPrivileges

+ type DropUserStatement struct

+ Name string

+ func (s *DropUserStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *DropUserStatement) String() string

+ type DurationLiteral struct

+ Val time.Duration

+ func (l *DurationLiteral) String() string

+ type ExecutionPrivilege struct

+ Name string

+ Privilege Privilege

+ type ExecutionPrivileges []ExecutionPrivilege

+ type Executor struct

+ func (e *Executor) Execute() <-chan *Row

+ type Expr interface

+ func CloneExpr(expr Expr) Expr

+ func ParseExpr(s string) (Expr, error)

+ func Reduce(expr Expr, valuer Valuer) Expr

+ type Field struct

+ Alias string

+ Expr Expr

+ func (f *Field) Name() string

+ func (f *Field) String() string

+ type Fields []*Field

+ func (a Fields) String() string

+ func (f Fields) Len() int

+ func (f Fields) Less(i, j int) bool

+ func (f Fields) Swap(i, j int)

+ type FillOption int

+ const NoFill

+ const NullFill

+ const NumberFill

+ const PreviousFill

+ type GrantStatement struct

+ On string

+ Privilege Privilege

+ User string

+ func (s *GrantStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *GrantStatement) String() string

+ type HasDefaultDatabase interface

+ DefaultDatabase func() string

+ type Iterator interface

+ Next func() (seriesKey string, time int64, value interface{})

+ type MapFunc func(Iterator) interface

+ func InitializeMapFunc(c *Call) (MapFunc, error)

+ type MapReduceJob struct

+ Mappers []Mapper

+ MeasurementName string

+ TMax int64

+ TMin int64

+ TagSet *TagSet

+ func (m *MapReduceJob) Close()

+ func (m *MapReduceJob) Execute(out chan *Row, filterEmptyResults bool)

+ func (m *MapReduceJob) Key() []byte

+ func (m *MapReduceJob) Open() error

+ type MapReduceJobs []*MapReduceJob

+ func (a MapReduceJobs) Len() int

+ func (a MapReduceJobs) Less(i, j int) bool

+ func (a MapReduceJobs) Swap(i, j int)

+ type Mapper interface

+ Begin func(aggregate *Call, startingTime int64, limit int) error

+ Close func()

+ NextInterval func() (interface{}, error)

+ Open func() error

+ type Measurement struct

+ Database string

+ Name string

+ Regex *RegexLiteral

+ RetentionPolicy string

+ func (m *Measurement) String() string

+ type Measurements []*Measurement

+ func (a Measurements) String() string

+ type Node interface

+ String func() string

+ func Rewrite(r Rewriter, node Node) Node

+ func RewriteFunc(node Node, fn func(Node) Node) Node

+ type NowValuer struct

+ Now time.Time

+ func (v *NowValuer) Value(key string) (interface{}, bool)

+ type NumberLiteral struct

+ Val float64

+ func (l *NumberLiteral) String() string

+ type NumberType int8

+ const Float64Type

+ const Int64Type

+ type ParenExpr struct

+ Expr Expr

+ func (e *ParenExpr) String() string

+ type ParseError struct

+ Expected []string

+ Found string

+ Message string

+ Pos Pos

+ func (e *ParseError) Error() string

+ type Parser struct

+ func NewParser(r io.Reader) *Parser

+ func (p *Parser) ParseExpr() (Expr, error)

+ func (p *Parser) ParseQuery() (*Query, error)

+ func (p *Parser) ParseStatement() (Statement, error)

+ type Planner struct

+ DB DB

+ Now func() time.Time

+ func NewPlanner(db DB) *Planner

+ func (p *Planner) Plan(stmt *SelectStatement, chunkSize int) (*Executor, error)

+ type Pos struct

+ Char int

+ Line int

+ type Privilege int

+ const AllPrivileges

+ const NoPrivileges

+ const ReadPrivilege

+ const WritePrivilege

+ func NewPrivilege(p Privilege) *Privilege

+ func (p Privilege) String() string

+ type Query struct

+ Statements Statements

+ func ParseQuery(s string) (*Query, error)

+ func (q *Query) String() string

+ type ReduceFunc func([]interface{}) interface

+ func InitializeReduceFunc(c *Call) (ReduceFunc, error)

+ func ReducePercentile(percentile float64) ReduceFunc

+ type RegexLiteral struct

+ Val *regexp.Regexp

+ func CloneRegexLiteral(r *RegexLiteral) *RegexLiteral

+ func (r *RegexLiteral) String() string

+ type Result struct

+ Err error

+ Series Rows

+ StatementID int

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

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

+ type RevokeStatement struct

+ On string

+ Privilege Privilege

+ User string

+ func (s *RevokeStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *RevokeStatement) String() string

+ type Rewriter interface

+ Rewrite func(Node) Node

+ type Row struct

+ Columns []string

+ Err error

+ Name string

+ Tags map[string]string

+ Values [][]interface{}

+ type Rows []*Row

+ func (p Rows) Len() int

+ func (p Rows) Less(i, j int) bool

+ func (p Rows) Swap(i, j int)

+ type Scanner struct

+ func NewScanner(r io.Reader) *Scanner

+ func (s *Scanner) Scan() (tok Token, pos Pos, lit string)

+ func (s *Scanner) ScanRegex() (tok Token, pos Pos, lit string)

+ type SelectStatement struct

+ Condition Expr

+ Dimensions Dimensions

+ Fields Fields

+ Fill FillOption

+ FillValue interface{}

+ IsRawQuery bool

+ Limit int

+ Offset int

+ SLimit int

+ SOffset int

+ SortFields SortFields

+ Sources Sources

+ Target *Target

+ func (s *SelectStatement) Clone() *SelectStatement

+ func (s *SelectStatement) FunctionCalls() []*Call

+ func (s *SelectStatement) GroupByInterval() (time.Duration, error)

+ func (s *SelectStatement) HasCountDistinct() bool

+ func (s *SelectStatement) HasDerivative() bool

+ func (s *SelectStatement) HasDistinct() bool

+ func (s *SelectStatement) HasWildcard() bool

+ func (s *SelectStatement) IsSimpleDerivative() bool

+ func (s *SelectStatement) NamesInSelect() []string

+ func (s *SelectStatement) NamesInWhere() []string

+ func (s *SelectStatement) OnlyTimeDimensions() bool

+ func (s *SelectStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *SelectStatement) RewriteDistinct()

+ func (s *SelectStatement) RewriteWildcards(fields Fields, dimensions Dimensions) *SelectStatement

+ func (s *SelectStatement) SetTimeRange(start, end time.Time) error

+ func (s *SelectStatement) String() string

+ func (s *SelectStatement) Substatement(ref *VarRef) (*SelectStatement, error)

+ type SetPasswordUserStatement struct

+ Name string

+ Password string

+ func (s *SetPasswordUserStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *SetPasswordUserStatement) String() string

+ type ShowContinuousQueriesStatement struct

+ func (s *ShowContinuousQueriesStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *ShowContinuousQueriesStatement) String() string

+ type ShowDatabasesStatement struct

+ func (s *ShowDatabasesStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *ShowDatabasesStatement) String() string

+ type ShowDiagnosticsStatement struct

+ func (s *ShowDiagnosticsStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *ShowDiagnosticsStatement) String() string

+ type ShowFieldKeysStatement struct

+ Limit int

+ Offset int

+ SortFields SortFields

+ Sources Sources

+ func (s *ShowFieldKeysStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *ShowFieldKeysStatement) String() string

+ type ShowMeasurementsStatement struct

+ Condition Expr

+ Limit int

+ Offset int

+ SortFields SortFields

+ func (s *ShowMeasurementsStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *ShowMeasurementsStatement) String() string

+ type ShowRetentionPoliciesStatement struct

+ Database string

+ func (s *ShowRetentionPoliciesStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *ShowRetentionPoliciesStatement) String() string

+ type ShowSeriesStatement struct

+ Condition Expr

+ Limit int

+ Offset int

+ SortFields SortFields

+ Sources Sources

+ func (s *ShowSeriesStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *ShowSeriesStatement) String() string

+ type ShowServersStatement struct

+ func (s *ShowServersStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *ShowServersStatement) String() string

+ type ShowStatsStatement struct

+ Host string

+ func (s *ShowStatsStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *ShowStatsStatement) String() string

+ type ShowTagKeysStatement struct

+ Condition Expr

+ Limit int

+ Offset int

+ SortFields SortFields

+ Sources Sources

+ func (s *ShowTagKeysStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *ShowTagKeysStatement) String() string

+ type ShowTagValuesStatement struct

+ Condition Expr

+ Limit int

+ Offset int

+ SortFields SortFields

+ Sources Sources

+ TagKeys []string

+ func (s *ShowTagValuesStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *ShowTagValuesStatement) String() string

+ type ShowUsersStatement struct

+ func (s *ShowUsersStatement) RequiredPrivileges() ExecutionPrivileges

+ func (s *ShowUsersStatement) String() string

+ type SortField struct

+ Ascending bool

+ Name string

+ func (field *SortField) String() string

+ type SortFields []*SortField

+ func (a SortFields) String() string

+ type Source interface

+ type Sources []Source

+ func (a Sources) String() string

+ type Statement interface

+ RequiredPrivileges func() ExecutionPrivileges

+ func MustParseStatement(s string) Statement

+ func ParseStatement(s string) (Statement, error)

+ type Statements []Statement

+ func (a Statements) String() string

+ type StringLiteral struct

+ Val string

+ func (l *StringLiteral) String() string

+ type TagSet struct

+ Filters []Expr

+ Key []byte

+ SeriesKeys []string

+ Tags map[string]string

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

+ type Target struct

+ Measurement *Measurement

+ func (t *Target) String() string

+ type TimeLiteral struct

+ Val time.Time

+ func (l *TimeLiteral) String() string

+ type Token int

+ const ADD

+ const ALL

+ const ALTER

+ const AND

+ const AS

+ const ASC

+ const BADESCAPE

+ const BADREGEX

+ const BADSTRING

+ const BEGIN

+ const BY

+ const COMMA

+ const CONTINUOUS

+ const CREATE

+ const DATABASE

+ const DATABASES

+ const DEFAULT

+ const DELETE

+ const DESC

+ const DIAGNOSTICS

+ const DISTINCT

+ const DIV

+ const DOT

+ const DROP

+ const DURATION

+ const DURATION_VAL

+ const END

+ const EOF

+ const EQ

+ const EQREGEX

+ const EXISTS

+ const EXPLAIN

+ const FALSE

+ const FIELD

+ const FOR

+ const FROM

+ const GRANT

+ const GROUP

+ const GT

+ const GTE

+ const IDENT

+ const IF

+ const ILLEGAL

+ const IN

+ const INF

+ const INNER

+ const INSERT

+ const INTO

+ const KEY

+ const KEYS

+ const LIMIT

+ const LPAREN

+ const LT

+ const LTE

+ const MEASUREMENT

+ const MEASUREMENTS

+ const MUL

+ const NEQ

+ const NEQREGEX

+ const NUMBER

+ const OFFSET

+ const ON

+ const OR

+ const ORDER

+ const PASSWORD

+ const POLICIES

+ const POLICY

+ const PRIVILEGES

+ const QUERIES

+ const QUERY

+ const READ

+ const REGEX

+ const REPLICATION

+ const RETENTION

+ const REVOKE

+ const RPAREN

+ const SELECT

+ const SEMICOLON

+ const SERIES

+ const SERVERS

+ const SET

+ const SHOW

+ const SLIMIT

+ const SOFFSET

+ const STATS

+ const STRING

+ const SUB

+ const TAG

+ const TO

+ const TRUE

+ const USER

+ const USERS

+ const VALUES

+ const WHERE

+ const WITH

+ const WRITE

+ const WS

+ func Lookup(ident string) Token

+ func (tok Token) Precedence() int

+ func (tok Token) String() string

+ type Tx interface

+ CreateMapReduceJobs func(stmt *SelectStatement, tagKeys []string) ([]*MapReduceJob, error)

+ type UnmarshalFunc func([]byte) (interface{}, error)

+ func InitializeUnmarshaller(c *Call) (UnmarshalFunc, error)

+ type Valuer interface

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

+ type VarRef struct

+ Val string

+ func (r *VarRef) String() string

+ type Visitor interface

+ Visit func(Node) Visitor

+ type Wildcard struct

+ func (e *Wildcard) String() string