executor

package

Go to main page

Versions in this module

v1

v1.5.3-rc4

Jan 15, 2026

v1.5.2

Jan 9, 2026

v1.5.1

Dec 24, 2025

v1.5.0

Nov 27, 2025

Changes in this version

+ const ALARM

+ const ANOMALY

+ const AbsoluteThreshold

+ const Algo

+ const AlgoType

+ const Annotations

+ const CTETransformName

+ const Conf

+ const CoreEntity

+ const CreatedTS

+ const EVENT

+ const EndTS

+ const EntityID

+ const GetTopoUidFuncName

+ const HashJoinTransformName

+ const ID

+ const InTransformName

+ const IncomeOp

+ const Kind

+ const LLMFuncPrefix

+ const LeftSide

+ const Level

+ const META

+ const NOT_READY

+ const Name

+ const NilMarkByte

+ const OutGoOp

+ const Q1Percentile

+ const Q3Percentile

+ const READY

+ const RUNNING

+ const RcaFuncName

+ const RightSide

+ const RowSizeBytes

+ const RuleID

+ const SlopeThreshold

+ const SortMergeJoinTransformName

+ const StartTS

+ const TimeSuffix

+ const Timestamps

+ const TrendScore

+ const TrimPercent

+ const TupleSizeBytes

+ const Type

+ const Uid

+ const WeightIQRCenter

+ const WeightMedian

+ const WeightTrimMean

+ var CTEBuf = NewDataCacheCenter()

+ var LLMFactoryInstance = map[string]LLMFunc

+ var NagtPool *pool.UnionPool[TTopnCM05Optimized]

+ var RegisterTable sync.Map

+ func ADDiffAbsReduce[T util.NumberOnly](si *SliceItem[T]) (int, int64, float64, bool)

+ func ADRMseExtReduce[T util.NumberOnly](si *SliceItem[T]) (int, int64, float64, bool)

+ func ADSlopeScoreReduce[T util.NumberOnly](si *SliceItem[T]) (int, int64, float64, bool)

+ func AppendBooleanValue(outColumn Column, value *ValueKeeper)

+ func AppendFloatValue(outColumn Column, value *ValueKeeper)

+ func AppendIntegerValue(outColumn Column, value *ValueKeeper)

+ func AppendStringValue(outColumn Column, value *ValueKeeper)

+ func AuxTagKeyHandler(auxTagIdx int, tags *influx.PointTags, rec *record.Record, start, end int)

+ func BuildCTELogicalPlan(ctx context.Context, outerSchema *QuerySchema, cte *influxql.CTE) (hybridqp.QueryNode, error)

+ func BuildJoinQueryPlan(ctx context.Context, qc query.LogicalPlanCreator, ...) (hybridqp.QueryNode, error)

+ func BuildNodeExchange(ctx context.Context, builder LogicalPlanBuilder, queryPlan hybridqp.QueryNode) error

+ func ChunkToLastRowCache(chunk Chunk, schema hybridqp.Catalog) *lastrowcache.CacheValue

+ func ColumnMapping(chunk Chunk, colMap map[influxql.Expr]influxql.VarRef)

+ func ConvertToLabels(pts *influx.PointTags, dst []byte) []byte

+ func CopyCastorADArrowRecordToChunk(r arrow.Record, c Chunk, fields map[string]struct{}) error

+ func DummyPipelineExecutorWithQuerySchema(s query.PreparedStatement) (hybridqp.Executor, error)

+ func ExprHasCall(expr influxql.Expr) bool

+ func FilterPushDown(opt *query.ProcessorOptions, schema *QuerySchema)

+ func GetAlignValue[T util.BasicType](in Column, values []T, start int, end int) (T, bool)

+ func HandleStandardAgg(node *LogicalHashAgg)

+ func HandleUnifyPlanAgg(node *LogicalHashAgg)

+ func InitNagtPool(cap int)

+ func IsOneShardExchange(exchange Exchange) bool

+ func LastRowFieldKey(field influxql.Expr, mapping map[influxql.Expr]influxql.VarRef) string

+ func LengthOfPrefixForField(name string, aliases []string) int

+ func MatchSortMergeJoin(join *influxql.Join, schema hybridqp.Catalog) (bool, error)

+ func MergeRecordColToChunk(r arrow.Record, c Chunk) error

+ func NewCallLLMApiFunc(ctx context.Context, client openai.Client, modelName string, ...) func(prompt string, question string) ([]string, error)

+ func OperateParam(e influxql.Expr, param *util.Param) error

+ func ProcessHashAgg(node *LogicalHashAgg, isUnifyPlan bool)

+ func RegistryLLMFunc(name string, op LLMFunc)

+ func RegistryTableFunctionOp(name string, tableFunctionOp TableFunctionOperator)

+ func RegrSlopeReduce[T util.NumberOnly](si *SliceItem[T]) (int, int64, float64, bool)

+ func ResetTimeForCompare(oChunk Chunk, offset time.Duration)

+ func RmseCol[T util.NumberOnly](actual, predicted []T) float64

+ func SetResource(qc query.LogicalPlanCreator, schema hybridqp.Catalog) error

+ func TransForwardBoolean(dst Column, src Column) error

+ func TransForwardFloat(dst Column, src Column) error

+ func TransForwardInteger(dst Column, src Column) error

+ func TransForwardString(dst Column, src Column) error

+ func TransNodeTraits(nodeTraits []hybridqp.Trait) ([]hybridqp.Trait, error)

+ func TransparentForwardGraph(dst Column, src Chunk, index []int, dstChunk Chunk)

+ func TransparentForwardGraphColumn(dst Column, src Column, srcChunk Chunk, dstChunk Chunk)

+ type ADDiffAbsOp struct

+ func (c *ADDiffAbsOp) CreateRoutine(params *AggCallFuncParams) (Routine, error)

+ type ADRmseExtOp struct

+ func (c *ADRmseExtOp) CreateRoutine(params *AggCallFuncParams) (Routine, error)

+ type ADSlopeScoreOp struct

+ func (c *ADSlopeScoreOp) CreateRoutine(params *AggCallFuncParams) (Routine, error)

type AggPushDownToColumnStoreReaderRule

+ func (r *AggPushDownToColumnStoreReaderRule) Category() OptRuleCategory

type AggPushDownToSubQueryRule

+ func (r *AggPushDownToSubQueryRule) Category() OptRuleCategory

type AggPushdownToExchangeRule

+ func (r *AggPushdownToExchangeRule) Category() OptRuleCategory

type AggPushdownToReaderRule

+ func (r *AggPushdownToReaderRule) Category() OptRuleCategory

type AggPushdownToSeriesRule

+ func (r *AggPushdownToSeriesRule) Category() OptRuleCategory

type AggSpreadToExchangeRule

+ func (r *AggSpreadToExchangeRule) Category() OptRuleCategory

type AggSpreadToReaderRule

+ func (r *AggSpreadToReaderRule) Category() OptRuleCategory

type AggSpreadToSortAppendRule

+ func (r *AggSpreadToSortAppendRule) Category() OptRuleCategory

type AggToProjectInSubQueryRule

+ func (r *AggToProjectInSubQueryRule) Category() OptRuleCategory

+ type AlgoParam struct

+ BFSNarrow bool

+ HopCount int

+ Task map[string]interface{}

type AlignTransform

+ func (trans *AlignTransform) NextChunk()

+ type AppendColumnValueFunc func(outColumn Column, value *ValueKeeper)

+ type ArrowChunkSender struct

+ Logger *logger.Logger

+ func NewArrowChunkSender(opt *query.ProcessorOptions) *ArrowChunkSender

+ func (w *ArrowChunkSender) GenRecords(chunk Chunk, lastChunk bool)

+ func (w *ArrowChunkSender) Release()

+ func (w *ArrowChunkSender) SetAbortProcessor(trans AbortProcessor)

+ func (w *ArrowChunkSender) Write(chunk Chunk, lastChunk bool) bool

+ type BaseLLMFunc struct

+ func NewBaseLLMFunc(name string, prompt string, ...) *BaseLLMFunc

+ func (b *BaseLLMFunc) Process(dst, src Column) error

type BinOpTransform

+ func (trans *BinOpTransform) AddPrePrimaryGroup(prePrimaryGroups *GroupLocs)

+ func (trans *BinOpTransform) AddResultBase(secondaryChunk Chunk, noMatchFn func(Chunk, int, *ChunkTags), ...) error

+ func (trans *BinOpTransform) AddResultLand(secondaryChunk Chunk) error

+ func (trans *BinOpTransform) AddResultLor(secondaryChunk Chunk) error

+ func (trans *BinOpTransform) AddResultLunless(secondaryChunk Chunk) error

+ type CTEExecutorBuilder interface

+ Analyze func(span *tracing.Span)

+ Build func(node hybridqp.QueryNode) (hybridqp.Executor, error)

+ type CTETransform struct

+ ExecutorBuilder CTEExecutorBuilder

+ func NewCTETransform(inRowDataType hybridqp.RowDataType, outRowDataType hybridqp.RowDataType, ...) (*CTETransform, error)

+ func (trans *CTETransform) Close()

+ func (trans *CTETransform) Explain() []ValuePair

+ func (trans *CTETransform) GetInputNumber(port Port) int

+ func (trans *CTETransform) GetInputs() Ports

+ func (trans *CTETransform) GetOutputNumber(port Port) int

+ func (trans *CTETransform) GetOutputs() Ports

+ func (trans *CTETransform) Name() string

+ func (trans *CTETransform) RunPlan(ctx context.Context, span *tracing.Span) error

+ func (trans *CTETransform) SendChunk(c Chunk)

+ func (trans *CTETransform) TagValueFromChunk(chunk Chunk, name string) Column

+ func (trans *CTETransform) Work(ctx context.Context) error

+ type CTETransformCreator struct

+ func (c *CTETransformCreator) Create(plan LogicalPlan, _ *query.ProcessorOptions) (Processor, error)

type CastorAggCutRule

+ func (r *CastorAggCutRule) Category() OptRuleCategory

+ type CastorParams struct

type Chunk

+ func FilterEventChunks(chunks []Chunk, nodes map[string]GraphNode, colMap map[string]int) (filterChunks []Chunk, err error)

+ func PromStepInvariant(src, dst Chunk, typ PromStepInvariantType, preGroup []byte, nextGroup []byte, ...) Chunk

+ func PromStepInvariantOnlyLastGroup(src Chunk, preGroup []byte, nextGroup []byte, step, startT, endT int64) Chunk

+ func PromStepInvariantSkipLastGroup(src, dst Chunk, preGroup []byte, step, startT, endT int64) Chunk

+ type ChunkColumn interface

+ AddColumn func(...Column)

+ AddDim func(...Column)

+ AddDims func([]string)

+ Column func(int) Column

+ Columns func() []Column

+ Dim func(int) Column

+ Dims func() []Column

+ NewDims func(size int)

+ SetColumn func(Column, int)

+ type ChunkGraph interface

+ GetGraph func() IGraph

+ SetGraph func(g IGraph)

type ChunkImpl

+ func (c *ChunkImpl) Append(ck Chunk, start, end int)

+ func (c *ChunkImpl) FilterRowsByIndexes(indexes ...int) Chunk

+ func (c *ChunkImpl) GetGraph() IGraph

+ func (c *ChunkImpl) SetGraph(g IGraph)

+ type ChunkMeta interface

+ CopyByRowDataType func(c Chunk, fromRt hybridqp.RowDataType, dstRt hybridqp.RowDataType) error

+ Name func() string

+ RowDataType func() hybridqp.RowDataType

+ SetName func(string)

+ SetRowDataType func(hybridqp.RowDataType)

+ type ChunkOperator interface

+ Append func(ck Chunk, start, end int)

+ CheckChunk func()

+ Clone func() Chunk

+ CopyTo func(Chunk)

+ FilterRowsByIndexes func(indexes ...int) Chunk

+ GetRecord func() *record.Record

+ IsNil func() bool

+ Len func() int

+ NumberOfCols func() int

+ NumberOfRows func() int

+ Reset func()

+ SlimChunk func(ridIdx []int) Chunk

+ String func() string

+ type ChunkPortsWithMeta struct

+ ChunkPort *ChunkPort

+ Chunks []Chunk

+ IGraph IGraph

+ Meta map[string]int

+ type ChunkSender interface

+ Release func()

+ SetAbortProcessor func(AbortProcessor)

+ Write func(Chunk, bool) bool

+ func NewChunkSender(opt *query.ProcessorOptions) ChunkSender

+ type ChunkSerialization interface

+ Instance func() transport.Codec

+ Marshal func([]byte) ([]byte, error)

+ Size func() int

+ Unmarshal func([]byte) error

+ type ChunkTag interface

+ AppendTagsAndIndex func(ChunkTags, int)

+ AppendTagsAndIndexes func([]ChunkTags, []int)

+ ResetTagsAndIndexes func(tags []ChunkTags, tagIndex []int)

+ TagIndex func() []int

+ TagLen func() int

+ Tags func() []ChunkTags

+ type ChunkTime interface

+ AppendIntervalIndex func(int)

+ AppendIntervalIndexes func([]int)

+ AppendTime func(...int64)

+ AppendTimes func([]int64)

+ InitTimeWindow func(minTime, maxTime, intervalTime int64, hasInterval, ascending bool, ...)

+ IntervalIndex func() []int

+ IntervalLen func() int

+ ResetIntervalIndex func(...int)

+ ResetTime func(int, int64)

+ SetTime func(time []int64)

+ Time func() []int64

+ TimeByIndex func(int) int64

+ TruncateTime func(int)

type Column

+ FilterColumnByRowIndexes func(indexes ...int) Column

+ GetFloatTupleValues func(int) []float64

type ColumnImpl

+ func (c *ColumnImpl) FilterColumnByRowIndexes(indexes ...int) Column

+ func (c *ColumnImpl) GetFloatTupleValues(idx int) []float64

+ type DataCacheCenter struct

+ func NewDataCacheCenter() DataCacheCenter

+ func (dataCacheCenter *DataCacheCenter) ClearDataStoreByKey(keyPrefix string, CTEs influxql.CTES)

+ type DistinctPushDownToExchangeRule struct

+ func NewDistinctPushDownToExchangeRule(description string) *DistinctPushDownToExchangeRule

+ func (r *DistinctPushDownToExchangeRule) Category() OptRuleCategory

+ func (r *DistinctPushDownToExchangeRule) Equals(rhs OptRule) bool

+ func (r *DistinctPushDownToExchangeRule) OnMatch(call *OptRuleCall)

+ func (r *DistinctPushDownToExchangeRule) ToString() string

+ type DistinctTransform struct

+ Inputs ChunkPorts

+ Outputs ChunkPorts

+ func NewDistinctTransform(inRowDataTypes []hybridqp.RowDataType, outRowDataTypes []hybridqp.RowDataType, ...) *DistinctTransform

+ func (d *DistinctTransform) Close()

+ func (d *DistinctTransform) Explain() []ValuePair

+ func (d *DistinctTransform) GetInputNumber(port Port) int

+ func (d *DistinctTransform) GetInputs() Ports

+ func (d *DistinctTransform) GetOutputNumber(port Port) int

+ func (d *DistinctTransform) GetOutputs() Ports

+ func (d *DistinctTransform) Name() string

+ func (d *DistinctTransform) Work(ctx context.Context) error

+ type DistinctTransformCreator struct

+ func (d *DistinctTransformCreator) Create(plan LogicalPlan, opt *query.ProcessorOptions) (Processor, error)

+ type EdgeMetaData struct

+ Kind string

+ SourceTopoKey string

+ SourceUid string

+ Tags map[string]string

+ TargetTopoKey string

+ TargetUid string

type FileFragment

+ AppendFragmentRangeDetails func(fragment.FragmentRangeDetails)

+ GetFragmentRangeDetails func() fragment.FragmentRangeDetails

type FileFragmentImpl

+ func NewFileFragmentForTest(f immutable.TSSPFile, fr fragment.FragmentRanges, fc int64) *FileFragmentImpl

+ func (f *FileFragmentImpl) AppendFragmentRangeDetails(frds fragment.FragmentRangeDetails)

+ func (f *FileFragmentImpl) GetFragmentRangeDetails() fragment.FragmentRangeDetails

+ type GenericAlignIterator struct

+ func NewGenericAlignIterator(fn GetColumnValueFunc, fv AppendColumnValueFunc) *GenericAlignIterator

+ func (f *GenericAlignIterator) Next(endpoint *IteratorEndpoint, p *IteratorParams)

+ type GetColumnValueFunc func(inColumn Column, start int, end int) (*ValueKeeper, bool)

+ type GetNodeIdOp struct

+ func (c *GetNodeIdOp) Run(params *TableFunctionParams) ([]Chunk, error)

+ type Graph struct

+ Edges map[string]GraphEdge

+ Nodes map[string]GraphNode

+ func FaultDemarcation(chunks []Chunk, subTopo *Graph, algoParams AlgoParam, colMap map[string]int) (graph *Graph, err error)

+ func NewGraph() *Graph

+ func (G *Graph) BatchInsertEdges(graphData GraphData) (bool, error)

+ func (G *Graph) BatchInsertNodes(graphData GraphData) bool

+ func (G *Graph) CreateGraph(jsonGraphData string) (bool, error)

+ func (G *Graph) GetEdgeInfo(id string) *GraphEdge

+ func (G *Graph) GetNodeInfo(id string) *GraphNode

+ func (G *Graph) GraphToRows() models.Rows

+ func (G *Graph) MultiHopFilter(startNodeId string, hopNum int, nodeCondition influxql.Expr, ...) (*Graph, error)

+ type GraphData struct

+ Graph TopoInfo

+ MetaData MetaData

+ ResultUid string

+ type GraphEdge struct

+ MetaData EdgeMetaData

+ Uid string

+ type GraphFilterFn func(chunks []Chunk, subTopo *Graph, algoParams AlgoParam, colMap map[string]int) (*Graph, error)

+ type GraphFilterIterator struct

+ func NewGraphFilterIterator(fn GraphFilterFn, outOrdinal int, params AlgoParam, ordinalMap map[int]int) *GraphFilterIterator

+ func (r *GraphFilterIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type GraphNode struct

+ InEdges []string

+ MetaData NodeMetaData

+ OutEdges []string

+ Uid string

+ type GraphTransform struct

+ func NewGraphTransform(stmt *influxql.GraphStatement) (*GraphTransform, error)

+ func (trans *GraphTransform) Close()

+ func (trans *GraphTransform) Explain() []ValuePair

+ func (trans *GraphTransform) GetInputNumber(_ Port) int

+ func (trans *GraphTransform) GetInputs() Ports

+ func (trans *GraphTransform) GetOutputNumber(_ Port) int

+ func (trans *GraphTransform) GetOutputs() Ports

+ func (trans *GraphTransform) Name() string

+ func (trans *GraphTransform) ParseGraphOtherCondition(cond string) (influxql.Expr, string, string, error)

+ func (trans *GraphTransform) Work(ctx context.Context) error

+ type GraphTransformCreator struct

+ func (c *GraphTransformCreator) Create(plan LogicalPlan, _ *query.ProcessorOptions) (Processor, error)

type HashAggType

+ const TopN

+ type HashJoinTransform struct

+ BuildSide int

+ ProbeSide int

+ func NewHashJoinTransform(inRowDataTypes []hybridqp.RowDataType, outRowDataType hybridqp.RowDataType, ...) (*HashJoinTransform, error)

+ func (trans *HashJoinTransform) Close()

+ func (trans *HashJoinTransform) Explain() []ValuePair

+ func (trans *HashJoinTransform) GetInputNumber(_ Port) int

+ func (trans *HashJoinTransform) GetInputs() Ports

+ func (trans *HashJoinTransform) GetOutputNumber(_ Port) int

+ func (trans *HashJoinTransform) GetOutputs() Ports

+ func (trans *HashJoinTransform) Name() string

+ func (trans *HashJoinTransform) SendChunk()

+ func (trans *HashJoinTransform) Work(ctx context.Context) error

+ type IGraph interface

+ BatchInsertEdges func(graphData GraphData) (bool, error)

+ BatchInsertNodes func(graphData GraphData) bool

+ CreateGraph func(jsonGraphData string) (bool, error)

+ GetEdgeInfo func(id string) *GraphEdge

+ GetNodeInfo func(id string) *GraphNode

+ GraphToRows func() models.Rows

+ MultiHopFilter func(startNodeId string, hopNum int, nodeCondition influxql.Expr, ...) (*Graph, error)

+ type InTransform struct

+ BufColumnMap map[interface{}]struct{}

+ ExecutorBuilder OuterExecutorBuilder

+ OuterVarRef *influxql.VarRef

+ func NewInTransform(inRowDataTypes []hybridqp.RowDataType, outRowDataType hybridqp.RowDataType, ...) (*InTransform, error)

+ func (trans *InTransform) AddChunkToBufColumn(c Chunk)

+ func (trans *InTransform) AddGraphChunkToBufColumn(c Chunk)

+ func (trans *InTransform) AddTagValsToBufColumn(s influxql.TablesTagSets)

+ func (trans *InTransform) Close()

+ func (trans *InTransform) Explain() []ValuePair

+ func (trans *InTransform) GetInputNumber(_ Port) int

+ func (trans *InTransform) GetInputs() Ports

+ func (trans *InTransform) GetOutputNumber(_ Port) int

+ func (trans *InTransform) GetOutputs() Ports

+ func (trans *InTransform) Name() string

+ func (trans *InTransform) RewriteOuterStmtCondition() error

+ func (trans *InTransform) RunOuterPlan(ctx context.Context) error

+ func (trans *InTransform) SendChunk(c Chunk)

+ func (trans *InTransform) ShowTagValRun(stmt *influxql.ShowTagValuesStatement) error

+ func (trans *InTransform) WalkDBNodes(database string, fn func(nodeID uint64, pts []uint32) error) error

+ func (trans *InTransform) Work(ctx context.Context) error

+ type InTransformCreator struct

+ func (c *InTransformCreator) Create(plan LogicalPlan, _ *query.ProcessorOptions) (Processor, error)

+ type InTransformRunningState int

type IncAggRule

+ func (r *IncAggRule) Category() OptRuleCategory

type IncHashAggRule

+ func (r *IncHashAggRule) Category() OptRuleCategory

type IndexScanExtraInfo

+ Dsc bool

type IntervalToProjectInSubQueryRule

+ func (r *IntervalToProjectInSubQueryRule) Category() OptRuleCategory

+ type JoinTransformCreator struct

+ func (c *JoinTransformCreator) Create(plan LogicalPlan, _ *query.ProcessorOptions) (Processor, error)

+ type LLMClassify struct

+ func (o *LLMClassify) GetPrompt(prompt string) string

+ func (o *LLMClassify) InitOp(arg string, callLLM func(prompt string, input string) ([]string, error)) LLMFunc

+ func (o *LLMClassify) Name() string

+ type LLMFunc interface

+ InitOp func(arg string, f func(prompt string, input string) ([]string, error)) LLMFunc

+ Name func() string

+ Process func(dst, src Column) error

+ func GetLLMFunc(name string) LLMFunc

+ type LLMGenerate struct

+ func (o *LLMGenerate) GetPrompt(prompt string) string

+ func (o *LLMGenerate) InitOp(arg string, callLLM func(prompt string, input string) ([]string, error)) LLMFunc

+ func (o *LLMGenerate) Name() string

+ type LLMSemanticTransform struct

+ func NewLLMSemanticTransform(inRowDataType, outRowDataType hybridqp.RowDataType, ops []hybridqp.ExprOptions, ...) (*LLMSemanticTransform, error)

+ func (st *LLMSemanticTransform) Close()

+ func (st *LLMSemanticTransform) Explain() []ValuePair

+ func (st *LLMSemanticTransform) GetInputNumber(port Port) int

+ func (st *LLMSemanticTransform) GetInputs() Ports

+ func (st *LLMSemanticTransform) GetOutputNumber(port Port) int

+ func (st *LLMSemanticTransform) GetOutputs() Ports

+ func (st *LLMSemanticTransform) Name() string

+ func (st *LLMSemanticTransform) Work(ctx context.Context) error

+ type LLMSemanticTransformCreator struct

+ func (c *LLMSemanticTransformCreator) Create(plan LogicalPlan, _ *query.ProcessorOptions) (Processor, error)

+ type LLMSummarize struct

+ func (o *LLMSummarize) GetPrompt(prompt string) string

+ func (o *LLMSummarize) InitOp(arg string, callLLM func(prompt string, input string) ([]string, error)) LLMFunc

+ func (o *LLMSummarize) Name() string

type LimitPushdownToExchangeRule

+ func (r *LimitPushdownToExchangeRule) Category() OptRuleCategory

type LimitPushdownToReaderRule

+ func (r *LimitPushdownToReaderRule) Category() OptRuleCategory

type LimitPushdownToSeriesRule

+ func (r *LimitPushdownToSeriesRule) Category() OptRuleCategory

type LogicalAggregate

+ func (p *LogicalAggregate) InferAggLevel() AggLevel

+ func (p *LogicalAggregate) InferPromAggLevel() AggLevel

+ type LogicalCTE struct

+ func NewLogicalCTE(cte *influxql.CTE, schema hybridqp.Catalog, ctePlan hybridqp.QueryNode) *LogicalCTE

+ func (p *LogicalCTE) Clone() hybridqp.QueryNode

+ func (p *LogicalCTE) DeriveOperations()

+ func (p *LogicalCTE) Digest() string

+ func (p *LogicalCTE) Explain(writer LogicalPlanWriter)

+ func (p *LogicalCTE) GetCTEPlan() hybridqp.QueryNode

+ func (p *LogicalCTE) LogicPlanType() internal.LogicPlanType

+ func (p *LogicalCTE) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ func (p *LogicalCTE) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalCTE) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalCTE) String() string

+ func (p *LogicalCTE) Type() string

+ type LogicalDistinct struct

+ func NewLogicalDistinct(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalDistinct

+ func (p *LogicalDistinct) Clone() hybridqp.QueryNode

+ func (p *LogicalDistinct) DeriveOperations()

+ func (p *LogicalDistinct) Digest() string

+ func (p *LogicalDistinct) Explain(writer LogicalPlanWriter)

+ func (p *LogicalDistinct) LogicPlanType() internal.LogicPlanType

+ func (p *LogicalDistinct) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ func (p *LogicalDistinct) String() string

+ func (p *LogicalDistinct) Type() string

+ type LogicalGraph struct

+ func NewLogicalGraph(input hybridqp.QueryNode, stmt *influxql.GraphStatement, ...) *LogicalGraph

+ func (p *LogicalGraph) Children() []hybridqp.QueryNode

+ func (p *LogicalGraph) Clone() hybridqp.QueryNode

+ func (p *LogicalGraph) DeriveOperations()

+ func (p *LogicalGraph) Digest() string

+ func (p *LogicalGraph) Explain(writer LogicalPlanWriter)

+ func (p *LogicalGraph) LogicPlanType() internal.LogicPlanType

+ func (p *LogicalGraph) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ func (p *LogicalGraph) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalGraph) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalGraph) String() string

+ func (p *LogicalGraph) Type() string

type LogicalHashAgg

+ func (p *LogicalHashAgg) ExplainIterms(writer LogicalPlanWriter)

+ type LogicalIn struct

+ func NewLogicalIn(innerPlan hybridqp.QueryNode, outerStmt *influxql.SelectStatement, ...) *LogicalIn

+ func (p *LogicalIn) Children() []hybridqp.QueryNode

+ func (p *LogicalIn) Clone() hybridqp.QueryNode

+ func (p *LogicalIn) DeriveOperations()

+ func (p *LogicalIn) Digest() string

+ func (p *LogicalIn) Explain(writer LogicalPlanWriter)

+ func (p *LogicalIn) LogicPlanType() internal.LogicPlanType

+ func (p *LogicalIn) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ func (p *LogicalIn) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalIn) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalIn) String() string

+ func (p *LogicalIn) Type() string

type LogicalJoin

+ func (p *LogicalJoin) Children() []hybridqp.QueryNode

+ func (p *LogicalJoin) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalJoin) ReplaceChildren(children []hybridqp.QueryNode)

+ type LogicalLLMSemantic struct

+ func NewLogicalLLMSemantic(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalLLMSemantic

+ func (p *LogicalLLMSemantic) Clone() hybridqp.QueryNode

+ func (p *LogicalLLMSemantic) DeriveOperations()

+ func (p *LogicalLLMSemantic) Digest() string

+ func (p *LogicalLLMSemantic) Explain(writer LogicalPlanWriter)

+ func (p *LogicalLLMSemantic) LogicPlanType() internal.LogicPlanType

+ func (p *LogicalLLMSemantic) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ func (p *LogicalLLMSemantic) String() string

+ func (p *LogicalLLMSemantic) Type() string

type LogicalPlanBuilder

+ CreateDistinct func(hybridqp.QueryNode) (hybridqp.QueryNode, error)

+ Distinct func() LogicalPlanBuilder

type LogicalPlanBuilderImpl

+ func (b *LogicalPlanBuilderImpl) Align() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) CreateDistinct(input hybridqp.QueryNode) (hybridqp.QueryNode, error)

+ func (b *LogicalPlanBuilderImpl) Distinct() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) LLMSemantic() LogicalPlanBuilder

+ type LogicalTableFunction struct

+ TableFunctionName string

+ func NewLogicalTableFunction(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, tableFunctionName string, ...) *LogicalTableFunction

+ func (p *LogicalTableFunction) Clone() hybridqp.QueryNode

+ func (p *LogicalTableFunction) DeriveOperations()

+ func (p *LogicalTableFunction) Digest() string

+ func (p *LogicalTableFunction) Explain(writer LogicalPlanWriter)

+ func (p *LogicalTableFunction) LogicPlanType() internal.LogicPlanType

+ func (p *LogicalTableFunction) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ func (p *LogicalTableFunction) String() string

+ func (p *LogicalTableFunction) Type() string

type MergeTransform

+ func (trans *MergeTransform) AppendIntervalIndex(chunk Chunk, i int, opt *query.ProcessorOptions, flag bool) bool

+ type MetaData struct

+ Region string

+ Timestamp string

+ Topokeys []string

+ type MultiMstInfo struct

+ Opt query.ProcessorOptions

+ ShardIds []uint64

+ type NodeMetaData struct

+ Kind string

+ Region string

+ Tags map[string]string

+ type NodeTraitKey struct

+ Database string

+ NodeID uint64

+ PtID uint32

type OptRule

+ Category func() OptRuleCategory

+ type OptRuleCategory int

+ const RULE_PUSHDOWN_DISTINCT

+ type OuterExecutorBuilder interface

+ Analyze func(span *tracing.Span)

+ Build func(node hybridqp.QueryNode) (hybridqp.Executor, error)

type PlanTypeInitShard

+ func (pts *PlanTypeInitShard) CheckDatabaseExists(name string) error

+ func (pts *PlanTypeInitShard) GetResource(resource string) map[string]string

+ func (pts *PlanTypeInitShard) GetTagKeys(stmt *influxql.ShowTagValuesStatement) (map[string]map[string]struct{}, error)

+ func (pts *PlanTypeInitShard) GetTagVals(nodeID uint64, stmt *influxql.ShowTagValuesStatement, pts2 []uint32, ...) (influxql.TablesTagSets, error)

+ func (pts *PlanTypeInitShard) QueryNodePtsMap(database string) (map[uint64][]uint32, error)

+ type Property struct

+ Key string

+ Value string

type QuerySchema

+ InConditons []*influxql.InCondition

+ func (qs *QuerySchema) AddLLMFunc(call *influxql.Call, alias string)

+ func (qs *QuerySchema) ClearInConditions()

+ func (qs *QuerySchema) GetResource(name string) map[string]string

+ func (qs *QuerySchema) GetUnionCases() []*influxql.Union

+ func (qs *QuerySchema) HasDistinct() bool

+ func (qs *QuerySchema) HasInCondition() bool

+ func (qs *QuerySchema) HasLLMFunc() bool

+ func (qs *QuerySchema) HasTopN() (string, bool)

+ func (qs *QuerySchema) IsColumnStoreCount() bool

+ func (qs *QuerySchema) IsCompareCall() bool

+ func (qs *QuerySchema) IsInSubquerySchema() bool

+ func (qs *QuerySchema) IsLastFieldQuery() bool

+ func (qs *QuerySchema) IsLastRowQuery() bool

+ func (qs *QuerySchema) LLMFunc() []*influxql.Field

+ func (qs *QuerySchema) RecordExpr(expr influxql.Node)

+ func (qs *QuerySchema) SetCompareCall()

+ func (qs *QuerySchema) SetDistinct(isDistinct bool)

+ func (qs *QuerySchema) SetIsInSubquerySchema(isInSubquerySchema bool)

+ func (qs *QuerySchema) SetJoinCases(joinCase []*influxql.Join)

+ func (qs *QuerySchema) SetResource(name string, resource map[string]string)

+ func (qs *QuerySchema) SetSources(sources influxql.Sources)

+ func (qs *QuerySchema) SetUnionCases(unionCase []*influxql.Union)

+ type QuerySchemaExpressionVisitor struct

+ ExprString *influxql.NestedNodeStringRepresentation

+ QuerySchema *QuerySchema

+ func (qsev *QuerySchemaExpressionVisitor) Visit(n influxql.Node) influxql.Visitor

+ type RCAOp struct

+ func (c *RCAOp) CreateRoutine(params *AggCallFuncParams) (Routine, error)

+ func (c *RCAOp) Run(params *TableFunctionParams) ([]Chunk, error)

type ReaderUpdateInSubQueryRule

+ func (r *ReaderUpdateInSubQueryRule) Category() OptRuleCategory

+ type RecordsGenerator struct

+ func NewRecordsGenerator(chunkedSize int) *RecordsGenerator

+ func (g *RecordsGenerator) Generate(chunk Chunk, lastChunk bool, records []*models.RecordContainer) []*models.RecordContainer

+ func (g *RecordsGenerator) Release()

+ type RegrSlopeOp struct

+ func (c *RegrSlopeOp) CreateRoutine(params *AggCallFuncParams) (Routine, error)

type RemoteQuery

+ MstInfos []*MultiMstInfo

+ func (c *RemoteQuery) BuildMstTraits() []*MultiMstReqs

+ func (c *RemoteQuery) Clone() *RemoteQuery

+ func (c *RemoteQuery) MarshalMstInfos(rq *proto2.RemoteQuery) error

+ func (c *RemoteQuery) UnmarshalMstInfos(pb *proto2.RemoteQuery) error

+ type Response struct

+ Data GraphData

type RuleInstruction

+ func (g *RuleInstruction) RuleCategory() OptRuleCategory

+ type Schema interface

+ Mapping func() map[influxql.Expr]influxql.VarRef

type SlideWindowSpreadRule

+ func (r *SlideWindowSpreadRule) Category() OptRuleCategory

+ type SortMergeJoinTransform struct

+ func NewSortMergeJoinTransform(inRowDataTypes []hybridqp.RowDataType, outRowDataType hybridqp.RowDataType, ...) (*SortMergeJoinTransform, error)

+ func (trans *SortMergeJoinTransform) Close()

+ func (trans *SortMergeJoinTransform) Explain() []ValuePair

+ func (trans *SortMergeJoinTransform) GetInputNumber(_ Port) int

+ func (trans *SortMergeJoinTransform) GetInputs() Ports

+ func (trans *SortMergeJoinTransform) GetOutputNumber(_ Port) int

+ func (trans *SortMergeJoinTransform) GetOutputs() Ports

+ func (trans *SortMergeJoinTransform) Name() string

+ func (trans *SortMergeJoinTransform) SendChunk()

+ func (trans *SortMergeJoinTransform) Work(ctx context.Context) error

type TCountMinSketch

+ func (cms *TCountMinSketch) Reset()

type TCounter

+ const NoCounter

type TDdcm

+ func (ddcm *TDdcm) Name() string

+ type THeavyHitterInfo struct

type TKey

+ func (k *TKey) Eq(o TKey) bool

+ func (k *TKey) GetByteSize() int

+ type TMajorityDetector struct

+ BitCounts []TCounter

+ TotalCount TCounter

+ func (detector *TMajorityDetector) AddKeyCount(key *TKey, count TCounter)

+ func (detector *TMajorityDetector) GetMajorityKey() (TKey, bool)

+ func (detector *TMajorityDetector) GetTotalCount() TCounter

+ func (detector *TMajorityDetector) Reset()

+ type TSmallCounterSet struct

+ Counters []TCounter

+ Min TCounter

+ func (set *TSmallCounterSet) Replace(before, after TCounter)

+ type TSubstream struct

+ func (sub *TSubstream) Reset()

+ type TTopnCM05Optimized struct

+ FrequencyEstimator TCountMinSketch

+ FrequencyEstimatorHasher THasher

+ HasherIntoSubstreams THasher

+ HeavyHitters map[string]*THeavyHitterInfo

+ KeysByIndices [][]map[string]struct{}

+ Parameters TTopnCM05OptimizedParameters

+ RandomEngine *rand.Rand

+ Substreams [][]TSubstream

+ TotalCount TCounter

+ func CreateTTopnCM05Optimized(...) *TTopnCM05Optimized

+ func DefaultCreateTTopnCM05Optimized() *TTopnCM05Optimized

+ func (nagt *TTopnCM05Optimized) AddKeyCount(key TKey, value TCounter)

+ func (nagt *TTopnCM05Optimized) GetFrequentKeys(countLowerBound TCounter) ([]TKey, []TCounter)

+ func (nagt *TTopnCM05Optimized) GetKeyCount(key TKey) TCounter

+ func (nagt *TTopnCM05Optimized) GetTotalCount() TCounter

+ func (nagt *TTopnCM05Optimized) Instance() *TTopnCM05Optimized

+ func (nagt *TTopnCM05Optimized) MemSize() int

+ func (nagt *TTopnCM05Optimized) Name() string

+ func (nagt *TTopnCM05Optimized) Ready(seed uint64)

+ func (nagt *TTopnCM05Optimized) Reset()

+ type TTopnCM05OptimizedParameters struct

+ func ConstructParametersFromGuarantees(...) TTopnCM05OptimizedParameters

+ type TableFunctionFactory map[string]TableFunctionOperator

+ type TableFunctionOperator interface

+ Run func(params *TableFunctionParams) ([]Chunk, error)

+ func GetTableFunctionOperator(name string) TableFunctionOperator

+ type TableFunctionParams struct

+ ChunkPortsWithMetas []*ChunkPortsWithMeta

+ Param string

+ type TableFunctionTransform struct

+ InputsWithMetas []*ChunkPortsWithMeta

+ Output *ChunkPort

+ TableFunctionName string

+ func NewTableFunctionTransform(plan LogicalPlan) *TableFunctionTransform

+ func (trans *TableFunctionTransform) Close()

+ func (trans *TableFunctionTransform) Explain() []ValuePair

+ func (trans *TableFunctionTransform) GetInputNumber(port Port) int

+ func (trans *TableFunctionTransform) GetInputs() Ports

+ func (trans *TableFunctionTransform) GetOutputNumber(port Port) int

+ func (trans *TableFunctionTransform) GetOutputs() Ports

+ func (trans *TableFunctionTransform) Name() string

+ func (trans *TableFunctionTransform) Work(ctx context.Context) error

+ type TableFunctionTransformCreator struct

+ func (trans *TableFunctionTransformCreator) Create(plan LogicalPlan, _ *query.ProcessorOptions) (Processor, error)

type TargetTable

+ func (tt *TargetTable) Instance() *TargetTable

+ func (tt *TargetTable) MemSize() int

+ type TopoInfo struct

+ Edges []GraphEdge

+ Vertex []GraphNode

type TransformVertex

+ func (t *TransformVertex) GetNode() hybridqp.QueryNode

+ type ValueKeeper struct

+ func GetBooleanAlignValue(inColumn Column, start int, end int) (*ValueKeeper, bool)

+ func GetFloatAlignValue(inColumn Column, start int, end int) (*ValueKeeper, bool)

+ func GetIntegerAlignValue(inColumn Column, start int, end int) (*ValueKeeper, bool)

+ func GetStringAlignValue(inColumn Column, start int, end int) (*ValueKeeper, bool)

+ func (v *ValueKeeper) Reset()

+ func (v *ValueKeeper) SetStringValue(value string)

+ type WideMultiColIterator struct

+ func NewWideMultiColIterator(fn WideReduce, params ...interface{}) *WideMultiColIterator

+ func (r *WideMultiColIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

v1.4.3

Sep 1, 2025

v1.4.2

Sep 1, 2025

v1.4.1

Jun 5, 2025

v1.4.0

Apr 12, 2025

Changes in this version

+ const EulerNumber

+ const MersennePower

+ const PromInstantVectorTransformName

+ var DefaultDelta float64 = 1e-8

+ var DefaultEps float64 = DefaultPhi / 10

+ var DefaultPhi float64 = 3e-5

+ var DefaultSigma float64 = 1e-8

+ func AbsentWithOutDataAlive(opt *query.ProcessorOptions, outChunk Chunk)

+ func B2ui64(b bool) uint64

+ func BinOpATAN2(lVal, rVal float64) (float64, bool)

+ func BottomCmpByValueReduceProm[T util.NumberOnly](a, b *PointItem[T]) bool

+ func CalcChange(preValues []float64, currValues []float64) float64

+ func CalcHoltWinters(preV []float64, curV []float64, sf, tf float64) float64

+ func CalcLastTwoPoints(preTimes []int64, currTimes []int64, preValues []float64, currValues []float64) (int64, int64, float64, float64)

+ func CalcLog2(value float64) int

+ func CalcMad(values []float64) float64

+ func CalcMad2(preValues []float64, currValues []float64) float64

+ func CalcQuantile(q float64, values []float64) float64

+ func CalcQuantile2(q float64, preValues []float64, currValues []float64) float64

+ func CalcResets(preV []float64, curV []float64) float64

+ func ContainsSameTagset(chunk Chunk) bool

+ func DoCalcChange(curV []float64, prev float64, changes int) (float64, int)

+ func DoCalcResets(prevV []float64, prev float64, resets int) (float64, int)

+ func Float64Equal(a, b float64) bool

+ func KahanSumInc(inc, sum, c float64) (newSum, newC float64)

+ func NewGroupPromFunc(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions) (*aggFunc, error)

+ func NewGroupPromOperator() aggOperator

+ func NewStdPromOperator(flag bool) aggOperator

+ func NewStddevPromFunc(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions) (*aggFunc, error)

+ func NewStdvarPromFunc(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions) (*aggFunc, error)

+ func SortByTimeAsc[T util.NumberOnly](f *HeapItem[T])

+ func SortByValueDsc[T util.NumberOnly](f *HeapItem[T])

+ func TopCmpByValueReduceProm[T util.NumberOnly](a, b *PointItem[T]) bool

type Abort

+ NoMarkCrash bool

+ type AbsentIterator struct

+ func NewAbsentIterator(inOrdinal, outOrdinal int, opt *query.ProcessorOptions) *AbsentIterator

+ func (r *AbsentIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

type BaseProcessor

+ func (bp *BaseProcessor) InterruptWithoutMark()

type BinOpTransform

+ func (trans *BinOpTransform) BinOpHelperConditionSingleExpr(ctx context.Context, errs *errno.Errs)

type Chunk

+ PromStepInvariant func(typ PromStepInvariantType, preGroup []byte, nextGroup []byte, ...) Chunk

type ChunkImpl

+ func (c *ChunkImpl) CopyGroup(dst Chunk, tagLoc, start, end int) Chunk

+ func (c *ChunkImpl) CopyTags(dst Chunk, tagLoc int) Chunk

+ func (c *ChunkImpl) PromStepInvariant(typ PromStepInvariantType, preGroup []byte, nextGroup []byte, ...) Chunk

+ func (c *ChunkImpl) PromStepInvariantOnlyLastGroup(preGroup []byte, nextGroup []byte, step, startT, endT int64) Chunk

+ func (c *ChunkImpl) PromStepInvariantSkipLastGroup(preGroup []byte, step, startT, endT int64, dst Chunk) Chunk

type ChunkValuer

+ func (c *ChunkValuer) SetValueFnOnlyPromTime()

+ func (c *ChunkValuer) ValuePromTime(key string) (interface{}, bool)

type Crash

+ NoMarkCrash bool

type ExchangeType

+ const SUBQUERY_EXCHANGE

type ExecutorBuilder

+ func (builder *ExecutorBuilder) CanOptimizeExchange(node hybridqp.QueryNode, children []*TransformVertex) (*TransformVertex, bool)

type FillTransform

+ func (trans *FillTransform) NextChunk()

+ type FrequentResult struct

+ func (fr *FrequentResult) Len() int

+ func (fr *FrequentResult) Less(i, j int) bool

+ func (fr *FrequentResult) Swap(i, j int)

type HashAggType

+ const SubQuery

type LogicalDummyShard

+ func (p *LogicalDummyShard) GetIndexInfo() comm.TSIndexInfo

type LogicalPlanBuilderImpl

+ func (b *LogicalPlanBuilderImpl) PromSort() LogicalPlanBuilder

+ type LogicalPromSort struct

+ func NewLogicalPromSort(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalPromSort

+ func (p *LogicalPromSort) Clone() hybridqp.QueryNode

+ func (p *LogicalPromSort) DeriveOperations()

+ func (p *LogicalPromSort) Digest() string

+ func (p *LogicalPromSort) Explain(writer LogicalPlanWriter)

+ func (p *LogicalPromSort) ExplainIterms(writer LogicalPlanWriter)

+ func (p *LogicalPromSort) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ func (p *LogicalPromSort) String() string

+ func (p *LogicalPromSort) Type() string

type MultiMstReqs

+ func (m *MultiMstReqs) SetReqs(reqs []*RemoteQuery)

type PipelineExecutor

+ Query string

+ func (exec *PipelineExecutor) NoMarkCrash()

type PlanType

+ const AGG_INTERVAL_FILLNONE

+ type PrePoint struct

+ func (p *PrePoint) Clear()

type Processor

+ func NewTopNTransform(inRowDataType, outRowDataType []hybridqp.RowDataType, ...) (Processor, error)

+ InterruptWithoutMark func()

type Processors

+ func (ps Processors) InterruptWithoutMark()

+ type PromAbsentOp struct

+ func (c *PromAbsentOp) CreateRoutine(params *AggCallFuncParams) (Routine, error)

+ type PromInstantVectorTransform struct

+ func NewPromInstantVectorTransform(inRowDataType hybridqp.RowDataType, outRowDataType hybridqp.RowDataType, ...) (*PromInstantVectorTransform, error)

+ func (trans *PromInstantVectorTransform) Close()

+ func (trans *PromInstantVectorTransform) Explain() []ValuePair

+ func (trans *PromInstantVectorTransform) GetGroupRange(i int, chunk Chunk) (int, int)

+ func (trans *PromInstantVectorTransform) GetInputNumber(_ Port) int

+ func (trans *PromInstantVectorTransform) GetInputs() Ports

+ func (trans *PromInstantVectorTransform) GetOutputNumber(_ Port) int

+ func (trans *PromInstantVectorTransform) GetOutputs() Ports

+ func (trans *PromInstantVectorTransform) GroupCall(startIdx, endIdx int)

+ func (trans *PromInstantVectorTransform) Name() string

+ func (trans *PromInstantVectorTransform) RangeCall(startCurrLoc, endCurrLoc int, start, rangeMaxt int64)

+ func (trans *PromInstantVectorTransform) UpdateLoc(startCurrLoc, endCurrLoc int)

+ func (trans *PromInstantVectorTransform) Work(ctx context.Context) error

+ func (trans *PromInstantVectorTransform) WorkHelper(ctx context.Context, errs *errno.Errs)

+ type PromInstantVectorTransformCreator struct

+ func (c *PromInstantVectorTransformCreator) Create(plan LogicalPlan, _ *query.ProcessorOptions) (Processor, error)

+ type PromSortGroups struct

+ func NewPromSortGroups() PromSortGroups

+ func (rows *PromSortGroups) AppendMany(tagKey, tagValue []string, value []float64, timestamp []int64)

+ type PromSortSeries struct

+ func NewPromSortSeries(tagKey, tagValue []string, value []float64, timestamp []int64) *PromSortSeries

+ func (r *PromSortSeries) Value() float64

+ type PromSortTransform struct

+ func NewPromSortTransform(inRowDataType, outRowDataType hybridqp.RowDataType, s *QuerySchema, ...) (*PromSortTransform, error)

+ func (trans *PromSortTransform) Close()

+ func (trans *PromSortTransform) Explain() []ValuePair

+ func (trans *PromSortTransform) GetInputNumber(_ Port) int

+ func (trans *PromSortTransform) GetInputs() Ports

+ func (trans *PromSortTransform) GetOutputNumber(_ Port) int

+ func (trans *PromSortTransform) GetOutputs() Ports

+ func (trans *PromSortTransform) Name() string

+ func (trans *PromSortTransform) Work(ctx context.Context) error

+ func (trans *PromSortTransform) WorkHelper(ctx context.Context, errs *errno.Errs)

+ type PromSortTransformCreator struct

+ func (c *PromSortTransformCreator) Create(plan LogicalPlan, _ *query.ProcessorOptions) (Processor, error)

+ type PromStepInvariantType int

+ const OnlyLastGroup

+ const SkipLastGroup

type QuerySchema

+ func (qs *QuerySchema) HasPromAbsentCall() bool

+ func (qs *QuerySchema) HasTopNDDCM() bool

+ func (qs *QuerySchema) IsPromAbsentCall() bool

+ func (qs *QuerySchema) IsPromNestedCountCall() bool

type RPCReaderTransform

+ NoMarkCrash bool

+ func (t *RPCReaderTransform) InterruptWithoutMark()

+ type RetryErrTransform struct

+ func NewRetryErrTransform() *RetryErrTransform

+ func (source *RetryErrTransform) Close()

+ func (source *RetryErrTransform) Explain() []ValuePair

+ func (source *RetryErrTransform) GetInputNumber(_ Port) int

+ func (source *RetryErrTransform) GetInputs() Ports

+ func (source *RetryErrTransform) GetOutputNumber(_ Port) int

+ func (source *RetryErrTransform) GetOutputs() Ports

+ func (source *RetryErrTransform) Name() string

+ func (source *RetryErrTransform) Work(ctx context.Context) error

type StreamAggregateTransform

+ func (trans *StreamAggregateTransform) NextChunk()

+ type TCountMinSketch struct

+ Depth int

+ Table [][]TCounter

+ Width int

+ func NewTCountMinSketch(depth int, widthLog2 int) TCountMinSketch

+ func (cms *TCountMinSketch) Add(indices []int, value TCounter)

+ func (cms *TCountMinSketch) Get(indices []int) TCounter

+ func (cms *TCountMinSketch) GetCounter(depth int, index int) TCounter

+ type TCounter float64

+ type TDdcm struct

+ CycleManager TDdcmCycleManagerBase

+ Hashers []THasher

+ HashersLastLevels []int

+ LargeSketch TCountMinSketch

+ LargeSketchHashes THashVector

+ LargeSketchIndices []int

+ Parameters TDdcmParameters

+ PrecalculatedHashes []THashVector

+ RandomEngine *rand.Rand

+ SargeSketchHashes THashVector

+ SmallSketchIndices []int

+ SmallSketches []TCountMinSketch

+ SmallSketchesHasherIds []int

+ SmallSketchesNextSameHasherLevel []int

+ TotalCount TCounter

+ func CreateDdcmWithWdm(...) TDdcm

+ func NewTDdcm(parameters *TDdcmParameters, seed uint64, cycleManager TDdcmCycleManagerBase) TDdcm

+ func (ddcm *TDdcm) AddKeyCount(key TKey, value TCounter)

+ func (ddcm *TDdcm) CalcHashesAndGetIndices(key TKey, level int, indices *[]int)

+ func (ddcm *TDdcm) CalcLargeSketchIndices(key TKey, indices *[]int)

+ func (ddcm *TDdcm) ExtendLevels(size int)

+ func (ddcm *TDdcm) GetFrequentKeys(countLowerBound TCounter) ([]TKey, []TCounter)

+ func (ddcm *TDdcm) GetFrequentKeysOfSize(countLowerBound TCounter, size int, keys *[]TKey, values *[]TCounter)

+ func (ddcm *TDdcm) GetKeyCount(key TKey) TCounter

+ func (ddcm *TDdcm) GetTotalCount() TCounter

+ type TDdcmCycleManagerBase interface

+ AddNewLevel func() int

+ Copy func() TDdcmCycleManagerBase

+ type TDdcmCycleManagerWdm struct

+ CurrentCycleLength int

+ CurrentCyclePos int

+ CurrentNumCycles int

+ CurrentNumCyclesFractional float64

+ CurrentPosInCycle int

+ CyclesNumberExponent float64

+ func NewTDdcmCycleManagerWdm(cyclesNumberExponent float64, firstCycleLength int) *TDdcmCycleManagerWdm

+ func (ddcmw *TDdcmCycleManagerWdm) AddNewLevel() int

+ func (ddcmw *TDdcmCycleManagerWdm) Copy() TDdcmCycleManagerBase

+ type TDdcmParameters struct

+ CountMinSketchWidthLog2 int

+ LargeCountMinSketchDepth int

+ SmallCountMinSketchDepth int

+ func CalcDdcmParameters(errRate, minSearchableFrequency, wrongAnswerProbability float64) (TDdcmParameters, error)

+ type TExtendedHashValue uint64

+ const MersennePrime

+ type THashValue uint32

+ func ModuleHash(hash TExtendedHashValue) THashValue

+ type THashVector THashValue

+ type THasher struct

+ Depth int

+ MultiplicativeHashCoefficients [][]TExtendedHashValue

+ PolynomialHashBases []TExtendedHashValue

+ WidthLog2 int

+ func NewTHasher(depth int, widthLog2 int, seed uint64) THasher

+ func (h *THasher) GetInitialHashVector(hashVector *THashVector)

+ func (h *THasher) TurnHashesIntoIndices(hashes THashVector, indices *[]int)

+ func (h *THasher) UpdateHashes(key TKey, numBitsBefore int, numBitsAfter int, hashes *THashVector)

+ func (h *THasher) UpdateHashesBytewise(key TKey, numBytesBefore int, numBytesAfter int, hashes *THashVector)

+ type TKey struct

+ Data []byte

+ func (k *TKey) ChangeBit(i int)

+ func (k *TKey) Copy() *TKey

+ func (k *TKey) Get(i int) bool

+ func (k *TKey) GetByte(i int) byte

+ func (k *TKey) GetSize() int

+ func (k *TKey) Less(o TKey) bool

+ type TopNTransform struct

+ func (trans *TopNTransform) Close()

+ func (trans *TopNTransform) Explain() []ValuePair

+ func (trans *TopNTransform) GetInputNumber(_ Port) int

+ func (trans *TopNTransform) GetInputs() Ports

+ func (trans *TopNTransform) GetOutputNumber(_ Port) int

+ func (trans *TopNTransform) GetOutputs() Ports

+ func (trans *TopNTransform) InitFuncs(inRowDataType hybridqp.RowDataType, fn string, opt hybridqp.ExprOptions) error

+ func (trans *TopNTransform) Name() string

+ func (trans *TopNTransform) Work(ctx context.Context) error

+ type TopNTransformCreator struct

+ func (c *TopNTransformCreator) Create(plan LogicalPlan, opt query.ProcessorOptions) (Processor, error)

v1.3.1

Jan 2, 2025

v1.3.0

Nov 12, 2024

Changes in this version

+ const BinOpTransformName

+ const OrderbyChunkNum

+ const PromRangeVectorTransformName

+ func AbsentMerge[T util.NumberOnly](prevPoint, currPoint *Point[T])

+ func AbsentReduce(c Chunk, values []int64, ordinal, start, end int) (int, int64, bool)

+ func AbsoluteDiffFunc[T util.NumberOnly](prev, curr T) T

+ func BehindDiffFunc[T util.NumberOnly](prev, curr T) T

+ func BinOpADD(lVal, rVal float64) (float64, bool)

+ func BinOpDIV(lVal, rVal float64) (float64, bool)

+ func BinOpEQLC(lVal, rVal float64) (float64, bool)

+ func BinOpGTE(lVal, rVal float64) (float64, bool)

+ func BinOpGTR(lVal, rVal float64) (float64, bool)

+ func BinOpLSS(lVal, rVal float64) (float64, bool)

+ func BinOpLTE(lVal, rVal float64) (float64, bool)

+ func BinOpMOD(lVal, rVal float64) (float64, bool)

+ func BinOpMUL(lVal, rVal float64) (float64, bool)

+ func BinOpNEQ(lVal, rVal float64) (float64, bool)

+ func BinOpPOW(lVal, rVal float64) (float64, bool)

+ func BinOpSUB(lVal, rVal float64) (float64, bool)

+ func BottomCmpByTimeReduce[T util.NumberOnly](a, b *PointItem[T]) bool

+ func BottomCmpByValueReduce[T util.NumberOnly](a, b *PointItem[T]) bool

+ func BuildBinOpQueryPlan(ctx context.Context, qc query.LogicalPlanCreator, ...) (hybridqp.QueryNode, error)

+ func BuildFullJoinQueryPlan(ctx context.Context, qc query.LogicalPlanCreator, ...) (hybridqp.QueryNode, error)

+ func BuildSources(ctx context.Context, qc query.LogicalPlanCreator, sources influxql.Sources, ...) (hybridqp.QueryNode, error)

+ func CalcReduceResult(prevT, currT []int64, prevV, currV []float64, isCounter bool) (int64, int64, float64, float64, float64)

+ func ChangeCallExprForTimestamp(call *influxql.Call)

+ func ChangeOpsForTimestamp(ops []hybridqp.ExprOptions) []hybridqp.ExprOptions

+ func CountMerge[T util.NumberOnly](prevPoint, currPoint *Point[T])

+ func CountReduce(c Chunk, values []int64, ordinal, start, end int) (int, int64, bool)

+ func FirstMerge[T util.NumberOnly](prevPoint, currPoint *Point[T])

+ func FirstReduce[T util.ExceptBool](c Chunk, values []T, ordinal, start, end int) (int, T, bool)

+ func FirstTimeColFastReduce[T util.ExceptBool](c Chunk, values []T, ordinal, start, end int) (int, T, bool)

+ func FirstTimeColMerge[T util.NumberOnly](prevPoint, currPoint *Point[T])

+ func FirstTimeColReduce[T util.ExceptBool](c Chunk, values []T, ordinal, start, end int) (int, T, bool)

+ func FirstTimeColSlowReduce[T util.ExceptBool](c Chunk, values []T, ordinal, start, end int) (int, T, bool)

+ func FloatCountPromMerge(prevPoint, currPoint *Point[float64])

+ func FloatCountPromReduce(c Chunk, values []float64, ordinal, start, end int) (int, float64, bool)

+ func FrontDiffFunc[T util.NumberOnly](prev, curr T) T

+ func GetOrdinal(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions) (int, int)

+ func GetPromTimeFuncInstance() map[string]PromTimeFunction

+ func GroupMerge(prevPoint, currPoint *Point[float64])

+ func GroupReduce(c Chunk, values []float64, ordinal, start, end int) (int, float64, bool)

+ func IrateFastReduce[T util.NumberOnly](c Chunk, values []T, ordinal, start, end int) (int, int, T, T, bool)

+ func IrateFinalReduce[T util.NumberOnly](ft int64, st int64, fv T, sv T, interval *hybridqp.Interval) (float64, bool)

+ func IrateMerge[T util.NumberOnly](prevPoints [2]*Point[T], interval *hybridqp.Interval) (float64, bool)

+ func IrateMiddleReduce[T util.NumberOnly](c Chunk, values []T, ordinal, start, end int) (int, int, T, T, bool)

+ func IrateSlowReduce[T util.NumberOnly](c Chunk, values []T, ordinal, start, end int) (int, int, T, T, bool)

+ func IrateUpdate[T util.NumberOnly](prevPoints, currPoints [2]*Point[T])

+ func IsEnableFileCursor(schema hybridqp.Catalog) bool

+ func LastMerge[T util.NumberOnly](prevPoint, currPoint *Point[T])

+ func LastReduce[T util.ExceptBool](c Chunk, values []T, ordinal, start, end int) (int, T, bool)

+ func LastTimeColFastReduce[T util.ExceptBool](c Chunk, values []T, ordinal, start, end int) (int, T, bool)

+ func LastTimeColMerge[T util.NumberOnly](prevPoint, currPoint *Point[T])

+ func LastTimeColReduce[T util.ExceptBool](c Chunk, values []T, ordinal, start, end int) (int, T, bool)

+ func LastTimeColSlowReduce[T util.ExceptBool](c Chunk, values []T, ordinal, start, end int) (int, T, bool)

+ func MaxMerge[T util.NumberOnly](prevPoint, currPoint *Point[T])

+ func MaxPromMerge(prevPoint, currPoint *Point[float64])

+ func MaxPromReduce(c Chunk, values []float64, ordinal, start, end int) (int, float64, bool)

+ func MaxReduce[T util.NumberOnly](c Chunk, values []T, ordinal, start, end int) (int, T, bool)

+ func MinMerge[T util.NumberOnly](prevPoint, currPoint *Point[T])

+ func MinPromMerge(prevPoint, currPoint *Point[float64])

+ func MinPromReduce(c Chunk, values []float64, ordinal, start, end int) (int, float64, bool)

+ func MinReduce[T util.NumberOnly](c Chunk, values []T, ordinal, start, end int) (int, T, bool)

+ func NewCountPromFunc(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions) (*aggFunc, error)

+ func NewCountPromOperator() aggOperator

+ func NewMaxPromFunc(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions) (*aggFunc, error)

+ func NewMaxPromOperator() aggOperator

+ func NewMedianReduce[T util.NumberOnly](si *SliceItem[T]) (int, int64, float64, bool)

+ func NewMinPromFunc(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions) (*aggFunc, error)

+ func NewMinPromOperator() aggOperator

+ func NewModeReduce[T util.ExceptBool](si *SliceItem[T]) (int, int64, float64, bool)

+ func NewPromFunc(inRowDataType hybridqp.RowDataType, typ AggFuncType, op func() aggOperator, ...) (*aggFunc, error)

+ func RateFastReduce[T util.NumberOnly](c Chunk, values []T, ordinal, start, end int) (int, int, T, T, bool)

+ func RateFinalReduce[T util.NumberOnly](firstTime int64, lastTime int64, firstValue T, lastValue T, ...) (float64, bool)

+ func RateLowReduce[T util.NumberOnly](c Chunk, values []T, ordinal, start, end int) (int, int, T, T, bool)

+ func RateMerge[T util.NumberOnly](prevPoints [2]*Point[T], interval *hybridqp.Interval) (float64, bool)

+ func RateMiddleReduce[T util.NumberOnly](c Chunk, values []T, ordinal, start, end int) (int, int, T, T, bool)

+ func RateUpdate[T util.NumberOnly](prevPoints, currPoints [2]*Point[T])

+ func RegistryAggOp(name string, aggOp AggOperator)

+ func RegistryLabelFunction(name string, labelFunc LabelFunction)

+ func RegistryPromTimeFunction(name string, timeFunc PromTimeFunction)

+ func RemoveCommonValues(prev, curr [][]interface{}) [][]interface

+ func ResetTime(srcCk, dstCk Chunk, ts int64)

+ func ResetTimeForProm(srcCk, dstCk Chunk, ts int64)

+ func SlidingWindowMergeFunc[T util.ExceptString](prevWindow, currWindow *SlidingWindow[T], fpm PointMerge[T])

+ func SumMerge[T util.NumberOnly](prevPoint, currPoint *Point[T])

+ func SumReduce[T util.NumberOnly](c Chunk, values []T, ordinal, start, end int) (int, T, bool)

+ func TopCmpByTimeReduce[T util.NumberOnly](a, b *PointItem[T]) bool

+ func TopCmpByValueReduce[T util.NumberOnly](a, b *PointItem[T]) bool

+ func TranverseBinTreeForTimestamp(expr influxql.Expr)

+ func UpdateHashBooleanMaxFast(dstChunk, srcChunk Chunk, dstCol, srcCol, dstRow, srcRow int, bitmap *Bitmap)

+ func UpdateHashBooleanMaxSlow(dstChunk, srcChunk Chunk, dstCol, srcCol, dstRow, srcRow int, bitmap *Bitmap)

+ func UpdateHashBooleanMinFast(dstChunk, srcChunk Chunk, dstCol, srcCol, dstRow, srcRow int, bitmap *Bitmap)

+ func UpdateHashBooleanMinSlow(dstChunk, srcChunk Chunk, dstCol, srcCol, dstRow, srcRow int, bitmap *Bitmap)

+ func UpdateHashFloatMaxFast(dstChunk, srcChunk Chunk, dstCol, srcCol, dstRow, srcRow int, bitmap *Bitmap)

+ func UpdateHashFloatMaxSlow(dstChunk, srcChunk Chunk, dstCol, srcCol, dstRow, srcRow int, bitmap *Bitmap)

+ func UpdateHashFloatMinFast(dstChunk, srcChunk Chunk, dstCol, srcCol, dstRow, srcRow int, bitmap *Bitmap)

+ func UpdateHashFloatMinSlow(dstChunk, srcChunk Chunk, dstCol, srcCol, dstRow, srcRow int, bitmap *Bitmap)

+ func UpdateHashFloatSumFast(dstChunk, srcChunk Chunk, dstCol, srcCol, dstRow, srcRow int, bitmap *Bitmap)

+ func UpdateHashFloatSumSlow(dstChunk, srcChunk Chunk, dstCol, srcCol, dstRow, srcRow int, bitmap *Bitmap)

+ func UpdateHashInterMaxFast(dstChunk, srcChunk Chunk, dstCol, srcCol, dstRow, srcRow int, bitmap *Bitmap)

+ func UpdateHashInterMaxSlow(dstChunk, srcChunk Chunk, dstCol, srcCol, dstRow, srcRow int, bitmap *Bitmap)

+ func UpdateHashInterMinFast(dstChunk, srcChunk Chunk, dstCol, srcCol, dstRow, srcRow int, bitmap *Bitmap)

+ func UpdateHashInterMinSlow(dstChunk, srcChunk Chunk, dstCol, srcCol, dstRow, srcRow int, bitmap *Bitmap)

+ func UpdateHashInterSumFast(dstChunk, srcChunk Chunk, dstCol, srcCol, dstRow, srcRow int, bitmap *Bitmap)

+ func UpdateHashInterSumSlow(dstChunk, srcChunk Chunk, dstCol, srcCol, dstRow, srcRow int, bitmap *Bitmap)

+ type AbortProcessor interface

+ AbortSinkTransform func()

+ type AggCallFuncParams struct

+ AuxProcessor []*AuxProcessor

+ ExprOpt hybridqp.ExprOptions

+ InRowDataType hybridqp.RowDataType

+ IsSingleCall bool

+ IsSubQuery bool

+ Name string

+ Opt *query.ProcessorOptions

+ OutRowDataType hybridqp.RowDataType

+ ProRes *processorResults

+ type AggFactory map[string]AggOperator

+ type AggOperator interface

+ CreateRoutine func(params *AggCallFuncParams) (Routine, error)

+ func GetAggOperator(name string) AggOperator

type BaseProcessor

+ func (bp *BaseProcessor) Interrupt()

+ type BasePromOp struct

+ func NewBasePromOp(op string, fn ColReduceFunc[float64], fv ColMergeFunc[float64]) BasePromOp

+ func (c *BasePromOp) CreateRoutine(params *AggCallFuncParams) (Routine, error)

+ type BinOpTransform struct

+ BinOpHelper func(ctx context.Context, errs *errno.Errs)

+ IncludeKeys []string

+ MatchKeys []string

+ MatchKeysForMatchCompute []string

+ NilMst influxql.NilMstState

+ On bool

+ OpType int

+ ReturnBool bool

+ func NewBinOpTransform(inRowDataTypes []hybridqp.RowDataType, outRowDataType hybridqp.RowDataType, ...) (*BinOpTransform, error)

+ func (trans *BinOpTransform) AddResult(secondaryChunk Chunk) error

+ func (trans *BinOpTransform) AddResultSimple(secondaryChunk Chunk)

+ func (trans *BinOpTransform) BinOpHelperConditionBoth(ctx context.Context, errs *errno.Errs)

+ func (trans *BinOpTransform) BinOpHelperConditionSingle(ctx context.Context, errs *errno.Errs)

+ func (trans *BinOpTransform) BinOpHelperOperator(ctx context.Context, errs *errno.Errs)

+ func (trans *BinOpTransform) Close()

+ func (trans *BinOpTransform) ComputeResultTags(pTagKeys, pTagValues, sTagKeys, sTagValues []string) ([]string, []string, string)

+ func (trans *BinOpTransform) Explain() []ValuePair

+ func (trans *BinOpTransform) GetInputNumber(_ Port) int

+ func (trans *BinOpTransform) GetInputs() Ports

+ func (trans *BinOpTransform) GetOutputNumber(_ Port) int

+ func (trans *BinOpTransform) GetOutputs() Ports

+ func (trans *BinOpTransform) Name() string

+ func (trans *BinOpTransform) SendChunk()

+ func (trans *BinOpTransform) Work(ctx context.Context) error

+ type BinOpTransformCreator struct

+ func (c *BinOpTransformCreator) Create(plan LogicalPlan, _ *query.ProcessorOptions) (Processor, error)

+ type BooleanIterator struct

+ func NewBooleanIterator(fn BooleanReduce, fv PointMerge[bool], isSingleCall bool, ...) *BooleanIterator

+ func (r *BooleanIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type BooleanReduce func(c Chunk, values []bool, ordinal, start, end int) (index int, value bool, isNil bool)

+ type BufEle struct

+ func NewBufEle() *BufEle

+ func (be *BufEle) Append(times []int64, values []float64)

+ func (be *BufEle) AppendBuf(buf *BufEle)

+ func (be *BufEle) Clear()

+ func (be *BufEle) Set(times []int64, values []float64, loc int, endLoc int)

+ type CallFn func([]int64, []int64, []float64, []float64, int64, *influxql.PromSubCall) (float64, bool)

type ChunkTags

+ func NewChunkTagsByBytes(bytes []byte) *ChunkTags

+ func NewChunkTagsDeepCopy(subset []byte, offsets []uint16) *ChunkTags

+ func NewChunkTagsWithoutDims(pts influx.PointTags, withoutDims []string) *ChunkTags

+ func (ct *ChunkTags) DecodeTagsWithoutTag(tagName string) ([]byte, string)

+ func (ct *ChunkTags) RemoveKeys(keys []string) *ChunkTags

type ChunkValuer

+ func (c *ChunkValuer) ValueNormal(key string) (interface{}, bool)

+ func (c *ChunkValuer) ValueProm(key string) (interface{}, bool)

+ type ColMergeFunc func(prevPoint, currPoint *Point[T])

+ type ColReduceFunc func(c Chunk, values []T, ordinal, start, end int) (index int, value T, isNil bool)

type Column

+ UpdateBooleanValueFast func(v bool, row int)

type ColumnImpl

+ func (c *ColumnImpl) UpdateBooleanValueFast(v bool, row int)

+ type CountValuesIterator struct

+ func NewCountValuesIterator(inOrdinal, outOrdinal int, tagName string) *CountValuesIterator

+ func (r *CountValuesIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type CountValuesOp struct

+ func (c *CountValuesOp) CreateRoutine(params *AggCallFuncParams) (Routine, error)

+ type Crash struct

+ ClientID uint64

+ QueryID uint64

+ func NewCrash(queryID uint64, clientID uint64) *Crash

+ func (c *Crash) Instance() transport.Codec

+ func (c *Crash) Marshal(buf []byte) ([]byte, error)

+ func (c *Crash) Size() int

+ func (c *Crash) Unmarshal(buf []byte) error

+ type DistinctItem struct

+ func NewDistinctItem[T util.ExceptBool]() *DistinctItem[T]

+ func (f *DistinctItem[T]) Len() int

+ func (f *DistinctItem[T]) Less(i, j int) bool

+ func (f *DistinctItem[T]) Nil() bool

+ func (f *DistinctItem[T]) Reset()

+ func (f *DistinctItem[T]) Swap(i, j int)

type ExecutorBuilder

+ func (builder *ExecutorBuilder) IsMultiMstPlanNode(node hybridqp.QueryNode) bool

+ type FloatColFloatHistogramIterator struct

+ func NewFloatColFloatHistogramIterator(fn FloatColReduceHistogramReduce, inOrdinal, outOrdinal int, ...) *FloatColFloatHistogramIterator

+ func (r *FloatColFloatHistogramIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

type FloatColFloatRateIterator

+ func NewFloatRateIterator(fn RateMiddleReduceFunc[float64], fv RateFinalReduceFunc[float64], ...) *FloatColFloatRateIterator

+ type FloatColReduceHistogramReduce func(floatItem []bucket) (value float64)

+ func FloatHistogramQuantilePromReduce(p float64) FloatColReduceHistogramReduce

+ type FloatCountPromOp struct

+ func (c *FloatCountPromOp) CreateRoutine(params *AggCallFuncParams) (Routine, error)

+ type FloatIntegralIterator struct

+ func NewFloatIntegralIterator(isSingleCall bool, inOrdinal, outOrdinal int, interval hybridqp.Interval, ...) *FloatIntegralIterator

+ func (r *FloatIntegralIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type FloatIterator struct

+ func NewFloatIterator(fn ColReduceFunc[float64], fv ColMergeFunc[float64], isSingleCall bool, ...) *FloatIterator

+ func (r *FloatIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type FloatTransIterator struct

+ func NewFloatTransIterator(isSingleCall bool, inOrdinal, outOrdinal int, transItem TransItem) *FloatTransIterator

+ func (r *FloatTransIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type GroupLocs struct

+ Loc int

+ Locs []*Loc

+ type HeapItem struct

+ func NewHeapItem[T util.NumberOnly](n int, cmpByValue, cmpByTime func(a, b *PointItem[T]) bool) *HeapItem[T]

+ func (f *HeapItem[T]) Len() int

+ func (f *HeapItem[T]) Less(i, j int) bool

+ func (f *HeapItem[T]) Pop() interface{}

+ func (f *HeapItem[T]) Push(x interface{})

+ func (f *HeapItem[T]) Reset()

+ func (f *HeapItem[T]) Swap(i, j int)

+ type HistogramQuantileOp struct

+ func (c *HistogramQuantileOp) CreateRoutine(params *AggCallFuncParams) (Routine, error)

type HttpChunkSender

+ func (w *HttpChunkSender) GenRows(chunk Chunk)

+ func (w *HttpChunkSender) SetAbortProcessor(trans AbortProcessor)

type HttpSenderHintTransform

+ func (trans *HttpSenderHintTransform) AbortSinkTransform()

+ func (trans *HttpSenderHintTransform) SetDag(dag *TransformDag)

+ func (trans *HttpSenderHintTransform) SetVertex(vertex *TransformVertex)

+ func (trans *HttpSenderHintTransform) Visit(vertex *TransformVertex) TransformVertexVisitor

type HttpSenderTransform

+ func (trans *HttpSenderTransform) AbortSinkTransform()

+ func (trans *HttpSenderTransform) SetDag(dag *TransformDag)

+ func (trans *HttpSenderTransform) SetVertex(vertex *TransformVertex)

+ func (trans *HttpSenderTransform) Visit(vertex *TransformVertex) TransformVertexVisitor

type IndexScanTransform

+ func (trans *IndexScanTransform) Interrupt()

type IntegerColFloatRateIterator

+ func NewIntegerRateIterator(fn RateMiddleReduceFunc[int64], fv RateFinalReduceFunc[int64], ...) *IntegerColFloatRateIterator

+ type IntegerIntegralIterator struct

+ func NewIntegerIntegralIterator(isSingleCall bool, inOrdinal, outOrdinal int, interval hybridqp.Interval, ...) *IntegerIntegralIterator

+ func (r *IntegerIntegralIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type IntegerIterator struct

+ func NewIntegerIterator(fn ColReduceFunc[int64], fv ColMergeFunc[int64], isSingleCall bool, ...) *IntegerIterator

+ func (r *IntegerIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type IntegerTransIterator struct

+ func NewIntegerTransIterator(isSingleCall bool, inOrdinal, outOrdinal int, transItem TransItem) *IntegerTransIterator

+ func (r *IntegerTransIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type IntegralItem struct

+ func NewIntegralItem[T util.NumberOnly](interval hybridqp.Interval, opt *query.ProcessorOptions) *IntegralItem[T]

+ func (f *IntegralItem[T]) AppendItem(c Chunk, values []T, ordinal int, start, end int, sameInterval, sameTag bool)

+ func (f *IntegralItem[T]) AppendItemFastFunc(c Chunk, values []T, start, end int, sameInterval bool, sameTag bool)

+ func (f *IntegralItem[T]) AppendItemSlowFunc(c Chunk, values []T, ordinal int, vs, ve int, sameInterval, sameTag bool)

+ func (f *IntegralItem[T]) CalculateUnit(index int, time int64, value float64)

+ func (f *IntegralItem[T]) Len() int

+ func (f *IntegralItem[T]) Nil() bool

+ func (f *IntegralItem[T]) Reset()

+ func (f *IntegralItem[T]) StartNewInterval(time int64)

+ type LabelFunction interface

+ CallFunc func(name string, args []interface{}) (interface{}, bool)

+ type LabelValuer struct

+ func (LabelValuer) SetValuer(_ influxql.Valuer, _ int)

+ func (LabelValuer) Value(_ string) (interface{}, bool)

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

+ type Loc struct

+ ChunkLoc int

+ GroupLoc int

+ RowLoc int

+ type LogicalBinOp struct

+ Para *influxql.BinOp

+ func NewLogicalBinOp(left hybridqp.QueryNode, right hybridqp.QueryNode, para *influxql.BinOp, ...) *LogicalBinOp

+ func (p *LogicalBinOp) Children() []hybridqp.QueryNode

+ func (p *LogicalBinOp) Clone() hybridqp.QueryNode

+ func (p *LogicalBinOp) DeriveOperations()

+ func (p *LogicalBinOp) Digest() string

+ func (p *LogicalBinOp) Explain(writer LogicalPlanWriter)

+ func (p *LogicalBinOp) LogicPlanType() internal.LogicPlanType

+ func (p *LogicalBinOp) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ func (p *LogicalBinOp) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalBinOp) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalBinOp) String() string

+ func (p *LogicalBinOp) Type() string

type LogicalPlanBuilderImpl

+ func (b *LogicalPlanBuilderImpl) HashAgg() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) PromSubquery(call *influxql.PromSubCall) LogicalPlanBuilder

+ type LogicalPromSubquery struct

+ Call *influxql.PromSubCall

+ func NewLogicalPromSubquery(input hybridqp.QueryNode, schema hybridqp.Catalog, Call *influxql.PromSubCall) *LogicalPromSubquery

+ func (p *LogicalPromSubquery) Children() []hybridqp.QueryNode

+ func (p *LogicalPromSubquery) Clone() hybridqp.QueryNode

+ func (p *LogicalPromSubquery) DeriveOperations()

+ func (p *LogicalPromSubquery) Digest() string

+ func (p *LogicalPromSubquery) Explain(writer LogicalPlanWriter)

+ func (p *LogicalPromSubquery) LogicPlanType() internal.LogicPlanType

+ func (p *LogicalPromSubquery) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ func (p *LogicalPromSubquery) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalPromSubquery) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalPromSubquery) String() string

+ func (p *LogicalPromSubquery) Type() string

type MaterializeTransform

+ HasBinaryExpr bool

+ type MaxOp struct

+ func (c *MaxOp) CreateRoutine(params *AggCallFuncParams) (Routine, error)

+ type MaxPromOp struct

+ func (c *MaxPromOp) CreateRoutine(params *AggCallFuncParams) (Routine, error)

+ type MinOp struct

+ func (c *MinOp) CreateRoutine(params *AggCallFuncParams) (Routine, error)

+ type MinPromOp struct

+ func (c *MinPromOp) CreateRoutine(params *AggCallFuncParams) (Routine, error)

type OrderByTransform

+ func (trans *OrderByTransform) GetCurrTags(i int) string

+ type PercentileApproxOp struct

+ func (c *PercentileApproxOp) CreateRoutine(params *AggCallFuncParams) (Routine, error)

type PipelineExecutor

+ func (exec *PipelineExecutor) InitContext(ctx context.Context) error

+ type Point struct

+ func (p *Point[T]) Assign(c *Point[T])

+ func (p *Point[T]) Reset()

+ func (p *Point[T]) Set(index int, time int64, value T)

+ type PointItem struct

+ func NewPointItem[T util.BasicType](time int64, value T) *PointItem[T]

+ type PointMerge func(prevPoint, currPoint *Point[T])

type Processor

+ Interrupt func()

type Processors

+ func (ps Processors) Interrupt()

+ type PromGroupOp struct

+ func (c *PromGroupOp) CreateRoutine(params *AggCallFuncParams) (Routine, error)

+ type PromQuantileOp struct

+ func (c *PromQuantileOp) CreateRoutine(params *AggCallFuncParams) (Routine, error)

+ type PromRangeVectorTransform struct

+ func NewPromRangeVectorTransform(inRowDataType hybridqp.RowDataType, outRowDataType hybridqp.RowDataType, ...) (*PromRangeVectorTransform, error)

+ func (trans *PromRangeVectorTransform) Close()

+ func (trans *PromRangeVectorTransform) Explain() []ValuePair

+ func (trans *PromRangeVectorTransform) GetGroupRange(i int, chunk Chunk) (int, int)

+ func (trans *PromRangeVectorTransform) GetInputNumber(_ Port) int

+ func (trans *PromRangeVectorTransform) GetInputs() Ports

+ func (trans *PromRangeVectorTransform) GetOutputNumber(_ Port) int

+ func (trans *PromRangeVectorTransform) GetOutputs() Ports

+ func (trans *PromRangeVectorTransform) GroupCall(startIdx, endIdx int)

+ func (trans *PromRangeVectorTransform) Name() string

+ func (trans *PromRangeVectorTransform) NewPromSubqueryCallFunc(call *influxql.PromSubCall) (CallFn, error)

+ func (trans *PromRangeVectorTransform) RangeCall(startPreLoc, endPreLoc, startCurrLoc, endCurrLoc int, start, rangeMaxt int64)

+ func (trans *PromRangeVectorTransform) UpdateLoc(startPreLoc, endPreLoc, startCurrLoc, endCurrLoc int)

+ func (trans *PromRangeVectorTransform) Work(ctx context.Context) error

+ func (trans *PromRangeVectorTransform) WorkHelper(ctx context.Context, errs *errno.Errs)

+ type PromRangeVectorTransformCreator struct

+ func (c *PromRangeVectorTransformCreator) Create(plan LogicalPlan, _ *query.ProcessorOptions) (Processor, error)

+ type PromScalarOp struct

+ func (c *PromScalarOp) CreateRoutine(params *AggCallFuncParams) (Routine, error)

+ type PromStdOp struct

+ func (c *PromStdOp) CreateRoutine(params *AggCallFuncParams) (Routine, error)

+ type PromTimeFunction interface

+ CallFunc func(name string, args []interface{}) (interface{}, bool)

+ type PromTimeValuer struct

+ func (PromTimeValuer) SetValuer(_ influxql.Valuer, _ int)

+ func (PromTimeValuer) Value(_ string) (interface{}, bool)

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

type QuerySchema

+ PromSubCalls []*influxql.PromSubCall

+ func (qs *QuerySchema) AddLabelCalls(key string, labelCalls *influxql.Call)

+ func (qs *QuerySchema) AddPromTimeCalls(key string, promTimeCalls *influxql.Call)

+ func (qs *QuerySchema) CanAggTagSet() bool

+ func (qs *QuerySchema) GetPromCalls() []*influxql.PromSubCall

+ func (qs *QuerySchema) HasLabelCalls() bool

+ func (qs *QuerySchema) HasPromNestedCall() bool

+ func (qs *QuerySchema) HasPromTimeCalls() bool

+ func (qs *QuerySchema) IsPromNestedCall(call *influxql.Call) bool

+ func (qs *QuerySchema) PromNestedCall() map[string]*hybridqp.PromNestedCall

+ func (qs *QuerySchema) PromResetTime() bool

+ func (qs *QuerySchema) SetPromCalls(calls []*influxql.PromSubCall)

+ func (qs *QuerySchema) SetSimpleTagset()

type RPCClient

+ func (c *RPCClient) Interrupt()

type RPCReaderTransform

+ func (t *RPCReaderTransform) Interrupt()

+ type RateFinalReduceFunc func(firstTime int64, lastTime int64, firstValue T, lastValue T, ...) (float64, bool)

+ type RateMergeFunc func(prevPoints [2]*Point[T], interval *hybridqp.Interval) (float64, bool)

+ type RateMiddleReduceFunc func(c Chunk, values []T, ordinal, start, end int) (firstIndex, lastIndex int, firstValue, lastValue T, isNil bool)

+ type RateUpdateFunc func(prevPoints, currPoints [2]*Point[T])

+ type SampleItem struct

+ func NewSampleItem[T util.BasicType](items []PointItem[T]) *SampleItem[T]

+ func (f *SampleItem[T]) Len() int

+ func (f *SampleItem[T]) Less(i, j int) bool

+ func (f *SampleItem[T]) Reset()

+ func (f *SampleItem[T]) Swap(i, j int)

+ type ScalarBuf struct

+ type ScalarIterator struct

+ func NewScalarIterator(inOrdinal, outOrdinal int) *ScalarIterator

+ func (r *ScalarIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type SliceItem struct

+ func NewSliceItem[T util.ExceptBool]() *SliceItem[T]

+ func (f *SliceItem[T]) AppendItem(c Chunk, ordinal, start, end int, values []T)

+ func (f *SliceItem[T]) Len() int

+ func (f *SliceItem[T]) Less(i, j int) bool

+ func (f *SliceItem[T]) Reset()

+ func (f *SliceItem[T]) Swap(i, j int)

+ type SliceReduce func(floatItem *SliceItem[T]) (index int, time int64, value float64, isNil bool)

+ func NewPercentileReduce[T util.NumberOnly](percentile float64) SliceReduce[T]

+ func NewStdDevReduce[T util.NumberOnly]() SliceReduce[T]

+ func NewStdReduce(isStddev bool) SliceReduce[float64]

+ func QuantileReduce(percentile float64) SliceReduce[float64]

+ type SlidingWindow struct

+ func NewSlidingWindow[T util.ExceptString](slidingNum int) *SlidingWindow[T]

+ func (w *SlidingWindow[T]) IsNil() bool

+ func (w *SlidingWindow[T]) Len() int

+ func (w *SlidingWindow[T]) Reset()

+ func (w *SlidingWindow[T]) SetPoint(value T, isNil bool, index int)

+ type SlidingWindowBooleanIterator struct

+ func NewSlidingWindowBooleanIterator(fwr BooleanColBooleanWindowReduce, fpm PointMerge[bool], fwm WindowMerge[bool], ...) *SlidingWindowBooleanIterator

+ func (r *SlidingWindowBooleanIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type SlidingWindowFloatIterator struct

+ func NewSlidingWindowFloatIterator(fwr ColReduceFunc[float64], fpm PointMerge[float64], fwm WindowMerge[float64], ...) *SlidingWindowFloatIterator

+ func (r *SlidingWindowFloatIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type SlidingWindowIntegerIterator struct

+ func NewSlidingWindowIntegerIterator(fwr ColReduceFunc[int64], fpm PointMerge[int64], fwm WindowMerge[int64], ...) *SlidingWindowIntegerIterator

+ func (r *SlidingWindowIntegerIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type StringIterator struct

+ func NewStringIterator(fn ColReduceFunc[string], fv StringMerge, isSingleCall bool, ...) *StringIterator

+ func (r *StringIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type StringMerge func(prevPoint, currPoint *StringPoint)

+ type TimeColReduceFunc func(c Chunk, values []T, ordinal, start, end int) (index int, value T, isNil bool)

+ type ValueCount struct

+ type WindowMerge func(prevWindow, currWindow *SlidingWindow[T], fpm PointMerge[T])

v1.3.0-rc.1

Sep 2, 2024

v1.2.0

Feb 29, 2024

Changes in this version

+ const Aborted

+ const FastFuncIdx

+ const FuncPathCount

+ const IncAggChunkCacheSize

+ const IncAggChunkCacheTTL

+ const IncHashAggChunkCacheSize

+ const IncHashAggChunkCacheTTL

+ const IncQueryFinishLength

+ const IncQueryFinishMessage

+ const MaxRowsInChunk

+ const SlowFuncIdx

+ var IncAggChunkCache = cache.NewCache(IncAggChunkCacheSize, IncAggChunkCacheTTL)

+ var IncHashAggChunkCache = cache.NewCache(IncHashAggChunkCacheSize, IncHashAggChunkCacheTTL)

+ func ColumnStringValue(c Column, rowLoc int) string

+ func ExpandColumnOffsets(col Column, stringBytes []byte, offsets []uint32) ([]byte, []uint32)

+ func GetMaxNumsOfGroups() int

+ func InitLocalStoreTemplatePlan()

+ func MarshalPtQuerys(ptQuerys []PtQuery) []*proto2.PtQuery

+ func MarshalShardInfos(shardInfos []ShardInfo) []*proto2.ShardInfo

+ func MatchNoAggNoGroupLimit(schema hybridqp.Catalog) bool

+ func NewHeapFloatOperator() aggOperator

+ func NewHeapFunc(inRowDataType, outRowDataType hybridqp.RowDataType, ...) (*aggFunc, error)

+ func NewHeapIntegerOperator() aggOperator

+ func NewHeapParam(topN int64, sortFuncs []func() sortEleMsg, sorKeyIdx []int, sortAsc []bool, ...) *heapParam

+ func NewHeapStringOperator() aggOperator

+ func NewIncQueryFinishMessage(isIncQuery, getFailed bool, queryID string, iterMaxNum int32, rowCount int64) *rpc.Message

+ func NewLocalStoreSqlPlanTypePool(planType PlanType) ([]hybridqp.QueryNode, error)

+ func NewMaxBooleanOperator() aggOperator

+ func NewMinBooleanOperator() aggOperator

+ func PrintPlan(planName string, plan hybridqp.QueryNode)

+ func PutIncAggChunk(queryID string, iterID int32, chunk Chunk)

+ func PutIncHashAggItem(queryID string, item *IncHashAggItem)

+ func ReplaceSortAggMergeWithHashAgg(plan hybridqp.QueryNode) []hybridqp.QueryNode

+ func ReplaceSortAggWithHashAgg(plan hybridqp.QueryNode) []hybridqp.QueryNode

+ func ReplaceSortMergeWithHashMerge(plan hybridqp.QueryNode) []hybridqp.QueryNode

+ func SetLocalStorageForQuery(storage hybridqp.StoreEngine)

+ func SetMaxGroupsNums(numsOfGroups int)

+ func UpdateFloatSumFast(dstChunk, srcChunk Chunk, dstCol, srcCol, dstRow, srcRow int)

+ func UpdateFloatSumSlow(dstChunk, srcChunk Chunk, dstCol, srcCol, dstRow, srcRow int)

+ func UpdateIncAggFunc(_, _ cache.Entry) bool

+ func UpdateIncHashAggFunc(_, _ cache.Entry) bool

+ func UpdateInterSumFast(dstChunk, srcChunk Chunk, dstCol, srcCol, dstRow, srcRow int)

+ func UpdateInterSumSlow(dstChunk, srcChunk Chunk, dstCol, srcCol, dstRow, srcRow int)

+ type AttachedFrags struct

+ func NewAttachedFrags(basePath string, cap int) *AttachedFrags

+ func (s *AttachedFrags) AppendIndexes(tsspFiles ...interface{})

+ func (s *AttachedFrags) IndexCount() int

+ func (s *AttachedFrags) Indexes() interface{}

+ type AttachedIndexInfo struct

+ func NewAttachedIndexInfo(files []immutable.TSSPFile, infos []*colstore.PKInfo) *AttachedIndexInfo

+ func (a *AttachedIndexInfo) Files() []immutable.TSSPFile

+ func (a *AttachedIndexInfo) Infos() []*colstore.PKInfo

+ type BaseFrags struct

+ func NewBaseFrags(basePath string, fileMode FileMode) *BaseFrags

+ func (s *BaseFrags) AddFragCount(fragCount int64)

+ func (s *BaseFrags) AppendFragRanges(frs ...fragment.FragmentRanges)

+ func (s *BaseFrags) BasePath() string

+ func (s *BaseFrags) FileMode() FileMode

+ func (s *BaseFrags) FragCount() int64

+ func (s *BaseFrags) FragRanges() []fragment.FragmentRanges

+ func (s *BaseFrags) GetErr() error

+ func (s *BaseFrags) SetErr(err error)

+ func (s *BaseFrags) Size() int

+ type CSIndexInfo struct

+ func NewCSIndexInfo(shardPath string, info *AttachedIndexInfo, version uint32) *CSIndexInfo

+ func (cs *CSIndexInfo) ShardPath() string

+ func (cs *CSIndexInfo) Version() uint32

type Chunk

+ func GetIncAggChunk(queryID string, iterID int32) (Chunk, bool)

+ InitTimeWindow func(minTime, maxTime, intervalTime int64, hasInterval, ascending bool, ...)

type ChunkImpl

+ func (c *ChunkImpl) AppendIntervalFullRows(start, step int64, num int, tag ChunkTags)

+ func (c *ChunkImpl) InitTimeWindow(minTime, maxTime, intervalTime int64, hasInterval, ascending bool, ...)

type Column

+ UpdateFloatValueFast func(v float64, row int)

+ UpdateIntegerValueFast func(v int64, row int)

type ColumnImpl

+ func (c *ColumnImpl) UpdateFloatValueFast(v float64, row int)

+ func (c *ColumnImpl) UpdateIntegerValueFast(v int64, row int)

+ type CsStoreExchangeTraits struct

+ func NewCsStoreExchangeTraits(w spdy.Responser, PtQuerys []PtQuery) *CsStoreExchangeTraits

+ type DetachedFrags struct

+ func NewDetachedFrags(basePath string, cap int) *DetachedFrags

+ func (s *DetachedFrags) AppendIndexes(metaIndexes ...interface{})

+ func (s *DetachedFrags) IndexCount() int

+ func (s *DetachedFrags) Indexes() interface{}

+ func (s *DetachedFrags) Size() int

+ type DetachedIndexInfo struct

+ func NewDetachedIndexInfo(files []*immutable.MetaIndex, infos []*colstore.DetachedPKInfo) *DetachedIndexInfo

+ func (a *DetachedIndexInfo) Files() []*immutable.MetaIndex

+ func (a *DetachedIndexInfo) Infos() []*colstore.DetachedPKInfo

+ type Exchange interface

+ AddTrait func(trait interface{})

+ ERole func() ExchangeRole

+ ETraits func() []hybridqp.Trait

+ EType func() ExchangeType

+ Schema func() hybridqp.Catalog

+ ToProducer func()

type ExchangeType

+ const PARTITION_EXCHANGE

type ExecutorBuilder

+ func NewColStoreScanExecutorBuilder(traits *StoreExchangeTraits, indexInfo interface{}, info *IndexScanExtraInfo) *ExecutorBuilder

+ func NewCsStoreExecutorBuilder(traits *CsStoreExchangeTraits, s hybridqp.StoreEngine, req *RemoteQuery, ...) *ExecutorBuilder

+ func (builder *ExecutorBuilder) NextInfo()

+ func (builder *ExecutorBuilder) NextMst()

+ func (builder *ExecutorBuilder) SetInfosAndTraits(mstsReqs []*MultiMstReqs, ctx context.Context)

+ func (builder *ExecutorBuilder) SetMultiMstInfosForLocalStore(t []*IndexScanExtraInfo)

+ func (builder *ExecutorBuilder) SetMultiMstTraitsForLocalStore(t []*StoreExchangeTraits)

+ func (builder *ExecutorBuilder) SetTraits(t *StoreExchangeTraits)

+ type FileMode uint8

+ const Attached

+ const Detached

+ type IncAggEntry struct

+ func NewIncAggEntry(queryID string) *IncAggEntry

+ func (e *IncAggEntry) GetKey() string

+ func (e *IncAggEntry) GetTime() time.Time

+ func (e *IncAggEntry) GetValue() interface{}

+ func (e *IncAggEntry) SetTime(time time.Time)

+ func (e *IncAggEntry) SetValue(value interface{})

+ func (e *IncAggEntry) Size() int64

+ type IncAggItem struct

+ func NewIncAggIterm(iterID int32, value Chunk) *IncAggItem

+ type IncAggRule struct

+ func NewIncAggRule(description string) *IncAggRule

+ func (r *IncAggRule) Catagory() OptRuleCatagory

+ func (r *IncAggRule) Equals(rhs OptRule) bool

+ func (r *IncAggRule) OnMatch(call *OptRuleCall)

+ func (r *IncAggRule) ToString() string

+ type IncAggTransform struct

+ Inputs ChunkPorts

+ Outputs ChunkPorts

+ func NewIncAggTransform(inRowDataTypes []hybridqp.RowDataType, outRowDataTypes []hybridqp.RowDataType, ...) (*IncAggTransform, error)

+ func (trans *IncAggTransform) Close()

+ func (trans *IncAggTransform) Explain() []ValuePair

+ func (trans *IncAggTransform) GetIndex(t int64) int64

+ func (trans *IncAggTransform) GetInputNumber(port Port) int

+ func (trans *IncAggTransform) GetInputs() Ports

+ func (trans *IncAggTransform) GetOutputNumber(port Port) int

+ func (trans *IncAggTransform) GetOutputs() Ports

+ func (trans *IncAggTransform) Name() string

+ func (trans *IncAggTransform) Work(ctx context.Context) error

+ type IncAggTransformCreator struct

+ func (c *IncAggTransformCreator) Create(plan LogicalPlan, opt *query.ProcessorOptions) (Processor, error)

+ type IncHashAggEntry struct

+ func NewIncHashAggEntry(queryID string) *IncHashAggEntry

+ func (e *IncHashAggEntry) GetKey() string

+ func (e *IncHashAggEntry) GetTime() time.Time

+ func (e *IncHashAggEntry) GetValue() interface{}

+ func (e *IncHashAggEntry) SetTime(time time.Time)

+ func (e *IncHashAggEntry) SetValue(value interface{})

+ func (e *IncHashAggEntry) Size() int64

+ type IncHashAggItem struct

+ func GetIncHashAggItem(queryID string, iterID int32) (*IncHashAggItem, bool)

+ func NewIncHashAggItem(iterID int32, chunks []Chunk) *IncHashAggItem

+ func (item *IncHashAggItem) AppendGroupIdx(groupIdx uint32)

+ func (item *IncHashAggItem) GetGroupIds(tag []byte) int

+ func (item *IncHashAggItem) Size() int64

+ func (item *IncHashAggItem) UpdateChunkAndIterID(iterID int32, chunks []Chunk)

+ type IncHashAggRule struct

+ func NewIncHashAggRule(description string) *IncHashAggRule

+ func (r *IncHashAggRule) Catagory() OptRuleCatagory

+ func (r *IncHashAggRule) Equals(rhs OptRule) bool

+ func (r *IncHashAggRule) OnMatch(call *OptRuleCall)

+ func (r *IncHashAggRule) ToString() string

+ type IncHashAggTransform struct

+ Inputs ChunkPorts

+ Outputs ChunkPorts

+ func NewIncHashAggTransform(inRowDataTypes []hybridqp.RowDataType, outRowDataTypes []hybridqp.RowDataType, ...) (*IncHashAggTransform, error)

+ func (trans *IncHashAggTransform) Close()

+ func (trans *IncHashAggTransform) Explain() []ValuePair

+ func (trans *IncHashAggTransform) GetIndex(t int64) int64

+ func (trans *IncHashAggTransform) GetInputNumber(port Port) int

+ func (trans *IncHashAggTransform) GetInputs() Ports

+ func (trans *IncHashAggTransform) GetOutputNumber(port Port) int

+ func (trans *IncHashAggTransform) GetOutputs() Ports

+ func (trans *IncHashAggTransform) Name() string

+ func (trans *IncHashAggTransform) Work(ctx context.Context) error

+ type IncHashAggTransformCreator struct

+ func (c *IncHashAggTransformCreator) Create(plan LogicalPlan, opt *query.ProcessorOptions) (Processor, error)

+ type IncQueryFinish struct

+ func (e *IncQueryFinish) Instance() transport.Codec

+ func (e *IncQueryFinish) Marshal(buf []byte) ([]byte, error)

+ func (e *IncQueryFinish) Size() int

+ func (e *IncQueryFinish) Unmarshal(buf []byte) error

+ type IndexFrags interface

+ AddFragCount func(int64)

+ AppendFragRanges func(...fragment.FragmentRanges)

+ AppendIndexes func(...interface{})

+ BasePath func() string

+ FileMode func() FileMode

+ FragCount func() int64

+ FragRanges func() []fragment.FragmentRanges

+ GetErr func() error

+ IndexCount func() int

+ Indexes func() interface{}

+ SetErr func(error)

+ Size func() int

type IndexScanExtraInfo

+ PtQuery *PtQuery

+ func (e *IndexScanExtraInfo) IsPtQuery() bool

+ func (e *IndexScanExtraInfo) Len() int

+ func (e *IndexScanExtraInfo) Next() *ShardInfo

type LogicalExchange

+ func (p *LogicalExchange) Schema() hybridqp.Catalog

+ type LogicalExchangeBase struct

+ func NewLogicalExchangeBase(eType ExchangeType, eRole ExchangeRole, eTraits []hybridqp.Trait) *LogicalExchangeBase

+ func (p *LogicalExchangeBase) ERole() ExchangeRole

+ func (p *LogicalExchangeBase) ETraits() []hybridqp.Trait

+ func (p *LogicalExchangeBase) EType() ExchangeType

+ func (p *LogicalExchangeBase) ToProducer()

type LogicalHashAgg

+ func (p *LogicalHashAgg) Schema() hybridqp.Catalog

+ type LogicalIncAgg struct

+ func NewLogicalIncAgg(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalIncAgg

+ func (p *LogicalIncAgg) Clone() hybridqp.QueryNode

+ func (p *LogicalIncAgg) CountToSum()

+ func (p *LogicalIncAgg) DeriveOperations()

+ func (p *LogicalIncAgg) Digest() string

+ func (p *LogicalIncAgg) Explain(writer LogicalPlanWriter)

+ func (p *LogicalIncAgg) ForwardCallArgs()

+ func (p *LogicalIncAgg) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ func (p *LogicalIncAgg) String() string

+ func (p *LogicalIncAgg) Type() string

+ type LogicalIncHashAgg struct

+ func NewLogicalIncHashAgg(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalIncHashAgg

+ func (p *LogicalIncHashAgg) Clone() hybridqp.QueryNode

+ func (p *LogicalIncHashAgg) CountToSum()

+ func (p *LogicalIncHashAgg) DeriveOperations()

+ func (p *LogicalIncHashAgg) Digest() string

+ func (p *LogicalIncHashAgg) Explain(writer LogicalPlanWriter)

+ func (p *LogicalIncHashAgg) ForwardCallArgs()

+ func (p *LogicalIncHashAgg) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ func (p *LogicalIncHashAgg) String() string

+ func (p *LogicalIncHashAgg) Type() string

type LogicalIndexScan

+ func (p *LogicalIndexScan) GetOneShardState() bool

+ func (p *LogicalIndexScan) SetOneShardState(enable bool)

type LogicalLimit

+ func (p *LogicalLimit) ExplainIterms(writer LogicalPlanWriter)

type LogicalPlanBuilderImpl

+ func (b *LogicalPlanBuilderImpl) CreateColStoreCursorPlan() (hybridqp.QueryNode, error)

+ func (b *LogicalPlanBuilderImpl) CreateColStoreReaderPlan(seriesPlan hybridqp.QueryNode) (hybridqp.QueryNode, error)

+ func (b *LogicalPlanBuilderImpl) CreatePartitionPlan(scanPlan hybridqp.QueryNode) (hybridqp.QueryNode, error)

+ func (b *LogicalPlanBuilderImpl) IncAgg() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) IncHashAgg() LogicalPlanBuilder

type MaterializeTransform

+ func (trans *MaterializeTransform) ResetTransparents()

+ type MultiMstReqs struct

+ func NewMultiMstReqs() *MultiMstReqs

type PlanTemplate

+ func (pp *PlanTemplate) GetLocalStorePlan() []hybridqp.QueryNode

+ func (pp *PlanTemplate) NewLocalStoreSqlPlanTemplate()

type PlanType

+ const NO_AGG_NO_GROUP_LIMIT

+ type PtQuery struct

+ PtID uint32

+ ShardInfos []ShardInfo

+ func UnmarshalPtQuerys(ptQuerys []*proto2.PtQuery) []PtQuery

type QuerySchema

+ func (qs *QuerySchema) CanSeqAggPushDown() bool

+ func (qs *QuerySchema) GetTimeRangeByTC() util.TimeRange

+ func (qs *QuerySchema) GetUnnests() influxql.Unnests

+ func (qs *QuerySchema) HasUnnests() bool

+ func (qs *QuerySchema) SetUnnests(unnests []*influxql.Unnest)

type RemoteQuery

+ PtQuerys []PtQuery

+ func (c *RemoteQuery) Empty() bool

+ func (c *RemoteQuery) HaveLocalMst() bool

+ func (c *RemoteQuery) Len() int

+ type ResultEval struct

+ func (re *ResultEval) IsNil(i int) bool

+ type ResultEvalPool struct

+ func NewResultEvalPool(len int) *ResultEvalPool

+ type ShardInfo struct

+ ID uint64

+ Path string

+ Version uint32

+ func UnmarshalShardInfos(shardInfos []*proto2.ShardInfo) []ShardInfo

type ShardsFragmentsGroups

+ func (fgs *ShardsFragmentsGroups) HasGroup() bool

+ func (fgs *ShardsFragmentsGroups) NextGroup() *ShardsFragmentsGroup

+ func (fgs *ShardsFragmentsGroups) PeekGroup() *ShardsFragmentsGroup

type SortTransform

+ func (trans *SortTransform) Release() error

type SparseIndexScanTransform

+ func (trans *SparseIndexScanTransform) Abort()

+ func (trans *SparseIndexScanTransform) IsSink() bool

v1.1.2

Oct 30, 2023

v1.1.1

Nov 7, 2023

Changes in this version

+ func NewCountOperator() aggOperator

+ func NewFirstBooleanOperator() aggOperator

+ func NewFirstFloatOperator() aggOperator

+ func NewFirstIntegerOperator() aggOperator

+ func NewFirstStringOperator() aggOperator

+ func NewLastBooleanOperator() aggOperator

+ func NewLastFloatOperator() aggOperator

+ func NewLastIntegerOperator() aggOperator

+ func NewLastStringOperator() aggOperator

+ func NewMaxFloatOperator() aggOperator

+ func NewMaxIntegerOperator() aggOperator

+ func NewMinFloatOperator() aggOperator

+ func NewMinIntegerOperator() aggOperator

+ func NewPercentileFloatOperator() aggOperator

+ func NewPercentileIntegerOperator() aggOperator

+ func NewSumFloatOperator() aggOperator

+ func NewSumIntegerOperator() aggOperator

type Bitmap

+ func (b *Bitmap) GetArray() []uint16

+ func (b *Bitmap) GetBit() []byte

+ func (b *Bitmap) GetLength() int

+ type HashMergeBooleanColumn struct

+ func (m *HashMergeBooleanColumn) AppendValues(col Column, start int, end int)

+ func (m *HashMergeBooleanColumn) SetOutPut(col Column)

+ type HashMergeColumn interface

+ AppendValues func(col Column, start int, end int)

+ SetOutPut func(col Column)

+ func NewHashMergeBooleanColumn() HashMergeColumn

+ func NewHashMergeFloatColumn() HashMergeColumn

+ func NewHashMergeIntegerColumn() HashMergeColumn

+ func NewHashMergeStringColumn() HashMergeColumn

+ type HashMergeFloatColumn struct

+ func (m *HashMergeFloatColumn) AppendValues(col Column, start int, end int)

+ func (m *HashMergeFloatColumn) SetOutPut(col Column)

+ type HashMergeIntegerColumn struct

+ func (m *HashMergeIntegerColumn) AppendValues(col Column, start int, end int)

+ func (m *HashMergeIntegerColumn) SetOutPut(col Column)

+ type HashMergeMsg struct

+ type HashMergeResult struct

+ func (mr *HashMergeResult) AppendResult(chunk Chunk, start int, end int)

+ type HashMergeStringColumn struct

+ func (m *HashMergeStringColumn) AppendValues(col Column, start int, end int)

+ func (m *HashMergeStringColumn) SetOutPut(col Column)

v1.1.0

Sep 28, 2023

Changes in this version

+ const BALANCED_DIFF

+ const DefaultTime

+ const HashAggTransformBufCap

+ const HashMergeTransformBufCap

+ const MessageEof

+ var GetPlanType func(hybridqp.Catalog, *influxql.SelectStatement) PlanType

+ var MatchPlanFunc []func(hybridqp.Catalog) bool

+ var OneShardStorePlanTemplate []*PlanTemplate

+ var PlanTypes []PlanType

+ var SqlPlanTemplate []*PlanTemplate

+ var StorePlanTemplate []*PlanTemplate

+ var TemplateSql []string = []string

+ func BuildInConditionPlan(ctx context.Context, qc query.LogicalPlanCreator, ...) (hybridqp.QueryNode, hybridqp.Catalog, error)

+ func GetPlanSliceByTree(plan hybridqp.QueryNode) []hybridqp.QueryNode

+ func GetPlanSliceByTreeDFS(plan hybridqp.QueryNode, dstPlan *[]hybridqp.QueryNode) error

+ func GetQuerySchemaLimit() int

+ func GetStorePlanTemplate(shardNum int, planType PlanType) []hybridqp.QueryNode

+ func MatchAggGroup(schema hybridqp.Catalog) bool

+ func MatchAggInterval(schema hybridqp.Catalog) bool

+ func MatchAggIntervalLimit(schema hybridqp.Catalog) bool

+ func MatchNoAggNoGroup(schema hybridqp.Catalog) bool

+ func NewAggFunc(aggType AggFuncType, fn NewAggOperator, inIdx int, outIdx int, p float64) *aggFunc

+ func NewBoolSortEle() sortEleMsg

+ func NewCountAggOperator() aggOperator

+ func NewCountFunc(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions) (*aggFunc, error)

+ func NewFirstAggOperator4Boolean() aggOperator

+ func NewFirstAggOperator4Float() aggOperator

+ func NewFirstAggOperator4Integer() aggOperator

+ func NewFirstAggOperator4String() aggOperator

+ func NewFirstFunc(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions) (*aggFunc, error)

+ func NewFloatSortEle() sortEleMsg

+ func NewIntegerSortEle() sortEleMsg

+ func NewLastAggOperator4Boolean() aggOperator

+ func NewLastAggOperator4Float() aggOperator

+ func NewLastAggOperator4Integer() aggOperator

+ func NewLastAggOperator4String() aggOperator

+ func NewLastFunc(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions) (*aggFunc, error)

+ func NewMaxAggOperator4Float() aggOperator

+ func NewMaxAggOperator4Integer() aggOperator

+ func NewMaxFunc(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions) (*aggFunc, error)

+ func NewMergeResultBooleanCol() mergeResultCol

+ func NewMergeResultFloatCol() mergeResultCol

+ func NewMergeResultIntegerCol() mergeResultCol

+ func NewMergeResultStringCol() mergeResultCol

+ func NewMinAggOperator4Float() aggOperator

+ func NewMinAggOperator4Integer() aggOperator

+ func NewMinFunc(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions) (*aggFunc, error)

+ func NewOneShardStorePlanTypePool(planType PlanType) []hybridqp.QueryNode

+ func NewPercentileAggOperator4Float() aggOperator

+ func NewPercentileAggOperator4Integer() aggOperator

+ func NewPercentileFunc(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions) (*aggFunc, error)

+ func NewPlanBySchemaAndSrcPlan(schema hybridqp.Catalog, srcPlan []hybridqp.QueryNode, eTrait []hybridqp.Trait) (hybridqp.QueryNode, error)

+ func NewSortPartition(i int, sortKeysIdxs []int, ascending []bool) *sortPartition

+ func NewSortRowMsg(eles []sortEleMsg) *sortRowMsg

+ func NewSqlPlanTypePool(planType PlanType) ([]hybridqp.QueryNode, error)

+ func NewStorePlanTypePool(planType PlanType) []hybridqp.QueryNode

+ func NewStringSortEle() sortEleMsg

+ func NewSumAggOperator4Float() aggOperator

+ func NewSumAggOperator4Integer() aggOperator

+ func NewSumFunc(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions) (*aggFunc, error)

+ func ReWriteArgs(best hybridqp.QueryNode)

+ func RebuildAggNodes(plan hybridqp.QueryNode)

+ func RebuildColumnStorePlan(plan hybridqp.QueryNode) []hybridqp.QueryNode

+ func RegistryReaderCreator(plan LogicalPlan, creator ReaderCreator) bool

+ func SetQuerySchemaLimit(limit int)

+ func ValidRpcMessageType(typ byte) bool

type Abort

+ QueryID uint64

+ type AggFuncType uint32

+ type AggOperatorMsgs struct

+ func NewAggOperatorMsgs(size int) *AggOperatorMsgs

+ func (a *AggOperatorMsgs) Alloc(size int) []*aggOperatorMsg

+ func (a *AggOperatorMsgs) Free()

+ type AggPushDownToColumnStoreReaderRule struct

+ func NewAggPushDownToColumnStoreReaderRule(description string) *AggPushDownToColumnStoreReaderRule

+ func (r *AggPushDownToColumnStoreReaderRule) Catagory() OptRuleCatagory

+ func (r *AggPushDownToColumnStoreReaderRule) Equals(rhs OptRule) bool

+ func (r *AggPushDownToColumnStoreReaderRule) OnMatch(call *OptRuleCall)

+ func (r *AggPushDownToColumnStoreReaderRule) ToString() string

+ type BaseMergeIterator struct

+ type BatchMPool struct

+ func NewBatchMPool(size int) *BatchMPool

+ func (b *BatchMPool) AllocBatchEndLocs() []int

+ func (b *BatchMPool) FreeBatchEndLocs(batchEndLocs []int)

type Chunk

+ AddDim func(...Column)

+ AddDims func([]string)

+ AppendIntervalIndexes func([]int)

+ AppendTimes func([]int64)

+ CopyByRowDataType func(c Chunk, fromRt hybridqp.RowDataType, dstRt hybridqp.RowDataType) error

+ Dim func(int) Column

+ Dims func() []Column

+ NewDims func(size int)

+ SetDim func(Column, int)

type ChunkBuilder

+ func (b *ChunkBuilder) SetDim(dimDataType hybridqp.RowDataType)

type ChunkImpl

+ func (c *ChunkImpl) AddDim(cols ...Column)

+ func (c *ChunkImpl) AddDims(dimsVals []string)

+ func (c *ChunkImpl) AppendIntervalIndexes(intervalIndex []int)

+ func (c *ChunkImpl) AppendTimes(ts []int64)

+ func (c *ChunkImpl) CopyByRowDataType(dst Chunk, fromRt hybridqp.RowDataType, dstRt hybridqp.RowDataType) error

+ func (c *ChunkImpl) Dim(i int) Column

+ func (c *ChunkImpl) Dims() []Column

+ func (c *ChunkImpl) NewDims(size int)

+ func (c *ChunkImpl) SetDim(col Column, i int)

type Column

+ AppendBooleanValue func(bool)

+ AppendColumnTime func(int64)

+ AppendFloatTuple func(floatTuple)

+ AppendFloatValue func(float64)

+ AppendIntegerValue func(int64)

+ AppendNotNil func()

+ AppendStringValue func(string)

+ StringValuesRangeV2 func(dst []string, start, end int) []string

+ StringValuesWithOffset func(start, end int, offsets []uint32) ([]byte, []uint32)

type ColumnImpl

+ func (c *ColumnImpl) AppendBooleanValue(value bool)

+ func (c *ColumnImpl) AppendColumnTime(value int64)

+ func (c *ColumnImpl) AppendFloatTuple(tuple floatTuple)

+ func (c *ColumnImpl) AppendFloatValue(value float64)

+ func (c *ColumnImpl) AppendIntegerValue(value int64)

+ func (c *ColumnImpl) AppendNotNil()

+ func (c *ColumnImpl) AppendStringValue(value string)

+ func (c *ColumnImpl) StringValuesRangeV2(dst []string, start, end int) []string

+ func (c *ColumnImpl) StringValuesWithOffset(start, end int, offsets []uint32) ([]byte, []uint32)

type ExchangeType

+ const SEGMENT_EXCHANGE

type ExecutorBuilder

+ func NewSparseIndexScanExecutorBuilder(frags *ShardsFragmentsGroups, info *IndexScanExtraInfo) *ExecutorBuilder

+ type FileFragment interface

+ AppendFragmentRange func(fragment.FragmentRanges)

+ CutTo func(num int64) FileFragment

+ FragmentCount func() int64

+ GetFile func() immutable.TSSPFile

+ GetFragmentRange func(int) *fragment.FragmentRange

+ GetFragmentRanges func() fragment.FragmentRanges

+ type FileFragmentImpl struct

+ func NewFileFragment(f immutable.TSSPFile, fr fragment.FragmentRanges, fc int64) *FileFragmentImpl

+ func (f *FileFragmentImpl) AppendFragmentRange(frs fragment.FragmentRanges)

+ func (f *FileFragmentImpl) CutTo(num int64) FileFragment

+ func (f *FileFragmentImpl) FragmentCount() int64

+ func (f *FileFragmentImpl) GetFile() immutable.TSSPFile

+ func (f *FileFragmentImpl) GetFragmentRange(i int) *fragment.FragmentRange

+ func (f *FileFragmentImpl) GetFragmentRanges() fragment.FragmentRanges

+ type FileFragments struct

+ FileMarks map[string]FileFragment

+ FragmentCount int64

+ func NewFileFragments() *FileFragments

+ func (fms *FileFragments) AddFileFragment(filePath string, fm FileFragment, fc int64)

+ type GroupKeysMPool struct

+ func NewGroupKeysPool(size int) *GroupKeysMPool

+ func (gkp *GroupKeysMPool) AllocGroupKeys(size int) [][]byte

+ func (gkp *GroupKeysMPool) AllocGroupTags(size int) []*ChunkTags

+ func (gkp *GroupKeysMPool) AllocValues(size int) []uint64

+ func (gkp *GroupKeysMPool) AllocZValues(size int) []int64

+ func (gkp *GroupKeysMPool) FreeGroupKeys(groupKeys [][]byte)

+ func (gkp *GroupKeysMPool) FreeGroupTags(groupTags []*ChunkTags)

+ func (gkp *GroupKeysMPool) FreeValues(values []uint64)

+ func (gkp *GroupKeysMPool) FreeZValue(spillState []int64)

+ type HashAggTransform struct

+ func NewHashAggTransform(inRowDataType, outRowDataType []hybridqp.RowDataType, ...) (*HashAggTransform, error)

+ func (trans *HashAggTransform) Close()

+ func (trans *HashAggTransform) Explain() []ValuePair

+ func (trans *HashAggTransform) GetFuncs() []aggFunc

+ func (trans *HashAggTransform) GetInputNumber(_ Port) int

+ func (trans *HashAggTransform) GetInputs() Ports

+ func (trans *HashAggTransform) GetOutputNumber(_ Port) int

+ func (trans *HashAggTransform) GetOutputs() Ports

+ func (trans *HashAggTransform) InitFuncs(inRowDataType, outRowDataType hybridqp.RowDataType, ...) error

+ func (trans *HashAggTransform) Name() string

+ func (trans *HashAggTransform) Work(ctx context.Context) error

+ type HashAggTransformCreator struct

+ func (c *HashAggTransformCreator) Create(plan LogicalPlan, _ *query.ProcessorOptions) (Processor, error)

+ type HashAggType uint32

+ const Fill

+ const Normal

+ type HashMergeTransform struct

+ func NewHashMergeHashTypeTransform(inRowDataType, outRowDataType []hybridqp.RowDataType, s *QuerySchema) (*HashMergeTransform, error)

+ func NewHashMergeStreamTypeTransform(inRowDataType, outRowDataType []hybridqp.RowDataType, s *QuerySchema) (*HashMergeTransform, error)

+ func NewHashMergeTransform(inRowDataType, outRowDataType []hybridqp.RowDataType, s *QuerySchema) (*HashMergeTransform, error)

+ func (trans *HashMergeTransform) Close()

+ func (trans *HashMergeTransform) Explain() []ValuePair

+ func (trans *HashMergeTransform) GetInputNumber(_ Port) int

+ func (trans *HashMergeTransform) GetInputs() Ports

+ func (trans *HashMergeTransform) GetOutputNumber(_ Port) int

+ func (trans *HashMergeTransform) GetOutputs() Ports

+ func (trans *HashMergeTransform) Name() string

+ func (trans *HashMergeTransform) Work(ctx context.Context) error

+ type HashMergeTransformCreator struct

+ func (c *HashMergeTransformCreator) Create(plan LogicalPlan, opt query.ProcessorOptions) (Processor, error)

+ type HashMergeType uint32

+ const Hash

+ const Stream

type HeuVertex

+ func (v *HeuVertex) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type HttpChunkSender

+ func (w *HttpChunkSender) Release()

type HttpSenderTransform

+ func (trans *HttpSenderTransform) Release() error

type IndexScanTransform

+ func (trans *IndexScanTransform) CursorsClose(plan hybridqp.QueryNode)

+ func (trans *IndexScanTransform) SetIndexScanErr(err bool)

+ type IntervalKeysMPool struct

+ func NewIntervalKeysMpool(size int) *IntervalKeysMPool

+ func (gkp *IntervalKeysMPool) AllocIntervalKeys(size int) []int64

+ func (gkp *IntervalKeysMPool) AllocValues(size int) []uint64

+ func (gkp *IntervalKeysMPool) FreeIntervalKeys(intervalKeys []int64)

+ func (gkp *IntervalKeysMPool) FreeValues(values []uint64)

type LogicalAggregate

+ func (p *LogicalAggregate) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalAlign

+ func (p *LogicalAlign) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ type LogicalColumnStoreReader struct

+ func NewLogicalColumnStoreReader(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalColumnStoreReader

+ func (p *LogicalColumnStoreReader) Clone() hybridqp.QueryNode

+ func (p *LogicalColumnStoreReader) DeriveOperations()

+ func (p *LogicalColumnStoreReader) Digest() string

+ func (p *LogicalColumnStoreReader) Explain(writer LogicalPlanWriter)

+ func (p *LogicalColumnStoreReader) ExplainIterms(writer LogicalPlanWriter)

+ func (p *LogicalColumnStoreReader) LogicPlanType() internal.LogicPlanType

+ func (p *LogicalColumnStoreReader) MstName() string

+ func (p *LogicalColumnStoreReader) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ func (p *LogicalColumnStoreReader) String() string

+ func (p *LogicalColumnStoreReader) Type() string

type LogicalDedupe

+ func (p *LogicalDedupe) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalDummyShard

+ func (p *LogicalDummyShard) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalExchange

+ func (p *LogicalExchange) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalFill

+ func (p *LogicalFill) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalFilter

+ func (p *LogicalFilter) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalFilterBlank

+ func (p *LogicalFilterBlank) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalFullJoin

+ func (p *LogicalFullJoin) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalGroupBy

+ func (p *LogicalGroupBy) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ type LogicalHashAgg struct

+ func NewLogicalHashAgg(input hybridqp.QueryNode, schema hybridqp.Catalog, eType ExchangeType, ...) *LogicalHashAgg

+ func (p *LogicalHashAgg) AddTrait(trait interface{})

+ func (p *LogicalHashAgg) Clone() hybridqp.QueryNode

+ func (p *LogicalHashAgg) CountToSum()

+ func (p *LogicalHashAgg) DeriveOperations()

+ func (p *LogicalHashAgg) Digest() string

+ func (p *LogicalHashAgg) Explain(writer LogicalPlanWriter)

+ func (p *LogicalHashAgg) ForwardCallArgs()

+ func (p *LogicalHashAgg) LogicPlanType() internal.LogicPlanType

+ func (p *LogicalHashAgg) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ func (p *LogicalHashAgg) String() string

+ func (p *LogicalHashAgg) Type() string

+ type LogicalHashMerge struct

+ func NewLogicalHashMerge(input hybridqp.QueryNode, schema hybridqp.Catalog, eType ExchangeType, ...) *LogicalHashMerge

+ func (p *LogicalHashMerge) AddTrait(trait interface{})

+ func (p *LogicalHashMerge) Clone() hybridqp.QueryNode

+ func (p *LogicalHashMerge) DeriveOperations()

+ func (p *LogicalHashMerge) Digest() string

+ func (p *LogicalHashMerge) Explain(writer LogicalPlanWriter)

+ func (p *LogicalHashMerge) ExplainIterms(writer LogicalPlanWriter)

+ func (p *LogicalHashMerge) LogicPlanType() internal.LogicPlanType

+ func (p *LogicalHashMerge) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ func (p *LogicalHashMerge) String() string

+ func (p *LogicalHashMerge) Type() string

type LogicalHoltWinters

+ func (p *LogicalHoltWinters) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalHttpSender

+ func (p *LogicalHttpSender) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalHttpSenderHint

+ func (p *LogicalHttpSenderHint) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalIndexScan

+ func (p *LogicalIndexScan) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalInterval

+ func (p *LogicalInterval) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ type LogicalJoin struct

+ func NewLogicalJoin(inputs []hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalJoin

+ func (p *LogicalJoin) Clone() hybridqp.QueryNode

+ func (p *LogicalJoin) DeriveOperations()

+ func (p *LogicalJoin) Digest() string

+ func (p *LogicalJoin) Explain(writer LogicalPlanWriter)

+ func (p *LogicalJoin) LogicPlanType() internal.LogicPlanType

+ func (p *LogicalJoin) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ func (p *LogicalJoin) String() string

+ func (p *LogicalJoin) Type() string

type LogicalLimit

+ func (p *LogicalLimit) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalMerge

+ func (p *LogicalMerge) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalMst

+ func (p *LogicalMst) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalOrderBy

+ func (p *LogicalOrderBy) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalPlanBase

+ func (p *LogicalPlanBase) InitRef(input hybridqp.QueryNode)

type LogicalPlanBuilder

+ CreateSegmentPlan func(schema hybridqp.Catalog) (hybridqp.QueryNode, error)

type LogicalPlanBuilderImpl

+ func (b *LogicalPlanBuilderImpl) CreateSegmentPlan(schema hybridqp.Catalog) (hybridqp.QueryNode, error)

+ func (b *LogicalPlanBuilderImpl) CreateSparseIndexScanPlan(plan hybridqp.QueryNode) (hybridqp.QueryNode, error)

+ func (b *LogicalPlanBuilderImpl) HashMerge(eType ExchangeType, eTraits []hybridqp.Trait) LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) Sort() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) SparseIndexScan() LogicalPlanBuilder

type LogicalPlanSingle

+ func (p *LogicalPlanSingle) SetHoltWintersType(setOps bool, fields influxql.Fields)

type LogicalProject

+ func (p *LogicalProject) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalReader

+ func (p *LogicalReader) GetOneReaderState() bool

+ func (p *LogicalReader) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ func (p *LogicalReader) SetOneReaderState(state bool)

type LogicalSequenceAggregate

+ func (p *LogicalSequenceAggregate) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalSeries

+ func (p *LogicalSeries) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalSlidingWindow

+ func (p *LogicalSlidingWindow) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ type LogicalSort struct

+ func NewLogicalSort(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalSort

+ func (p *LogicalSort) Clone() hybridqp.QueryNode

+ func (p *LogicalSort) DeriveOperations()

+ func (p *LogicalSort) Digest() string

+ func (p *LogicalSort) Explain(writer LogicalPlanWriter)

+ func (p *LogicalSort) ExplainIterms(writer LogicalPlanWriter)

+ func (p *LogicalSort) LogicPlanType() internal.LogicPlanType

+ func (p *LogicalSort) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ func (p *LogicalSort) String() string

+ func (p *LogicalSort) Type() string

type LogicalSortAppend

+ func (p *LogicalSortAppend) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalSortMerge

+ func (p *LogicalSortMerge) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ type LogicalSparseIndexScan struct

+ func NewLogicalSparseIndexScan(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalSparseIndexScan

+ func (p *LogicalSparseIndexScan) Clone() hybridqp.QueryNode

+ func (p *LogicalSparseIndexScan) DeriveOperations()

+ func (p *LogicalSparseIndexScan) Digest() string

+ func (p *LogicalSparseIndexScan) Explain(writer LogicalPlanWriter)

+ func (p *LogicalSparseIndexScan) LogicPlanType() internal.LogicPlanType

+ func (p *LogicalSparseIndexScan) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ func (p *LogicalSparseIndexScan) String() string

+ func (p *LogicalSparseIndexScan) Type() string

type LogicalSplitGroup

+ func (p *LogicalSplitGroup) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalSubQuery

+ func (p *LogicalSubQuery) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalTSSPScan

+ func (p *LogicalTSSPScan) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalTagSubset

+ func (p *LogicalTagSubset) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalTarget

+ func (p *LogicalTarget) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

type LogicalWriteIntoStorage

+ func (p *LogicalWriteIntoStorage) New(inputs []hybridqp.QueryNode, schema hybridqp.Catalog, eTrait []hybridqp.Trait) hybridqp.QueryNode

+ type NewAggOperator func() aggOperator

+ type PlanTemplate struct

+ func NewOneShardStorePlanTemplate(t PlanType) *PlanTemplate

+ func NewSqlPlanTemplate(t PlanType) *PlanTemplate

+ func NewStorePlanTemplate(t PlanType) *PlanTemplate

+ func (pp *PlanTemplate) GetPlan() []hybridqp.QueryNode

+ type PlanType uint32

+ const AGG_GROUP

+ const AGG_INTERVAL

+ const AGG_INTERVAL_LIMIT

+ const NO_AGG_NO_GROUP

+ const UNKNOWN

+ func NilGetPlanType(schema hybridqp.Catalog, stmt *influxql.SelectStatement) PlanType

+ func NormalGetPlanType(schema hybridqp.Catalog, stmt *influxql.SelectStatement) PlanType

+ type PlanTypeInitShard struct

+ func NewPlanTypeInitShardGroup() *PlanTypeInitShard

+ func (pts *PlanTypeInitShard) Close() error

+ func (pts *PlanTypeInitShard) CreateLogicalPlan(ctx context.Context, sources influxql.Sources, schema hybridqp.Catalog) (hybridqp.QueryNode, error)

+ func (pts *PlanTypeInitShard) FieldDimensions(m *influxql.Measurement) (map[string]influxql.DataType, map[string]struct{}, *influxql.Schema, error)

+ func (pts *PlanTypeInitShard) GetETraits(ctx context.Context, sources influxql.Sources, schema hybridqp.Catalog) ([]hybridqp.Trait, error)

+ func (pts *PlanTypeInitShard) GetSeriesKey() []byte

+ func (pts *PlanTypeInitShard) GetSources(sources influxql.Sources) influxql.Sources

+ func (pts *PlanTypeInitShard) LogicalPlanCost(source *influxql.Measurement, opt query.ProcessorOptions) (hybridqp.LogicalPlanCost, error)

+ func (pts *PlanTypeInitShard) MapType(m *influxql.Measurement, field string) influxql.DataType

+ func (pts *PlanTypeInitShard) MapTypeBatch(m *influxql.Measurement, fields map[string]*influxql.FieldNameSpace, ...) error

+ type PlanTypeInitShardMapper struct

+ func NewPlanTypeInitShardMapper() *PlanTypeInitShardMapper

+ func (pts *PlanTypeInitShardMapper) Close() error

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

type QuerySchema

+ func (qs *QuerySchema) GetPlanType() PlanType

+ func (qs *QuerySchema) GetSortFields() influxql.SortFields

+ func (qs *QuerySchema) HasOptimizeCall() bool

+ func (qs *QuerySchema) HasRowCount() bool

+ func (qs *QuerySchema) HasSort() bool

+ func (qs *QuerySchema) IsHoltWinters(val string) bool

+ func (qs *QuerySchema) SetFill(fill influxql.FillOption)

+ func (qs *QuerySchema) SetPlanType(planType PlanType)

type RPCClient

+ func (c *RPCClient) Init(ctx context.Context, queryNode []byte)

+ type ReaderCreator interface

+ CreateReader func(outSchema hybridqp.RowDataType, ops []hybridqp.ExprOptions, ...) (Processor, error)

+ type ReaderCreatorFactory struct

+ func GetReaderFactoryInstance() *ReaderCreatorFactory

+ func NewReaderCreatorFactory() *ReaderCreatorFactory

+ func (r *ReaderCreatorFactory) Add(name string, creator ReaderCreator)

+ func (r *ReaderCreatorFactory) Find(name string) (ReaderCreator, bool)

+ type RowsGenerator struct

+ func NewRowsGenerator() *RowsGenerator

+ func (g *RowsGenerator) Generate(chunk Chunk, loc *time.Location) models.Rows

+ func (g *RowsGenerator) GetColValue(col2 Column, idx int) interface{}

+ func (g *RowsGenerator) Release()

+ func (g *RowsGenerator) Reset()

type RuleInstruction

+ func (g *RuleInstruction) SkippingGroup(schema hybridqp.Catalog) bool

+ type ShardFileFragment struct

+ func NewShardFileFragment(shardId uint64, item FileFragment) *ShardFileFragment

+ type ShardsFragments map[uint64]*FileFragments

+ func NewShardsFragments() ShardsFragments

+ func (sfs *ShardsFragments) String() string

+ type ShardsFragmentsGroup struct

+ func NewShardsFragmentsGroup(frags ShardsFragments, fragmentCount int64) *ShardsFragmentsGroup

+ func (sfg *ShardsFragmentsGroup) GetFragmentCount() int64

+ func (sfg *ShardsFragmentsGroup) GetFrags() ShardsFragments

+ func (sfg *ShardsFragmentsGroup) MoveTo(des *ShardsFragmentsGroup, id uint64, filePath string)

+ func (sfg *ShardsFragmentsGroup) MoveToFileNotExist(des *ShardsFragmentsGroup)

+ func (sfg *ShardsFragmentsGroup) SearchAndMoveExistFile(des *ShardsFragmentsGroup)

+ type ShardsFragmentsGroups struct

+ Items []*ShardsFragmentsGroup

+ func DistributeFragments(frags ShardsFragments, parallel int) (*ShardsFragmentsGroups, error)

+ func DistributeFragmentsV2(frags ShardsFragments, parallel int) (*ShardsFragmentsGroups, error)

+ func NewShardsFragmentsGroups(parallel int) *ShardsFragmentsGroups

+ func (fgs *ShardsFragmentsGroups) Balance()

+ func (fgs *ShardsFragmentsGroups) Len() int

+ func (fgs *ShardsFragmentsGroups) Less(i, j int) bool

+ func (fgs *ShardsFragmentsGroups) MoveFrags(from, to int)

+ func (fgs *ShardsFragmentsGroups) Pop() interface{}

+ func (fgs *ShardsFragmentsGroups) Push(x interface{})

+ func (fgs *ShardsFragmentsGroups) String() string

+ func (fgs *ShardsFragmentsGroups) Swap(i, j int)

+ type SortTransform struct

+ func NewSortTransform(inRowDataType, outRowDataType []hybridqp.RowDataType, s *QuerySchema, ...) (*SortTransform, error)

+ func (trans *SortTransform) Close()

+ func (trans *SortTransform) Explain() []ValuePair

+ func (trans *SortTransform) GetInputNumber(_ Port) int

+ func (trans *SortTransform) GetInputs() Ports

+ func (trans *SortTransform) GetOutputNumber(_ Port) int

+ func (trans *SortTransform) GetOutputs() Ports

+ func (trans *SortTransform) Name() string

+ func (trans *SortTransform) Work(ctx context.Context) error

+ type SortTransformCreator struct

+ func (c *SortTransformCreator) Create(plan LogicalPlan, _ *query.ProcessorOptions) (Processor, error)

+ type SparseIndexScanTransform struct

+ func NewSparseIndexScanTransform(inRowDataType hybridqp.RowDataType, node hybridqp.QueryNode, ...) *SparseIndexScanTransform

+ func (trans *SparseIndexScanTransform) Close()

+ func (trans *SparseIndexScanTransform) Counting(ctx context.Context)

+ func (trans *SparseIndexScanTransform) Explain() []ValuePair

+ func (trans *SparseIndexScanTransform) GetInputNumber(_ Port) int

+ func (trans *SparseIndexScanTransform) GetInputs() Ports

+ func (trans *SparseIndexScanTransform) GetOutputNumber(_ Port) int

+ func (trans *SparseIndexScanTransform) GetOutputs() Ports

+ func (trans *SparseIndexScanTransform) Name() string

+ func (trans *SparseIndexScanTransform) Release() error

+ func (trans *SparseIndexScanTransform) Running(ctx context.Context)

+ func (trans *SparseIndexScanTransform) Work(ctx context.Context) error

+ func (trans *SparseIndexScanTransform) WorkHelper(ctx context.Context) error

+ type SparseIndexScanTransformCreator struct

+ func (c *SparseIndexScanTransformCreator) Create(plan LogicalPlan, _ *query.ProcessorOptions) (Processor, error)

+ type TimeFuncState uint32

v1.1.0-rc1

Aug 31, 2023

v1.0.1

Mar 29, 2023

Changes in this version

type BaseProcessor

+ func (bp *BaseProcessor) Abort()

type IndexScanTransform

+ func (trans *IndexScanTransform) Abort()

+ func (trans *IndexScanTransform) FreeResFromAllocator()

+ func (trans *IndexScanTransform) GetResFromAllocator()

type Processor

+ Abort func()

type SeriesRecord

+ func (r *SeriesRecord) GetTr() *record.TimeRange

+ func (r *SeriesRecord) SetRec(re *record.Record)

v1.0.0

Feb 23, 2023

Changes in this version

+ const DefaultClusterNum

+ const MaxClusterNum

+ const OGSketchInsert

+ const OGSketchMerge

+ const OGSketchPercentile

+ const PercentileApprox

+ const PercentileOGSketch

+ const RESULT_NAME

+ const UDAFMaxRow

+ var IgnoreEmptyTag = false

+ var OptimizeAgg = map[string]bool

+ func AddRule(mapDescToRule map[string]OptRule, rule OptRule) (bool, map[string]OptRule)

+ func AdjustNils(dst Column, src Column)

+ func AppendRowValue(column Column, value interface{})

+ func BuildHeuristicPlanner() hybridqp.Planner

+ func BuildHeuristicPlannerForStore() hybridqp.Planner

+ func ChunkToArrowRecords(chunks []Chunk, taskId string, args []influxql.Expr) ([]array.Record, *errno.Error)

+ func CopyArrowRecordToChunk(r array.Record, c Chunk, fields map[string]struct{}) *errno.Error

+ func GetFieldInfo(chunks []Chunk) (map[string]map[string]*fieldInfo, *errno.Error)

+ func GetInnerDimensions(outer, inner []string) []string

+ func InitMstName(item *AppendHeapItems) string

+ func Marshal(plan LogicalPlaner, extMarshal func(pb *internal.QueryNode), ...) ([]byte, error)

+ func MarshalBinary(q hybridqp.QueryNode) ([]byte, error)

+ func NewHoltWintersReducer(h, m int, includeFitData bool, interval time.Duration) *holtWintersReducer

+ func NewfloatTuple(tuple []float64) *floatTuple

+ func TransMath(c *influxql.Call) (func(dst Column, src Chunk, index []int), error)

+ func TransparentForwardBoolean(dst Column, src Chunk, index []int)

+ func TransparentForwardFloat(dst Column, src Chunk, index []int)

+ func TransparentForwardInteger(dst Column, src Chunk, index []int)

+ func TransparentForwardString(dst Column, src Chunk, index []int)

+ func UnmarshalBinary(buf []byte, schema hybridqp.Catalog) (hybridqp.QueryNode, error)

+ func UnmarshalBinaryNode(pb *internal.QueryNode, schema hybridqp.Catalog) (error, hybridqp.QueryNode)

+ type AggLevel uint8

+ const MiddleLevel

+ const SinkLevel

+ const SourceLevel

+ const UnknownLevel

type AppendHeapItems

+ func (h *AppendHeapItems) GetBreakPoint() BaseBreakPoint

+ func (h *AppendHeapItems) GetOption() *query.ProcessorOptions

+ type BaseBreakPoint interface

+ type BaseHeapItems interface

+ GetBreakPoint func() BaseBreakPoint

+ GetOption func() *query.ProcessorOptions

+ Len func() int

+ Less func(i, j int) bool

+ Pop func() interface{}

+ Push func(x interface{})

+ Swap func(i, j int)

+ type BlockChunkPool struct

+ func NewBlockChunkPool(chunkNum int, chunkBuilder *ChunkBuilder) *BlockChunkPool

+ func (cp *BlockChunkPool) Get() Chunk

+ func (cp *BlockChunkPool) Put(c Chunk)

+ func (cp *BlockChunkPool) Release()

+ type BooleanFieldValuer struct

+ func (valuer *BooleanFieldValuer) At(col Column, pos int, field *influx.Field) bool

+ type CONTEXT_IDENTIFIER int

+ const WRITER_CONTEXT

type Chunk

+ CopyTo func(Chunk)

+ CreatePointRowIterator func(string, *FieldsValuer) PointRowIterator

+ GetRecord func() *record.Record

type ChunkImpl

+ func (c *ChunkImpl) CopyTo(dstChunk Chunk)

+ func (c *ChunkImpl) CreatePointRowIterator(name string, valuer *FieldsValuer) PointRowIterator

+ func (c *ChunkImpl) GetRecord() *record.Record

+ type ChunkIterator struct

+ func NewChunkIteratorFromValuer(chunk *ChunkImpl, name string, valuer *FieldsValuer) *ChunkIterator

+ func (iter *ChunkIterator) GetNext(row *influx.Row, tuple *TargetTuple)

+ func (iter *ChunkIterator) HasMore() bool

type ChunkPort

+ func (p *ChunkPort) ConnectNoneCache(to Port)

type ChunkTags

+ func NewChunkTagsByTagKVs(k []string, v []string) *ChunkTags

+ func (c *ChunkTags) GetOffsets() []uint16

+ func (ct *ChunkTags) PointTags() influx.PointTags

+ type Cluster struct

+ Mean float64

+ Weight float64

+ func NewCluster() *Cluster

+ func (c *Cluster) Reset()

+ func (c *Cluster) Set(m, w float64)

+ type ClusterPool struct

+ func NewClusterPool() *ClusterPool

+ func (p *ClusterPool) Get() *Cluster

+ func (p *ClusterPool) Put(cluster *Cluster)

+ type ClusterSet []Cluster

+ func (l ClusterSet) Len() int

+ func (l ClusterSet) Less(i, j int) bool

+ func (l ClusterSet) Swap(i, j int)

type Column

+ AppendFloatTuples func(...floatTuple)

+ FloatTuple func(int) floatTuple

+ FloatTuples func() []floatTuple

+ SetFloatTuples func([]floatTuple)

type ColumnImpl

+ func (c *ColumnImpl) AppendFloatTuples(tuples ...floatTuple)

+ func (c *ColumnImpl) FloatTuple(idx int) floatTuple

+ func (c *ColumnImpl) FloatTuples() []floatTuple

+ func (c *ColumnImpl) SetFloatTuples(tuples []floatTuple)

+ type DeleteClusterSet map[float64]float64

+ type DownSampleState struct

+ func NewDownSampleState(taskID int, err error, newFiles []immutable.TSSPFile) *DownSampleState

+ func (p *DownSampleState) GetErr() error

+ func (p *DownSampleState) GetNewFiles() []immutable.TSSPFile

+ func (p *DownSampleState) GetTaskID() int

+ type DownSampleStatePort struct

+ OrigiState chan *DownSampleState

+ Redirected bool

+ RowDataType hybridqp.RowDataType

+ State chan *DownSampleState

+ func NewDownSampleStatePort(rowDataType hybridqp.RowDataType) *DownSampleStatePort

+ func (p *DownSampleStatePort) Close()

+ func (p *DownSampleStatePort) Connect(to Port)

+ func (p *DownSampleStatePort) ConnectStateReserve(to Port)

+ func (p *DownSampleStatePort) ConnectionId() uintptr

+ func (p *DownSampleStatePort) Equal(to Port) bool

+ func (p *DownSampleStatePort) Redirect(to Port)

+ func (p *DownSampleStatePort) Release()

type ExchangeType

+ const SINGLE_SHARD_EXCHANGE

type ExecutorBuilder

+ func (builder *ExecutorBuilder) SetInfo(info *IndexScanExtraInfo)

+ type FieldValuer interface

+ At func(Column, int, *influx.Field) bool

+ func NewFieldValuer(ref *influxql.VarRef) (FieldValuer, error)

+ type FieldsValuer struct

+ func NewFieldsValuer(rdt hybridqp.RowDataType) (*FieldsValuer, error)

+ func (valuer *FieldsValuer) At(chunk Chunk, pos int, tuple *TargetTuple)

+ type FloatFieldValuer struct

+ func (valuer *FloatFieldValuer) At(col Column, pos int, field *influx.Field) bool

+ type FloatOGSketchInsertItem struct

+ func NewFloatOGSketchInsertIem(isSingleCall bool, inOrdinal, outOrdinal, clusterNum int, percentile float64) *FloatOGSketchInsertItem

+ func (o *FloatOGSketchInsertItem) IsNil() bool

+ func (o *FloatOGSketchInsertItem) Reset()

+ func (o *FloatOGSketchInsertItem) UpdateCluster(inChunk Chunk, start, end int)

+ func (o *FloatOGSketchInsertItem) WriteResult(outChunk Chunk, time int64)

+ type FloatOGSketchPercentileItem struct

+ func NewFloatOGSketchPercentileItem(isSingleCall bool, inOrdinal, outOrdinal, clusterNum int, percentile float64) *FloatOGSketchPercentileItem

+ func (o *FloatOGSketchPercentileItem) IsNil() bool

+ func (o *FloatOGSketchPercentileItem) Reset()

+ func (o *FloatOGSketchPercentileItem) UpdateCluster(inChunk Chunk, start, end int)

+ func (o *FloatOGSketchPercentileItem) WriteResult(outChunk Chunk, time int64)

+ type FloatPercentileApproxItem struct

+ func NewFloatPercentileApproxItem(isSingleCall bool, inOrdinal, outOrdinal, clusterNum int, percentile float64) *FloatPercentileApproxItem

+ func (o *FloatPercentileApproxItem) IsNil() bool

+ func (o *FloatPercentileApproxItem) Reset()

+ func (o *FloatPercentileApproxItem) UpdateCluster(inChunk Chunk, start, end int)

+ func (o *FloatPercentileApproxItem) WriteResult(outChunk Chunk, time int64)

+ type FloatTupleMergeIterator struct

+ func NewFloatTupleMergeIterator() *FloatTupleMergeIterator

+ func (f *FloatTupleMergeIterator) Next(endpoint *IteratorEndpoint, params *IteratorParams)

+ type FullJoinTransform struct

+ func NewFullJoinTransform(inRowDataTypes []hybridqp.RowDataType, outRowDataType hybridqp.RowDataType, ...) (*FullJoinTransform, error)

+ func (trans *FullJoinTransform) Close()

+ func (trans *FullJoinTransform) Explain() []ValuePair

+ func (trans *FullJoinTransform) GetInputNumber(_ Port) int

+ func (trans *FullJoinTransform) GetInputs() Ports

+ func (trans *FullJoinTransform) GetOutputNumber(_ Port) int

+ func (trans *FullJoinTransform) GetOutputs() Ports

+ func (trans *FullJoinTransform) Name() string

+ func (trans *FullJoinTransform) NewChunkElem(chunk Chunk, seriesKeyLoc int, seriesValLoc int) *chunkElem

+ func (trans *FullJoinTransform) SendChunk()

+ func (trans *FullJoinTransform) Work(ctx context.Context) error

+ type FullJoinTransformCreator struct

+ func (c *FullJoinTransformCreator) Create(plan LogicalPlan, opt query.ProcessorOptions) (Processor, error)

type HeapItems

+ func (h *HeapItems) GetOption() *query.ProcessorOptions

+ type HoltWintersTransform struct

+ Input ChunkPort

+ Output ChunkPort

+ func NewHoltWintersTransform(inRowDataType, outRowDataType hybridqp.RowDataType, opt query.ProcessorOptions, ...) (*HoltWintersTransform, error)

+ func (trans *HoltWintersTransform) Close()

+ func (trans *HoltWintersTransform) Explain() []ValuePair

+ func (trans *HoltWintersTransform) GetInputNumber(port Port) int

+ func (trans *HoltWintersTransform) GetInputs() Ports

+ func (trans *HoltWintersTransform) GetOutputNumber(port Port) int

+ func (trans *HoltWintersTransform) GetOutputs() Ports

+ func (trans *HoltWintersTransform) Name() string

+ func (trans *HoltWintersTransform) Work(ctx context.Context) error

+ type HoltWintersTransformCreator struct

+ func (c *HoltWintersTransformCreator) Create(plan LogicalPlan, opt query.ProcessorOptions) (Processor, error)

type IndexScanTransform

+ func (trans *IndexScanTransform) BuildDownSamplePlan(s hybridqp.Catalog) (hybridqp.QueryNode, error)

+ func (trans *IndexScanTransform) BuildDownSampleSchema(schema hybridqp.Catalog) *QuerySchema

+ func (trans *IndexScanTransform) BuildPlan(downSampleLevel int) (*QuerySchema, hybridqp.QueryNode, error)

+ func (trans *IndexScanTransform) CanDownSampleRewrite(downSampleLevel int) bool

+ func (trans *IndexScanTransform) IsSink() bool

+ func (trans *IndexScanTransform) RewriteChunk(c Chunk) Chunk

+ func (trans *IndexScanTransform) Running(ctx context.Context)

+ func (trans *IndexScanTransform) SetDownSampleLevel(l int)

+ func (trans *IndexScanTransform) SetPipelineExecutor(exec *PipelineExecutor)

+ func (trans *IndexScanTransform) WorkHelper(ctx context.Context) error

+ type IntegerFieldValuer struct

+ func (valuer *IntegerFieldValuer) At(col Column, pos int, field *influx.Field) bool

+ type IntegerOGSketchInsertItem struct

+ func NewIntegerOGSketchInsertIem(isSingleCall bool, inOrdinal, outOrdinal, clusterNum int, percentile float64) *IntegerOGSketchInsertItem

+ func (o *IntegerOGSketchInsertItem) IsNil() bool

+ func (o *IntegerOGSketchInsertItem) Reset()

+ func (o *IntegerOGSketchInsertItem) UpdateCluster(inChunk Chunk, start, end int)

+ func (o *IntegerOGSketchInsertItem) WriteResult(outChunk Chunk, time int64)

+ type IntegerOGSketchPercentileItem struct

+ func NewIntegerOGSketchPercentileItem(isSingleCall bool, inOrdinal, outOrdinal, clusterNum int, percentile float64) *IntegerOGSketchPercentileItem

+ func (o *IntegerOGSketchPercentileItem) IsNil() bool

+ func (o *IntegerOGSketchPercentileItem) Reset()

+ func (o *IntegerOGSketchPercentileItem) UpdateCluster(inChunk Chunk, start, end int)

+ func (o *IntegerOGSketchPercentileItem) WriteResult(outChunk Chunk, time int64)

+ type IntegerPercentileApproxItem struct

+ func NewIntegerPercentileApproxItem(isSingleCall bool, inOrdinal, outOrdinal, clusterNum int, percentile float64) *IntegerPercentileApproxItem

+ func (o *IntegerPercentileApproxItem) IsNil() bool

+ func (o *IntegerPercentileApproxItem) Reset()

+ func (o *IntegerPercentileApproxItem) UpdateCluster(inChunk Chunk, start, end int)

+ func (o *IntegerPercentileApproxItem) WriteResult(outChunk Chunk, time int64)

type IteratorParams

+ func (i *IteratorParams) GetErr() error

type LogicalAggregate

+ func (p *LogicalAggregate) LogicPlanType() internal.LogicPlanType

type LogicalAlign

+ func (p *LogicalAlign) LogicPlanType() internal.LogicPlanType

type LogicalDedupe

+ func (p *LogicalDedupe) DeriveOperations()

+ func (p *LogicalDedupe) LogicPlanType() internal.LogicPlanType

type LogicalDummyShard

+ func (p *LogicalDummyShard) LogicPlanType() internal.LogicPlanType

type LogicalExchange

+ func (p *LogicalExchange) LogicPlanType() internal.LogicPlanType

type LogicalFill

+ func (p *LogicalFill) LogicPlanType() internal.LogicPlanType

type LogicalFilter

+ func (p *LogicalFilter) LogicPlanType() internal.LogicPlanType

type LogicalFilterBlank

+ func (p *LogicalFilterBlank) LogicPlanType() internal.LogicPlanType

+ type LogicalFullJoin struct

+ func NewLogicalFullJoin(left hybridqp.QueryNode, right hybridqp.QueryNode, condition influxql.Expr, ...) *LogicalFullJoin

+ func (p *LogicalFullJoin) Children() []hybridqp.QueryNode

+ func (p *LogicalFullJoin) Clone() hybridqp.QueryNode

+ func (p *LogicalFullJoin) DeriveOperations()

+ func (p *LogicalFullJoin) Digest() string

+ func (p *LogicalFullJoin) Explain(writer LogicalPlanWriter)

+ func (p *LogicalFullJoin) LogicPlanType() internal.LogicPlanType

+ func (p *LogicalFullJoin) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalFullJoin) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalFullJoin) String() string

+ func (p *LogicalFullJoin) Type() string

type LogicalGroupBy

+ func (p *LogicalGroupBy) LogicPlanType() internal.LogicPlanType

+ type LogicalHoltWinters struct

+ func NewLogicalHoltWinters(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalHoltWinters

+ func (p *LogicalHoltWinters) Clone() hybridqp.QueryNode

+ func (p *LogicalHoltWinters) DeriveOperations()

+ func (p *LogicalHoltWinters) Digest() string

+ func (p *LogicalHoltWinters) Explain(writer LogicalPlanWriter)

+ func (p *LogicalHoltWinters) LogicPlanType() internal.LogicPlanType

+ func (p *LogicalHoltWinters) String() string

+ func (p *LogicalHoltWinters) Type() string

type LogicalHttpSender

+ func (p *LogicalHttpSender) LogicPlanType() internal.LogicPlanType

type LogicalHttpSenderHint

+ func (p *LogicalHttpSenderHint) LogicPlanType() internal.LogicPlanType

type LogicalIndexScan

+ func (p *LogicalIndexScan) LogicPlanType() internal.LogicPlanType

type LogicalInterval

+ func (p *LogicalInterval) LogicPlanType() internal.LogicPlanType

type LogicalLimit

+ func (p *LogicalLimit) LogicPlanType() internal.LogicPlanType

type LogicalMerge

+ func (p *LogicalMerge) LogicPlanType() internal.LogicPlanType

type LogicalMst

+ func (p *LogicalMst) LogicPlanType() internal.LogicPlanType

type LogicalOrderBy

+ func (p *LogicalOrderBy) LogicPlanType() internal.LogicPlanType

type LogicalPlanBase

+ func (p *LogicalPlanBase) Children() []hybridqp.QueryNode

+ func (p *LogicalPlanBase) PreAggInit()

type LogicalPlanBuilderImpl

+ func (b *LogicalPlanBuilderImpl) HoltWinters() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) Target(mst *influxql.Measurement) LogicalPlanBuilder

+ type LogicalPlanMulti struct

+ func (p *LogicalPlanMulti) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalPlanMulti) ReplaceChildren(children []hybridqp.QueryNode)

+ type LogicalPlanSingle struct

+ func NewLogicalPlanSingle(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalPlanSingle

+ func (p *LogicalPlanSingle) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalPlanSingle) ReplaceChildren(children []hybridqp.QueryNode)

+ type LogicalPlaner interface

+ LogicPlanType func() internal.LogicPlanType

+ RowDataType func() hybridqp.RowDataType

+ RowExprOptions func() []hybridqp.ExprOptions

+ SetInputs func(inputs []hybridqp.QueryNode)

type LogicalProject

+ func (p *LogicalProject) LogicPlanType() internal.LogicPlanType

type LogicalReader

+ func (p *LogicalReader) LogicPlanType() internal.LogicPlanType

+ type LogicalSequenceAggregate struct

+ func NewLogicalSequenceAggregate(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalSequenceAggregate

+ func (p *LogicalSequenceAggregate) Clone() hybridqp.QueryNode

+ func (p *LogicalSequenceAggregate) DeriveOperations()

+ func (p *LogicalSequenceAggregate) Digest() string

+ func (p *LogicalSequenceAggregate) Explain(writer LogicalPlanWriter)

+ func (p *LogicalSequenceAggregate) LogicPlanType() internal.LogicPlanType

+ func (p *LogicalSequenceAggregate) String() string

+ func (p *LogicalSequenceAggregate) Type() string

type LogicalSeries

+ func (p *LogicalSeries) LogicPlanType() internal.LogicPlanType

type LogicalSlidingWindow

+ func (p *LogicalSlidingWindow) LogicPlanType() internal.LogicPlanType

type LogicalSortAppend

+ func (p *LogicalSortAppend) LogicPlanType() internal.LogicPlanType

type LogicalSortMerge

+ func (p *LogicalSortMerge) LogicPlanType() internal.LogicPlanType

type LogicalSplitGroup

+ func (p *LogicalSplitGroup) LogicPlanType() internal.LogicPlanType

type LogicalSubQuery

+ func (p *LogicalSubQuery) LogicPlanType() internal.LogicPlanType

+ type LogicalTSSPScan struct

+ func NewLogicalTSSPScan(schema hybridqp.Catalog) *LogicalTSSPScan

+ func (p *LogicalTSSPScan) Children() []hybridqp.QueryNode

+ func (p *LogicalTSSPScan) Clone() hybridqp.QueryNode

+ func (p *LogicalTSSPScan) DeriveOperations()

+ func (p *LogicalTSSPScan) Digest() string

+ func (p *LogicalTSSPScan) Explain(writer LogicalPlanWriter)

+ func (p *LogicalTSSPScan) ExplainIterms(writer LogicalPlanWriter)

+ func (p *LogicalTSSPScan) GetFiles() *immutable.TSSPFiles

+ func (p *LogicalTSSPScan) GetNewSeqs() []uint64

+ func (p *LogicalTSSPScan) LogicPlanType() internal.LogicPlanType

+ func (p *LogicalTSSPScan) MstName() string

+ func (p *LogicalTSSPScan) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalTSSPScan) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalTSSPScan) SetFiles(files *immutable.TSSPFiles)

+ func (p *LogicalTSSPScan) SetNewSeqs(seqs []uint64)

+ func (p *LogicalTSSPScan) String() string

+ func (p *LogicalTSSPScan) Type() string

type LogicalTagSubset

+ func (p *LogicalTagSubset) DeriveOperations()

+ func (p *LogicalTagSubset) LogicPlanType() internal.LogicPlanType

+ type LogicalTarget struct

+ func NewLogicalTarget(input hybridqp.QueryNode, schema hybridqp.Catalog, mst *influxql.Measurement) *LogicalTarget

+ func (p *LogicalTarget) Clone() hybridqp.QueryNode

+ func (p *LogicalTarget) DeriveOperations()

+ func (p *LogicalTarget) Digest() string

+ func (p *LogicalTarget) Explain(writer LogicalPlanWriter)

+ func (p *LogicalTarget) LogicPlanType() internal.LogicPlanType

+ func (p *LogicalTarget) String() string

+ func (p *LogicalTarget) TargetMeasurement() *influxql.Measurement

+ func (p *LogicalTarget) Type() string

+ type LogicalWriteIntoStorage struct

+ func NewLogicalWriteIntoStorage(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalWriteIntoStorage

+ func (p *LogicalWriteIntoStorage) Clone() hybridqp.QueryNode

+ func (p *LogicalWriteIntoStorage) DeriveOperations()

+ func (p *LogicalWriteIntoStorage) Digest() string

+ func (p *LogicalWriteIntoStorage) Explain(writer LogicalPlanWriter)

+ func (p *LogicalWriteIntoStorage) ExplainIterms(writer LogicalPlanWriter)

+ func (p *LogicalWriteIntoStorage) GetMmsTables() *immutable.MmsTables

+ func (p *LogicalWriteIntoStorage) LogicPlanType() internal.LogicPlanType

+ func (p *LogicalWriteIntoStorage) MstName() string

+ func (p *LogicalWriteIntoStorage) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalWriteIntoStorage) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalWriteIntoStorage) SetMmsTables(m *immutable.MmsTables)

+ func (p *LogicalWriteIntoStorage) String() string

+ func (p *LogicalWriteIntoStorage) Type() string

+ type MergeTransf struct

+ func (t *MergeTransf) CostName() string

+ func (t *MergeTransf) GetType() MergeTransformType

+ func (t *MergeTransf) InitColumnsIteratorHelper(rt hybridqp.RowDataType) CoProcessor

+ func (t *MergeTransf) InitHeapItems(inRowDataLen int, _ hybridqp.RowDataType, schema *QuerySchema) BaseHeapItems

+ func (t *MergeTransf) Name() string

type MergeTransform

+ func NewBaseMergeTransform(inRowDataTypes []hybridqp.RowDataType, outRowDataTypes []hybridqp.RowDataType, ...) *MergeTransform

+ func (trans *MergeTransform) CostName() string

+ func (trans *MergeTransform) GetMstName() string

+ func (trans *MergeTransform) InitHeapItems(inRowDataLen int, rt hybridqp.RowDataType, schema *QuerySchema)

+ func (trans *MergeTransform) IsNewMstName() bool

+ type MergeTransformType int

+ const MergeTrans

+ const SortAppendTrans

+ const SortMergeTrans

+ type MergeType interface

+ CostName func() string

+ GetType func() MergeTransformType

+ InitColumnsIteratorHelper func(rt hybridqp.RowDataType) CoProcessor

+ InitHeapItems func(inRowDataLen int, rt hybridqp.RowDataType, schema *QuerySchema) BaseHeapItems

+ Name func() string

+ type OGSketch interface

+ Clusters func() ClusterSet

+ DeleteClusters func(...floatTuple)

+ DeletePoints func(...float64)

+ DemarcationHistogram func(float64, float64, int, int) []int64

+ EquiHeightHistogram func(int, float64, float64) []float64

+ InsertClusters func(...floatTuple)

+ InsertPoints func(...float64)

+ Len func() int

+ Merge func(*OGSketchImpl)

+ Percentile func(float64) float64

+ Rank func(float64) int64

+ Reset func()

+ type OGSketchImpl struct

+ func NewOGSketchImpl(c float64) *OGSketchImpl

+ func (s *OGSketchImpl) Clusters() ClusterSet

+ func (s *OGSketchImpl) DeleteClusters(cluster ...floatTuple)

+ func (s *OGSketchImpl) DeletePoints(m ...float64)

+ func (s *OGSketchImpl) DemarcationHistogram(begin, width float64, binsNum, binsType int) []int64

+ func (s *OGSketchImpl) EquiHeightHistogram(binNum int, begin float64, end float64) []float64

+ func (s *OGSketchImpl) InsertClusters(cluster ...floatTuple)

+ func (s *OGSketchImpl) InsertPoints(m ...float64)

+ func (s *OGSketchImpl) Len() int

+ func (s *OGSketchImpl) Merge(s1 *OGSketchImpl)

+ func (s *OGSketchImpl) Percentile(q float64) float64

+ func (s *OGSketchImpl) Rank(Q float64) int64

+ func (s *OGSketchImpl) Reset()

+ type OGSketchItem interface

+ IsNil func() bool

+ Reset func()

+ UpdateCluster func(inChunk Chunk, start, end int)

+ WriteResult func(outChunk Chunk, time int64)

+ type OGSketchIterator struct

+ func NewOGSketchIterator(isSingleCall bool, inOrdinal, outOrdinal int, clusterNum int, ...) *OGSketchIterator

+ func (r *OGSketchIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type OGSketchMergeItem struct

+ func NewOGSketchMergeItem(isSingleCall bool, inOrdinal, outOrdinal, clusterNum int, percentile float64) *OGSketchMergeItem

+ func (o *OGSketchMergeItem) IsNil() bool

+ func (o *OGSketchMergeItem) Reset()

+ func (o *OGSketchMergeItem) UpdateCluster(inChunk Chunk, start, end int)

+ func (o *OGSketchMergeItem) WriteResult(outChunk Chunk, time int64)

+ type Para struct

+ Expr influxql.Expr

+ VarRef *influxql.VarRef

+ type ParaPointers []*Para

+ func (a ParaPointers) Len() int

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

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

type PipelineExecutor

+ func (exec *PipelineExecutor) GetProcessors() Processors

+ func (exec *PipelineExecutor) GetRoot() *TransformVertex

+ func (exec *PipelineExecutor) SetDag(d *TransformDag)

+ func (exec *PipelineExecutor) SetProcessors(pro Processors)

+ func (exec *PipelineExecutor) SetRoot(r *TransformVertex)

type PipelineExecutorManager

+ func GetPipelineExecutorResourceManager() *PipelineExecutorManager

+ func (p *PipelineExecutorManager) GetMemBucket() bucket.ResourceBucket

+ type PointRowIterator interface

+ GetNext func(row *influx.Row, tuple *TargetTuple)

+ HasMore func() bool

type Processor

+ func CreateBaseMergeTransform(plan LogicalPlan, mergeType MergeType) (Processor, error)

type QuerySchema

+ func NewQuerySchemaWithJoinCase(fields influxql.Fields, sources influxql.Sources, columnNames []string, ...) *QuerySchema

+ func (qs *QuerySchema) AddHoltWinters(call *influxql.Call, alias string)

+ func (qs *QuerySchema) BuildDownSampleSchema(addPrefix bool) record.Schemas

+ func (qs *QuerySchema) CompositeCall() map[string]*hybridqp.OGSketchCompositeOperator

+ func (qs *QuerySchema) GetFieldType(i int) (int64, error)

+ func (qs *QuerySchema) GetJoinCaseCount() int

+ func (qs *QuerySchema) GetJoinCases() []*influxql.Join

+ func (qs *QuerySchema) GetSourcesNames() []string

+ func (qs *QuerySchema) HasAuxTag() bool

+ func (qs *QuerySchema) HasExcatLimit() bool

+ func (qs *QuerySchema) HasHoltWintersCall() bool

+ func (qs *QuerySchema) HasOptimizeAgg() bool

+ func (qs *QuerySchema) HasPercentileOGSketch() bool

+ func (qs *QuerySchema) HoltWinters() []*influxql.Field

+ func (qs *QuerySchema) InitFieldCondition()

+ func (qs *QuerySchema) SetHoltWinters(calls []*influxql.Call)

type Routine

+ func NewPercentileApproxRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, ...) (Routine, error)

+ type SeriesRecord struct

+ func NewSeriesRecord(rec *record.Record, sid uint64, file immutable.TSSPFile, seq uint64, err error) *SeriesRecord

+ func (r *SeriesRecord) GetErr() error

+ func (r *SeriesRecord) GetRec() *record.Record

+ func (r *SeriesRecord) GetSeq() uint64

+ func (r *SeriesRecord) GetSid() uint64

+ func (r *SeriesRecord) GetTsspFile() immutable.TSSPFile

+ type SeriesRecordPort struct

+ OrigiState chan *SeriesRecord

+ Redirected bool

+ RowDataType hybridqp.RowDataType

+ State chan *SeriesRecord

+ func NewSeriesRecordPort(rowDataType hybridqp.RowDataType) *SeriesRecordPort

+ func (p *SeriesRecordPort) Close()

+ func (p *SeriesRecordPort) Connect(to Port)

+ func (p *SeriesRecordPort) ConnectWithoutCache(to Port)

+ func (p *SeriesRecordPort) ConnectionId() uintptr

+ func (p *SeriesRecordPort) Equal(to Port) bool

+ func (p *SeriesRecordPort) Redirect(to Port)

+ func (p *SeriesRecordPort) Release()

+ type SortAppendTransf struct

+ func (t *SortAppendTransf) CostName() string

+ func (t *SortAppendTransf) GetType() MergeTransformType

+ func (t *SortAppendTransf) InitColumnsIteratorHelper(rt hybridqp.RowDataType) CoProcessor

+ func (t *SortAppendTransf) InitHeapItems(inRowDataLen int, _ hybridqp.RowDataType, schema *QuerySchema) BaseHeapItems

+ func (t *SortAppendTransf) Name() string

+ type SortMergeTransf struct

+ func (t *SortMergeTransf) CostName() string

+ func (t *SortMergeTransf) GetType() MergeTransformType

+ func (t *SortMergeTransf) InitColumnsIteratorHelper(rt hybridqp.RowDataType) CoProcessor

+ func (t *SortMergeTransf) InitHeapItems(inRowDataLen int, rt hybridqp.RowDataType, schema *QuerySchema) BaseHeapItems

+ func (t *SortMergeTransf) Name() string

type SortedHeapItems

+ func (h *SortedHeapItems) GetBreakPoint() BaseBreakPoint

+ func (h *SortedHeapItems) GetOption() *query.ProcessorOptions

+ type StringFieldValuer struct

+ func (valuer *StringFieldValuer) At(col Column, pos int, field *influx.Field) bool

+ type TagValues [][]string

+ func (t TagValues) Len() int

+ func (t TagValues) Less(i, j int) bool

+ func (t TagValues) Swap(i, j int)

+ type TargetTable struct

+ func NewTargetTable(rowCap int, tupleCap int) *TargetTable

+ func (tt *TargetTable) Active() []influx.Row

+ func (tt *TargetTable) Allocate() (*influx.Row, *TargetTuple)

+ func (tt *TargetTable) CheckAndAllocate() (*influx.Row, *TargetTuple, bool)

+ func (tt *TargetTable) Commit()

+ func (tt *TargetTable) Reset()

+ type TargetTablePool struct

+ func NewTargetTablePool(rowCap int, tupleCap int) *TargetTablePool

+ func (p *TargetTablePool) Get() *TargetTable

+ func (p *TargetTablePool) Put(table *TargetTable)

+ type TargetTransform struct

+ func NewTargetTransform(inRowDataType hybridqp.RowDataType, outRowDataType hybridqp.RowDataType, ...) (*TargetTransform, error)

+ func (trans *TargetTransform) Close()

+ func (trans *TargetTransform) CloseWriteChan()

+ func (trans *TargetTransform) Explain() []ValuePair

+ func (trans *TargetTransform) GetInputNumber(_ Port) int

+ func (trans *TargetTransform) GetInputs() Ports

+ func (trans *TargetTransform) GetOutputNumber(_ Port) int

+ func (trans *TargetTransform) GetOutputs() Ports

+ func (trans *TargetTransform) Name() string

+ func (trans *TargetTransform) Work(ctx context.Context) error

+ type TargetTransformCreator struct

+ func (c *TargetTransformCreator) Create(plan LogicalPlan, opt query.ProcessorOptions) (Processor, error)

+ type TargetTuple struct

+ func NewTargetTuple(cap int) *TargetTuple

+ func (t *TargetTuple) Active() []influx.Field

+ func (t *TargetTuple) Allocate() *influx.Field

+ func (t *TargetTuple) CheckAndAllocate() (*influx.Field, bool)

+ func (t *TargetTuple) Commit()

+ func (t *TargetTuple) Len() int

+ func (t *TargetTuple) Reset()

type TransformDag

+ func (dag *TransformDag) SetVertexToInfo(vertex *TransformVertex, info *TransformVertexInfo)

type TransformVertex

+ func (t *TransformVertex) GetTransform() Processor

v0

v0.2.0

Dec 7, 2022

Changes in this version

+ func CastorReduce(in []Chunk, out Chunk, args ...interface{}) error

+ type CastorAggCutRule struct

+ func NewCastorAggCutRule(description string) *CastorAggCutRule

+ func (r *CastorAggCutRule) Catagory() OptRuleCatagory

+ func (r *CastorAggCutRule) Equals(rhs OptRule) bool

+ func (r *CastorAggCutRule) OnMatch(call *OptRuleCall)

+ func (r *CastorAggCutRule) ToString() string

type CoProcessor

+ func NewWideProcessorImpl(inRowDataType, outRowDataType hybridqp.RowDataType, ...) (CoProcessor, error)

type LogicalPlanBuilder

+ SplitGroup func() LogicalPlanBuilder

type LogicalPlanBuilderImpl

+ func (b *LogicalPlanBuilderImpl) SplitGroup() LogicalPlanBuilder

+ type LogicalSplitGroup struct

+ func NewLogicalSplitGroup(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalSplitGroup

+ func (p *LogicalSplitGroup) Children() []hybridqp.QueryNode

+ func (p *LogicalSplitGroup) Clone() hybridqp.QueryNode

+ func (p *LogicalSplitGroup) DeriveOperations()

+ func (p *LogicalSplitGroup) Digest() string

+ func (p *LogicalSplitGroup) Dummy() bool

+ func (p *LogicalSplitGroup) Explain(writer LogicalPlanWriter)

+ func (p *LogicalSplitGroup) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalSplitGroup) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalSplitGroup) RowDataType() hybridqp.RowDataType

+ func (p *LogicalSplitGroup) RowExprOptions() []hybridqp.ExprOptions

+ func (p *LogicalSplitGroup) Schema() hybridqp.Catalog

+ func (p *LogicalSplitGroup) String() string

+ func (p *LogicalSplitGroup) Type() string

type OptRuleCatagory

+ const RULE_HEIMADLL_PUSHDOWN

type QuerySchema

+ func (qs *QuerySchema) HasCastorCall() bool

+ type SplitTransformTransform struct

+ CoProcessor CoProcessor

+ NewChunk Chunk

+ func NewSplitTransformTransform(inRowDataType hybridqp.RowDataType, outRowDataType hybridqp.RowDataType, ...) *SplitTransformTransform

+ func (trans *SplitTransformTransform) Close()

+ func (trans *SplitTransformTransform) Explain() []ValuePair

+ func (trans *SplitTransformTransform) GetInputNumber(_ Port) int

+ func (trans *SplitTransformTransform) GetInputs() Ports

+ func (trans *SplitTransformTransform) GetOutputNumber(_ Port) int

+ func (trans *SplitTransformTransform) GetOutputs() Ports

+ func (trans *SplitTransformTransform) Name() string

+ func (trans *SplitTransformTransform) Release() error

+ func (trans *SplitTransformTransform) SendChunk()

+ func (trans *SplitTransformTransform) Work(ctx context.Context) error

+ type SplitTransformTransformCreator struct

+ func (c *SplitTransformTransformCreator) Create(plan LogicalPlan, opt query.ProcessorOptions) (Processor, error)

+ type WideCoProcessorImpl struct

+ Routine *WideRoutineImpl

+ func NewWideCoProcessorImpl(routine *WideRoutineImpl) *WideCoProcessorImpl

+ func (p *WideCoProcessorImpl) WorkOnChunk(in Chunk, out Chunk, params *IteratorParams)

+ type WideIterator struct

+ func NewWideIterator(fn WideReduce, params ...interface{}) *WideIterator

+ func (r *WideIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type WideReduce func(input []Chunk, out Chunk, p ...interface{}) error

+ type WideRoutineImpl struct

+ func NewWideRoutineImpl(iterator Iterator) *WideRoutineImpl

+ func (r *WideRoutineImpl) WorkOnChunk(in Chunk, out Chunk, params *IteratorParams)

v0.1.0

Sep 27, 2022

Changes in this version

+ const AggBufChunkNum

+ const AlignPingPongChunkNum

+ const AnalyzeResponseMessage

+ const ChunkResponseMessage

+ const CircularChunkNum

+ const DefaultBooleanSize

+ const DefaultFloatSize

+ const DefaultIntegerSize

+ const DefaultStringSize

+ const DefaultTimeOut

+ const ErrorMessage

+ const FillBufChunkNum

+ const FinishMessage

+ const INVALID_NUMBER

+ const KBytes2Bytes

+ const LenOfValuers

+ const PORT_CHAN_SIZE

+ const QueryMessage

+ const SlidingWindowBufChunkNum

+ const UnknownMessage

+ const ZeroTimeStamp

+ var BitMask2 = [8]byte

+ var DataSources = map[string]ChunkStruct

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

+ var EnableBinaryTreeMerge int64 = 0

+ var EnableForceBroadcastQuery int64 = 0

+ var EnablePrintLogicalPlan int64 = 0

+ var EnableSlidingWindowPushUp int64 = 0

+ var GetColValsFn map[influxql.DataType]func(col Column, bmStart, bmEnd int, ckLen int, dst []interface{}) []interface

+ var NotAggOnSeries = map[string]bool

+ var OnForceBroadcastQuery int64 = 1

+ var OnPrintLogicalPlan int64 = 1

+ var OnSlidingWindowPushUp int64 = 0

+ var RowSize = 1024

+ var SkipDefault = interface{}(0)

+ func AccessPath(first string, second string) string

+ func AddDataSources(name string, chunks []Chunk, m map[string]int)

+ func BooleanAbsentReduce(c Chunk, ordinal, start, end int) (int, int64, bool)

+ func BooleanAscendingAuxHelper(x, y Column, i, j int) (bool, bool)

+ func BooleanAuxHelpFunc(input, output Column, rowIdx ...int)

+ func BooleanCountReduce(c Chunk, ordinal, start, end int) (int, int64, bool)

+ func BooleanDescendingAuxHelper(x, y Column, i, j int) (bool, bool)

+ func BooleanFirstMerge(prevPoint, currPoint *BooleanPoint)

+ func BooleanFirstReduce(c Chunk, ordinal, start, end int) (int, bool, bool)

+ func BooleanFirstTimeColFastReduce(c Chunk, ordinal, start, end int) (int, bool, bool)

+ func BooleanFirstTimeColMerge(prevPoint, currPoint *BooleanPoint)

+ func BooleanFirstTimeColReduce(c Chunk, ordinal, start, end int) (int, bool, bool)

+ func BooleanFirstTimeColSlowReduce(c Chunk, ordinal, start, end int) (int, bool, bool)

+ func BooleanLastMerge(prevPoint, currPoint *BooleanPoint)

+ func BooleanLastReduce(c Chunk, ordinal, start, end int) (int, bool, bool)

+ func BooleanLastTimeColFastReduce(c Chunk, ordinal, start, end int) (int, bool, bool)

+ func BooleanLastTimeColMerge(prevPoint, currPoint *BooleanPoint)

+ func BooleanLastTimeColReduce(c Chunk, ordinal, start, end int) (int, bool, bool)

+ func BooleanLastTimeColSlowReduce(c Chunk, ordinal, start, end int) (int, bool, bool)

+ func BooleanMaxMerge(prevPoint, currPoint *BooleanPoint)

+ func BooleanMaxReduce(c Chunk, ordinal, start, end int) (int, bool, bool)

+ func BooleanMinMerge(prevPoint, currPoint *BooleanPoint)

+ func BooleanMinReduce(c Chunk, ordinal, start, end int) (int, bool, bool)

+ func BooleanSlidingWindowMergeFunc(prevWindow, currWindow *BooleanSlidingWindow, fpm BooleanPointMerge)

+ func CompareBreakPoint(name string, time int64, tag ChunkTags, b *BreakPoint, ...) bool

+ func CompareSortedAppendBreakPoint(item Item, in int, tag ChunkTags, b *SortedBreakPoint, ...) bool

+ func CompareSortedMergeBreakPoint(item Item, in int, tag ChunkTags, b *SortedBreakPoint, ...) bool

+ func Connect(from Port, to Port) error

+ func ContainDim(des []string, src string) bool

+ func DFSSources(sources influxql.Sources) []*influxql.Measurement

+ func DecodeBytes(bytes []byte) []byte

+ func DecomposePath(path string) []string

+ func EnableFileCursor(en bool)

+ func ExprWalk(v influxql.Fields, node influxql.Node)

+ func Float64AscendingAuxHelper(x, y Column, i, j int) (bool, bool)

+ func Float64DescendingAuxHelper(x, y Column, i, j int) (bool, bool)

+ func FloatAbsentReduce(c Chunk, ordinal, start, end int) (int, int64, bool)

+ func FloatAbsoluteDiffFunc(prev, curr float64) float64

+ func FloatAuxHelpFunc(input, output Column, rowIdx ...int)

+ func FloatBehindDiffFunc(prev, curr float64) float64

+ func FloatBottomCmpByTimeReduce(a, b *FloatPointItem) bool

+ func FloatBottomCmpByValueReduce(a, b *FloatPointItem) bool

+ func FloatCountReduce(c Chunk, ordinal, start, end int) (int, int64, bool)

+ func FloatFirstMerge(prevPoint, currPoint *FloatPoint)

+ func FloatFirstReduce(c Chunk, ordinal, start, end int) (int, float64, bool)

+ func FloatFirstTimeColFastReduce(c Chunk, ordinal, start, end int) (int, float64, bool)

+ func FloatFirstTimeColMerge(prevPoint, currPoint *FloatPoint)

+ func FloatFirstTimeColReduce(c Chunk, ordinal, start, end int) (int, float64, bool)

+ func FloatFirstTimeColSlowReduce(c Chunk, ordinal, start, end int) (int, float64, bool)

+ func FloatFrontDiffFunc(prev, curr float64) float64

+ func FloatIrateFastReduce(c Chunk, ordinal, start, end int) (int, int, float64, float64, bool)

+ func FloatIrateFinalReduce(ft int64, st int64, fv float64, sv float64, interval *hybridqp.Interval) (float64, bool)

+ func FloatIrateMerge(prevPoints [2]*FloatPoint, interval *hybridqp.Interval) (float64, bool)

+ func FloatIrateMiddleReduce(c Chunk, ordinal, start, end int) (int, int, float64, float64, bool)

+ func FloatIrateSlowReduce(c Chunk, ordinal, start, end int) (int, int, float64, float64, bool)

+ func FloatIrateUpdate(prevPoints, currPoints [2]*FloatPoint)

+ func FloatLastMerge(prevPoint, currPoint *FloatPoint)

+ func FloatLastReduce(c Chunk, ordinal, start, end int) (int, float64, bool)

+ func FloatLastTimeColFastReduce(c Chunk, ordinal, start, end int) (int, float64, bool)

+ func FloatLastTimeColMerge(prevPoint, currPoint *FloatPoint)

+ func FloatLastTimeColReduce(c Chunk, ordinal, start, end int) (int, float64, bool)

+ func FloatLastTimeColSlowReduce(c Chunk, ordinal, start, end int) (int, float64, bool)

+ func FloatMaxMerge(prevPoint, currPoint *FloatPoint)

+ func FloatMaxReduce(c Chunk, ordinal, start, end int) (int, float64, bool)

+ func FloatMeanMerge(prevPoint, currPoint *FloatPoint)

+ func FloatMeanReduce(c Chunk, ordinal, start, end int) (int, float64, bool)

+ func FloatMinMerge(prevPoint, currPoint *FloatPoint)

+ func FloatMinReduce(c Chunk, ordinal, start, end int) (int, float64, bool)

+ func FloatRateFastReduce(c Chunk, ordinal, start, end int) (int, int, float64, float64, bool)

+ func FloatRateFinalReduce(firstTime int64, lastTime int64, firstValue float64, lastValue float64, ...) (float64, bool)

+ func FloatRateLowReduce(c Chunk, ordinal, start, end int) (int, int, float64, float64, bool)

+ func FloatRateMerge(prevPoints [2]*FloatPoint, interval *hybridqp.Interval) (float64, bool)

+ func FloatRateMiddleReduce(c Chunk, ordinal, start, end int) (int, int, float64, float64, bool)

+ func FloatRateUpdate(prevPoints, currPoints [2]*FloatPoint)

+ func FloatSlidingWindowMergeFunc(prevWindow, currWindow *FloatSlidingWindow, fpm FloatPointMerge)

+ func FloatSumMerge(prevPoint, currPoint *FloatPoint)

+ func FloatSumReduce(c Chunk, ordinal, start, end int) (int, float64, bool)

+ func FloatTopCmpByTimeReduce(a, b *FloatPointItem) bool

+ func FloatTopCmpByValueReduce(a, b *FloatPointItem) bool

+ func GetEnableBinaryTreeMerge() int64

+ func GetEnableFileCursor() bool

+ func GetEnableForceBroadcastQuery() int64

+ func GetEnablePrintLogicalPlan() int64

+ func GetEnableSlidingWindowPushUp() int64

+ func GetMapFromReader(rowDataType hybridqp.RowDataType, ops []hybridqp.ExprOptions) map[int]string

+ func GetType(i interface{}) string

+ func GetTypeName(i interface{}) string

+ func IndexUnion(index1, index2 []int) []int

+ func IntegerAbsentMerge(prevPoint, currPoint *IntegerPoint)

+ func IntegerAbsentReduce(c Chunk, ordinal, start, end int) (int, int64, bool)

+ func IntegerAbsoluteDiffFunc(prev, curr int64) int64

+ func IntegerAscendingAuxHelper(x, y Column, i, j int) (bool, bool)

+ func IntegerAuxHelpFunc(input, output Column, rowIdx ...int)

+ func IntegerBehindDiffFunc(prev, curr int64) int64

+ func IntegerBottomCmpByTimeReduce(a, b *IntegerPointItem) bool

+ func IntegerBottomCmpByValueReduce(a, b *IntegerPointItem) bool

+ func IntegerCountMerge(prevPoint, currPoint *IntegerPoint)

+ func IntegerCountReduce(c Chunk, ordinal, start, end int) (int, int64, bool)

+ func IntegerDescendingAuxHelper(x, y Column, i, j int) (bool, bool)

+ func IntegerFirstMerge(prevPoint, currPoint *IntegerPoint)

+ func IntegerFirstReduce(c Chunk, ordinal, start, end int) (int, int64, bool)

+ func IntegerFirstTimeColFastReduce(c Chunk, ordinal, start, end int) (int, int64, bool)

+ func IntegerFirstTimeColMerge(prevPoint, currPoint *IntegerPoint)

+ func IntegerFirstTimeColReduce(c Chunk, ordinal, start, end int) (int, int64, bool)

+ func IntegerFirstTimeColSlowReduce(c Chunk, ordinal, start, end int) (int, int64, bool)

+ func IntegerFrontDiffFunc(prev, curr int64) int64

+ func IntegerIrateFastReduce(c Chunk, ordinal, start, end int) (int, int, int64, int64, bool)

+ func IntegerIrateFinalReduce(ft int64, st int64, fv int64, sv int64, interval *hybridqp.Interval) (float64, bool)

+ func IntegerIrateMerge(prevPoints [2]*IntegerPoint, interval *hybridqp.Interval) (float64, bool)

+ func IntegerIrateMiddleReduce(c Chunk, ordinal, start, end int) (int, int, int64, int64, bool)

+ func IntegerIrateSlowReduce(c Chunk, ordinal, start, end int) (int, int, int64, int64, bool)

+ func IntegerIrateUpdate(prevPoints, currPoints [2]*IntegerPoint)

+ func IntegerLastMerge(prevPoint, currPoint *IntegerPoint)

+ func IntegerLastReduce(c Chunk, ordinal, start, end int) (int, int64, bool)

+ func IntegerLastTimeColFastReduce(c Chunk, ordinal, start, end int) (int, int64, bool)

+ func IntegerLastTimeColMerge(prevPoint, currPoint *IntegerPoint)

+ func IntegerLastTimeColReduce(c Chunk, ordinal, start, end int) (int, int64, bool)

+ func IntegerLastTimeColSlowReduce(c Chunk, ordinal, start, end int) (int, int64, bool)

+ func IntegerMaxMerge(prevPoint, currPoint *IntegerPoint)

+ func IntegerMaxReduce(c Chunk, ordinal, start, end int) (int, int64, bool)

+ func IntegerMeanReduce(c Chunk, ordinal, start, end int) (int, float64, bool)

+ func IntegerMinMerge(prevPoint, currPoint *IntegerPoint)

+ func IntegerMinReduce(c Chunk, ordinal, start, end int) (int, int64, bool)

+ func IntegerRateFastReduce(c Chunk, ordinal, start, end int) (int, int, int64, int64, bool)

+ func IntegerRateFinalReduce(firstTime int64, lastTime int64, firstValue int64, lastValue int64, ...) (float64, bool)

+ func IntegerRateLowReduce(c Chunk, ordinal, start, end int) (int, int, int64, int64, bool)

+ func IntegerRateMerge(prevPoints [2]*IntegerPoint, interval *hybridqp.Interval) (float64, bool)

+ func IntegerRateMiddleReduce(c Chunk, ordinal, start, end int) (int, int, int64, int64, bool)

+ func IntegerRateUpdate(prevPoints, currPoints [2]*IntegerPoint)

+ func IntegerSlidingWindowMergeFunc(prevWindow, currWindow *IntegerSlidingWindow, fpm IntegerPointMerge)

+ func IntegerSumMerge(prevPoint, currPoint *IntegerPoint)

+ func IntegerSumReduce(c Chunk, ordinal, start, end int) (int, int64, bool)

+ func IntegerTopCmpByTimeReduce(a, b *IntegerPointItem) bool

+ func IntegerTopCmpByValueReduce(a, b *IntegerPointItem) bool

+ func IntervalIndexGen(chunk Chunk, opt query.ProcessorOptions)

+ func IntervalIndexGenerator(c Chunk, opt query.ProcessorOptions)

+ func IsSubTreeEqual(node hybridqp.QueryNode, comparedNode hybridqp.QueryNode) bool

+ func LowerBoundInt64(a []int64, x int64) int

+ func MarshalQueryNode(node hybridqp.QueryNode) ([]byte, error)

+ func MeasurementsFromSelectStmt(stmt *influxql.SelectStatement) []*influxql.Measurement

+ func MemoryEstimator(exec *PipelineExecutor)

+ func NewAnalyzeResponse(trace *tracing.Trace) *rpc.Message

+ func NewBooleanModeReduce(BooleanSliceItem *BooleanSliceItem) (int, int64, float64, bool)

+ func NewChunkResponse(chunk Chunk) *rpc.Message

+ func NewErrorMessage(err string) *rpc.Message

+ func NewFinishMessage() *rpc.Message

+ func NewFloatMedianReduce(floatSliceItem *FloatSliceItem) (int, int64, float64, bool)

+ func NewFloatModeReduce(FloatSliceItem *FloatSliceItem) (int, int64, float64, bool)

+ func NewIntegerMedianReduce(integerSliceItem *IntegerSliceItem) (int, int64, float64, bool)

+ func NewIntegerModeReduce(IntegerSliceItem *IntegerSliceItem) (int, int64, float64, bool)

+ func NewInvalidTypeError(exp string, data interface{}) error

+ func NewLogicPlanByName(name string) hybridqp.QueryNode

+ func NewPreparedStatement(stmt *influxql.SelectStatement, opt hybridqp.Options, shards interface{ ... }, ...) *preparedStatement

+ func NewPrevValuesFunc(rowDataType hybridqp.RowDataType) []func(prev Chunk, prevValues []interface{}, ordinal int)

+ func NewPrevWindowFunc(rowDataType hybridqp.RowDataType) ([]func(prev Chunk, window *prevWindow, ordinal int), ...)

+ func NewProcessors(inRowDataType, outRowDataType hybridqp.RowDataType, ...) (*processorResults, error)

+ func NewRPCMessage(typ uint8) transport.Codec

+ func NewStringModeReduce(StringSliceItem *StringSliceItem) (int, int64, float64, bool)

+ func NilInColumn(columnBitmap [][]uint32, colNum, position int, offsets []int) (bool, int)

+ func NodeMemEstimator(rt hybridqp.RowDataType, chunkSize int64) int64

+ func PutChunkTags(ct *ChunkTags)

+ func RegistryMockTransformCreator()

+ func RegistryTransformCreator(plan LogicalPlan, creator TransformCreator) bool

+ func SearchIndex(outRt hybridqp.RowDataType, ref influxql.VarRef) int

+ func Select(ctx context.Context, stmt *influxql.SelectStatement, ...) (hybridqp.Executor, error)

+ func SetEnableBinaryTreeMerge(enabled int64)

+ func SetEnableForceBroadcastQuery(enabled int64)

+ func SetEnablePrintLogicalPlan(enabled int64)

+ func SetEnableSlidingWindowPushUp(enabled int64)

+ func SetPipelineExecutorResourceManagerParas(TotalRes int64, timeout time.Duration)

+ func SetTimeZero(schema *QuerySchema) bool

+ func Str2bytes(s string) []byte

+ func StrFunc(srcStr string, subStr string) bool

+ func StrLenFunc(srcStr string) int64

+ func StringAbsentReduce(c Chunk, ordinal, start, end int) (int, int64, bool)

+ func StringAscendingAuxHelper(x, y Column, i, j int) (bool, bool)

+ func StringAuxHelpFunc(input, output Column, rowIdx ...int)

+ func StringCountReduce(c Chunk, ordinal, start, end int) (int, int64, bool)

+ func StringDescendingAuxHelper(x, y Column, i, j int) (bool, bool)

+ func StringFirstMerge(prevPoint, currPoint *StringPoint)

+ func StringFirstReduce(c Chunk, ordinal, start, end int) (int, string, bool)

+ func StringFirstTimeColFastReduce(c Chunk, ordinal, start, end int) (int, string, bool)

+ func StringFirstTimeColMerge(prevPoint, currPoint *StringPoint)

+ func StringFirstTimeColReduce(c Chunk, ordinal, start, end int) (int, string, bool)

+ func StringFirstTimeColSlowReduce(c Chunk, ordinal, start, end int) (int, string, bool)

+ func StringLastMerge(prevPoint, currPoint *StringPoint)

+ func StringLastReduce(c Chunk, ordinal, start, end int) (int, string, bool)

+ func StringLastTimeColFastReduce(c Chunk, ordinal, start, end int) (int, string, bool)

+ func StringLastTimeColMerge(prevPoint, currPoint *StringPoint)

+ func StringLastTimeColReduce(c Chunk, ordinal, start, end int) (int, string, bool)

+ func StringLastTimeColSlowReduce(c Chunk, ordinal, start, end int) (int, string, bool)

+ func SubStrThreeParaFunc(srcStr string, start, subStrLen int64) string

+ func SubStrTwoParaFunc(srcStr string, start int64) string

+ func TransparentForwardBooleanColumn(dst Column, src Column)

+ func TransparentForwardFloatColumn(dst Column, src Column)

+ func TransparentForwardIntegerColumn(dst Column, src Column)

+ func TransparentForwardStringColumn(dst Column, src Column)

+ func UnionBitMapArray(b1, b2 []uint16) []uint16

+ func UnionColumns(cols ...Column) []uint16

+ func UnmarshalQueryNode(buf []byte) (hybridqp.QueryNode, error)

+ func UpperBoundInt64(a []int64, x int64) int

+ func ValidateFieldsFromPlans(plans []hybridqp.QueryNode) bool

+ func Walk(v LogicalPlanVisitor, plan hybridqp.QueryNode)

+ func WalkRefs(fields influxql.Fields) []influxql.VarRef

+ type Abort struct

+ ClientID uint64

+ Seq uint64

+ func NewAbort(seq uint64, clientID uint64) *Abort

+ func (e *Abort) Instance() transport.Codec

+ func (e *Abort) Marshal(buf []byte) ([]byte, error)

+ func (e *Abort) Size() int

+ func (e *Abort) Unmarshal(buf []byte) error

+ type AggPushDownToSubQueryRule struct

+ func NewAggPushDownToSubQueryRule(description string) *AggPushDownToSubQueryRule

+ func (r *AggPushDownToSubQueryRule) Catagory() OptRuleCatagory

+ func (r *AggPushDownToSubQueryRule) Equals(rhs OptRule) bool

+ func (r *AggPushDownToSubQueryRule) OnMatch(call *OptRuleCall)

+ func (r *AggPushDownToSubQueryRule) ToString() string

+ type AggPushdownToExchangeRule struct

+ func NewAggPushdownToExchangeRule(description string) *AggPushdownToExchangeRule

+ func (r *AggPushdownToExchangeRule) Catagory() OptRuleCatagory

+ func (r *AggPushdownToExchangeRule) Equals(rhs OptRule) bool

+ func (r *AggPushdownToExchangeRule) OnMatch(call *OptRuleCall)

+ func (r *AggPushdownToExchangeRule) ToString() string

+ type AggPushdownToReaderRule struct

+ func NewAggPushdownToReaderRule(description string) *AggPushdownToReaderRule

+ func (r *AggPushdownToReaderRule) Catagory() OptRuleCatagory

+ func (r *AggPushdownToReaderRule) Equals(rhs OptRule) bool

+ func (r *AggPushdownToReaderRule) OnMatch(call *OptRuleCall)

+ func (r *AggPushdownToReaderRule) ToString() string

+ type AggPushdownToSeriesRule struct

+ func NewAggPushdownToSeriesRule(description string) *AggPushdownToSeriesRule

+ func (r *AggPushdownToSeriesRule) Catagory() OptRuleCatagory

+ func (r *AggPushdownToSeriesRule) Equals(rhs OptRule) bool

+ func (r *AggPushdownToSeriesRule) OnMatch(call *OptRuleCall)

+ func (r *AggPushdownToSeriesRule) ToString() string

+ type AggSpreadToExchangeRule struct

+ func NewAggSpreadToExchangeRule(description string) *AggSpreadToExchangeRule

+ func (r *AggSpreadToExchangeRule) Catagory() OptRuleCatagory

+ func (r *AggSpreadToExchangeRule) Equals(rhs OptRule) bool

+ func (r *AggSpreadToExchangeRule) OnMatch(call *OptRuleCall)

+ func (r *AggSpreadToExchangeRule) ToString() string

+ type AggSpreadToReaderRule struct

+ func NewAggSpreadToReaderRule(description string) *AggSpreadToReaderRule

+ func (r *AggSpreadToReaderRule) Catagory() OptRuleCatagory

+ func (r *AggSpreadToReaderRule) Equals(rhs OptRule) bool

+ func (r *AggSpreadToReaderRule) OnMatch(call *OptRuleCall)

+ func (r *AggSpreadToReaderRule) ToString() string

+ type AggSpreadToSortAppendRule struct

+ func NewAggSpreadToSortAppendRule(description string) *AggSpreadToSortAppendRule

+ func (r *AggSpreadToSortAppendRule) Catagory() OptRuleCatagory

+ func (r *AggSpreadToSortAppendRule) Equals(rhs OptRule) bool

+ func (r *AggSpreadToSortAppendRule) OnMatch(call *OptRuleCall)

+ func (r *AggSpreadToSortAppendRule) ToString() string

+ type AggToProjectInSubQueryRule struct

+ func NewAggToProjectInSubQueryRule(description string) *AggToProjectInSubQueryRule

+ func (r *AggToProjectInSubQueryRule) Catagory() OptRuleCatagory

+ func (r *AggToProjectInSubQueryRule) Equals(rhs OptRule) bool

+ func (r *AggToProjectInSubQueryRule) OnMatch(call *OptRuleCall)

+ func (r *AggToProjectInSubQueryRule) ToString() string

+ type AlignTransform struct

+ Inputs ChunkPorts

+ Outputs ChunkPorts

+ func NewAlignTransform(inRowDataType []hybridqp.RowDataType, outRowDataType []hybridqp.RowDataType, ...) *AlignTransform

+ func (trans *AlignTransform) Close()

+ func (trans *AlignTransform) Explain() []ValuePair

+ func (trans *AlignTransform) GetInputNumber(port Port) int

+ func (trans *AlignTransform) GetInputs() Ports

+ func (trans *AlignTransform) GetOutputNumber(port Port) int

+ func (trans *AlignTransform) GetOutputs() Ports

+ func (trans *AlignTransform) Name() string

+ func (trans *AlignTransform) SendChunk()

+ func (trans *AlignTransform) Work(ctx context.Context) error

+ type AlignTransformCreator struct

+ func (c *AlignTransformCreator) Create(plan LogicalPlan, opt query.ProcessorOptions) (Processor, error)

+ type AnalyzeResponse struct

+ func (a *AnalyzeResponse) Marshal(buf []byte) ([]byte, error)

+ func (a *AnalyzeResponse) Size() int

+ func (a *AnalyzeResponse) Unmarshal(buf []byte) error

+ func (a AnalyzeResponse) Instance() transport.Codec

+ type AppendHeapItems struct

+ Items []*Item

+ func (h *AppendHeapItems) GetSortedBreakPoint() *SortedBreakPoint

+ func (h *AppendHeapItems) Len() int

+ func (h *AppendHeapItems) Less(i, j int) bool

+ func (h *AppendHeapItems) Pop() interface{}

+ func (h *AppendHeapItems) Push(x interface{})

+ func (h *AppendHeapItems) Swap(i, j int)

+ type AuxProcessor struct

+ func NewAuxCoProcessor(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions) *AuxProcessor

+ type BaseProcessor struct

+ func (bp *BaseProcessor) Analyze(span *tracing.Span)

+ func (bp *BaseProcessor) BaseSpan() *tracing.Span

+ func (bp *BaseProcessor) FinishSpan()

+ func (bp *BaseProcessor) InitOnce()

+ func (bp *BaseProcessor) IsSink() bool

+ func (bp *BaseProcessor) Once(fn func())

+ func (bp *BaseProcessor) Release() error

+ func (bp *BaseProcessor) StartSpan(name string, withPP bool) *tracing.Span

+ type BaseTransData struct

+ type BeginGroup struct

+ func NewBeginGroup() *BeginGroup

+ func (g *BeginGroup) Execute(planner HeuPlanner)

+ func (g *BeginGroup) Initialize(clearCache bool)

+ type Bitmap struct

+ func NewBitmap() *Bitmap

+ func (b *Bitmap) Clear()

+ func (b *Bitmap) CopyTo(dst *Bitmap)

+ func (b *Bitmap) Instance() transport.Codec

+ func (b *Bitmap) Marshal(buf []byte) ([]byte, error)

+ func (b *Bitmap) Reverse()

+ func (b *Bitmap) SetArray(arr []uint16)

+ func (b *Bitmap) SetLen(len int)

+ func (b *Bitmap) SetNilCount(nilCount int)

+ func (b *Bitmap) Size() int

+ func (b *Bitmap) String() string

+ func (b *Bitmap) ToArray() []uint16

+ func (b *Bitmap) ToBit() []byte

+ func (b *Bitmap) Unmarshal(buf []byte) error

+ func (b *Bitmap) UpdateBitWithArray(dat []bool)

+ type BooleanAlignIterator struct

+ func NewBooleanAlignIterator() *BooleanAlignIterator

+ func (f *BooleanAlignIterator) Next(endpoint *IteratorEndpoint, _ *IteratorParams)

+ type BooleanAppendIterator struct

+ func NewBooleanAppendIterator() *BooleanAppendIterator

+ func (f *BooleanAppendIterator) Next(endpoint *IteratorEndpoint, params *IteratorParams)

+ type BooleanColBooleanDistinctIterator struct

+ func NewBooleanColBooleanDistinctIterator(inOrdinal, outOrdinal int) *BooleanColBooleanDistinctIterator

+ func (r *BooleanColBooleanDistinctIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type BooleanColBooleanIterator struct

+ func NewBooleanColBooleanIterator(fn BooleanColBooleanReduce, fv BooleanColBooleanMerge, isSingleCall bool, ...) *BooleanColBooleanIterator

+ func (r *BooleanColBooleanIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type BooleanColBooleanMerge func(prevPoint, currPoint *BooleanPoint)

+ type BooleanColBooleanReduce func(c Chunk, ordinal, start, end int) (index int, value bool, isNil bool)

+ type BooleanColBooleanSampleIterator struct

+ func NewBooleanColBooleanSampleIterator(sampleNum int, isSingleCall bool, inOrdinal, outOrdinal int, ...) *BooleanColBooleanSampleIterator

+ func (r *BooleanColBooleanSampleIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type BooleanColBooleanSliceIterator struct

+ func NewBooleanColBooleanSliceIterator(fn BooleanColReduceSliceReduce, isSingleCall bool, inOrdinal, outOrdinal int, ...) *BooleanColBooleanSliceIterator

+ func (r *BooleanColBooleanSliceIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type BooleanColBooleanWindowReduce func(c Chunk, ordinal, start, end int) (index int, value bool, isNil bool)

+ type BooleanColIntegerIterator struct

+ func NewBooleanColIntegerIterator(fn BooleanColIntegerReduce, fv BooleanColIntegerMerge, isSingleCall bool, ...) *BooleanColIntegerIterator

+ func (r *BooleanColIntegerIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type BooleanColIntegerMerge func(prevPoint, currPoint *IntegerPoint)

+ type BooleanColIntegerReduce func(c Chunk, ordinal, start, end int) (index int, value int64, isNil bool)

+ type BooleanColIntegerWindowReduce func(c Chunk, ordinal, start, end int) (index int, value int64, isNil bool)

+ type BooleanColReduceSliceReduce func(booleanItem *BooleanSliceItem) (index int, time int64, value float64, isNil bool)

+ type BooleanDistinctItem struct

+ func NewBooleanDistinctItem() *BooleanDistinctItem

+ func (f *BooleanDistinctItem) Len() int

+ func (f *BooleanDistinctItem) Less(i, j int) bool

+ func (f *BooleanDistinctItem) Nil() bool

+ func (f *BooleanDistinctItem) Reset()

+ func (f *BooleanDistinctItem) Swap(i, j int)

+ type BooleanIntervalIterator struct

+ func NewBooleanIntervalIterator() *BooleanIntervalIterator

+ func (f *BooleanIntervalIterator) Next(endpoint *IteratorEndpoint, _ *IteratorParams)

+ type BooleanLimitIterator struct

+ func NewBooleanLimitIterator() *BooleanLimitIterator

+ func (f *BooleanLimitIterator) Next(endpoint *IteratorEndpoint, params *IteratorParams)

+ type BooleanLinearFillProcessor struct

+ func NewBooleanLinearFillProcessor(inOrdinal, outOrdinal int) *BooleanLinearFillProcessor

+ type BooleanMergeIterator struct

+ func NewBooleanMergeIterator() *BooleanMergeIterator

+ func (f *BooleanMergeIterator) Next(endpoint *IteratorEndpoint, params *IteratorParams)

+ type BooleanNullFillProcessor struct

+ func NewBooleanNullFillProcessor(inOrdinal, outOrdinal int) *BooleanNullFillProcessor

+ type BooleanNumberFillProcessor struct

+ func NewBooleanNumberFillProcessor(inOrdinal, outOrdinal int) *BooleanNumberFillProcessor

+ type BooleanPoint struct

+ func (p *BooleanPoint) Assign(c *BooleanPoint)

+ func (p *BooleanPoint) Reset()

+ func (p *BooleanPoint) Set(index int, time int64, value bool)

+ type BooleanPointItem struct

+ func NewBooleanPointItem(time int64, value bool) *BooleanPointItem

+ type BooleanPointMerge func(prevPoint, currPoint *BooleanPoint)

+ type BooleanPreviousFillProcessor struct

+ func NewBooleanPreviousFillProcessor(inOrdinal, outOrdinal int) *BooleanPreviousFillProcessor

+ type BooleanSampleItem struct

+ func NewBooleanSampleItem(items []BooleanPointItem) *BooleanSampleItem

+ func (f *BooleanSampleItem) Len() int

+ func (f *BooleanSampleItem) Less(i, j int) bool

+ func (f *BooleanSampleItem) Reset()

+ func (f *BooleanSampleItem) Swap(i, j int)

+ type BooleanSliceItem struct

+ func NewBooleanSliceItem() *BooleanSliceItem

+ func (f *BooleanSliceItem) AppendItem(c Chunk, ordinal, start, end int)

+ func (f *BooleanSliceItem) Len() int

+ func (f *BooleanSliceItem) Reset()

+ type BooleanSlidingWindow struct

+ func NewBooleanSlidingWindow(slidingNum int) *BooleanSlidingWindow

+ func (w *BooleanSlidingWindow) IsNil() bool

+ func (w *BooleanSlidingWindow) Len() int

+ func (w *BooleanSlidingWindow) Reset()

+ func (w *BooleanSlidingWindow) SetPoint(value bool, isNil bool, index int)

+ type BooleanSlidingWindowBooleanIterator struct

+ func NewBooleanSlidingWindowBooleanIterator(fwr BooleanColBooleanWindowReduce, fpm BooleanPointMerge, ...) *BooleanSlidingWindowBooleanIterator

+ func (r *BooleanSlidingWindowBooleanIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type BooleanSlidingWindowIntegerIterator struct

+ func NewBooleanSlidingWindowIntegerIterator(fwr BooleanColIntegerWindowReduce, fpm IntegerPointMerge, ...) *BooleanSlidingWindowIntegerIterator

+ func (r *BooleanSlidingWindowIntegerIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type BooleanTimeColBooleanIterator struct

+ func NewBooleanTimeColBooleanIterator(fn BooleanTimeColBooleanReduce, fv BooleanTimeColBooleanMerge, ...) *BooleanTimeColBooleanIterator

+ func (r *BooleanTimeColBooleanIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type BooleanTimeColBooleanMerge func(prevPoint, currPoint *BooleanPoint)

+ type BooleanTimeColBooleanReduce func(c Chunk, ordinal, start, end int) (index int, value bool, isNil bool)

+ type BooleanWindowMerge func(prevWindow, currWindow *BooleanSlidingWindow, fpm BooleanPointMerge)

+ type BreakPoint struct

+ Name string

+ Tag ChunkTags

+ TimeEnd int64

+ TimeStart int64

+ type Byte byte

+ type CancelOnlySource struct

+ Output *ChunkPort

+ func NewCancelOnlySource(rowDataType hybridqp.RowDataType) *CancelOnlySource

+ func (source *CancelOnlySource) Close()

+ func (source *CancelOnlySource) Explain() []ValuePair

+ func (source *CancelOnlySource) GetInputNumber(_ Port) int

+ func (source *CancelOnlySource) GetInputs() Ports

+ func (source *CancelOnlySource) GetOutputNumber(_ Port) int

+ func (source *CancelOnlySource) GetOutputs() Ports

+ func (source *CancelOnlySource) Name() string

+ func (source *CancelOnlySource) Work(ctx context.Context) error

+ type Catalog struct

+ func NewCatalog() *Catalog

+ func (c *Catalog) CreateDatabase(name string, rp string) (*Database, error)

+ func (c *Catalog) Database(name string, rp string) (*Database, error)

+ func (c *Catalog) Table(name string, rp string, tbl string) (*Table, error)

+ type Chunk interface

+ AddColumn func(...Column)

+ AddIntervalIndex func(i int)

+ AddTagAndIndex func(tag ChunkTags, i int)

+ AppendIntervalIndex func(...int)

+ AppendTagsAndIndex func(ChunkTags, int)

+ AppendTagsAndIndexes func([]ChunkTags, []int)

+ AppendTime func(...int64)

+ CheckChunk func()

+ Clone func() Chunk

+ Column func(int) Column

+ Columns func() []Column

+ Instance func() transport.Codec

+ IntervalIndex func() []int

+ IntervalLen func() int

+ IsNil func() bool

+ Len func() int

+ Marshal func([]byte) ([]byte, error)

+ Name func() string

+ NumberOfCols func() int

+ NumberOfRows func() int

+ Release func()

+ Reset func()

+ ResetIntervalIndex func(...int)

+ ResetTagsAndIndexes func(tags []ChunkTags, tagIndex []int)

+ ResetTime func(int, int64)

+ RowDataType func() hybridqp.RowDataType

+ SetColumn func(Column, int)

+ SetName func(string)

+ SetRowDataType func(hybridqp.RowDataType)

+ SetTime func(time []int64)

+ Size func() int

+ SlimChunk func(ridIdx []int) Chunk

+ String func() string

+ TagIndex func() []int

+ TagLen func() int

+ Tags func() []ChunkTags

+ Time func() []int64

+ TimeByIndex func(int) int64

+ TruncateTime func(int)

+ Unmarshal func([]byte) error

+ func BuildSQLChunk1() Chunk

+ func BuildSQLChunk2() Chunk

+ func BuildSQLChunk3() Chunk

+ func BuildSQLChunk4() Chunk

+ func BuildSQLChunk5() Chunk

+ func BuildSQLChunk6() Chunk

+ func BuildSQLChunk7() Chunk

+ type ChunkBuilder struct

+ func NewChunkBuilder(rowDataType hybridqp.RowDataType) *ChunkBuilder

+ func (b *ChunkBuilder) NewChunk(name string) Chunk

+ type ChunkForwardTransWorkHelper struct

+ CloseFn func()

+ ForwardFn func(Chunk) Chunk

+ GetInputsFn func() ChunkPorts

+ GetOutputsFn func() ChunkPorts

+ func (helper ChunkForwardTransWorkHelper) Work(ctx context.Context) error

+ type ChunkImpl struct

+ func NewChunkImpl(rowDataType hybridqp.RowDataType, name string) *ChunkImpl

+ func (c *ChunkImpl) AddColumn(cols ...Column)

+ func (c *ChunkImpl) AddIntervalIndex(i int)

+ func (c *ChunkImpl) AddTagAndIndex(tag ChunkTags, i int)

+ func (c *ChunkImpl) AppendIntervalIndex(intervalIndex ...int)

+ func (c *ChunkImpl) AppendTagsAndIndex(tag ChunkTags, tagIndex int)

+ func (c *ChunkImpl) AppendTagsAndIndexes(tags []ChunkTags, tagIndex []int)

+ func (c *ChunkImpl) AppendTime(t ...int64)

+ func (c *ChunkImpl) CheckChunk()

+ func (c *ChunkImpl) Clone() Chunk

+ func (c *ChunkImpl) Column(i int) Column

+ func (c *ChunkImpl) Columns() []Column

+ func (c *ChunkImpl) Instance() transport.Codec

+ func (c *ChunkImpl) IntervalIndex() []int

+ func (c *ChunkImpl) IntervalLen() int

+ func (c *ChunkImpl) IsNil() bool

+ func (c *ChunkImpl) Len() int

+ func (c *ChunkImpl) Marshal(buf []byte) ([]byte, error)

+ func (c *ChunkImpl) Name() string

+ func (c *ChunkImpl) NumberOfCols() int

+ func (c *ChunkImpl) NumberOfRows() int

+ func (c *ChunkImpl) Release()

+ func (c *ChunkImpl) Reset()

+ func (c *ChunkImpl) ResetIntervalIndex(intervalIndex ...int)

+ func (c *ChunkImpl) ResetTagsAndIndexes(tags []ChunkTags, tagIndex []int)

+ func (c *ChunkImpl) ResetTime(idx int, time int64)

+ func (c *ChunkImpl) RowDataType() hybridqp.RowDataType

+ func (c *ChunkImpl) SetColumn(column Column, i int)

+ func (c *ChunkImpl) SetName(name string)

+ func (c *ChunkImpl) SetRowDataType(r hybridqp.RowDataType)

+ func (c *ChunkImpl) SetTime(time []int64)

+ func (c *ChunkImpl) Size() int

+ func (c *ChunkImpl) SlimChunk(ridIdx []int) Chunk

+ func (c *ChunkImpl) String() string

+ func (c *ChunkImpl) TagIndex() []int

+ func (c *ChunkImpl) TagLen() int

+ func (c *ChunkImpl) Tags() []ChunkTags

+ func (c *ChunkImpl) Time() []int64

+ func (c *ChunkImpl) TimeByIndex(i int) int64

+ func (c *ChunkImpl) TruncateTime(idx int)

+ func (c *ChunkImpl) Unmarshal(buf []byte) error

+ type ChunkMergeTransWorkHelper struct

+ CloseFn func()

+ ConsumeFn func(Chunk)

+ GenerateFn func() Chunk

+ GetInputsFn func() ChunkPorts

+ GetOutputsFn func() ChunkPorts

+ func (helper ChunkMergeTransWorkHelper) Work(ctx context.Context) error

+ type ChunkPort struct

+ OrigiState chan Chunk

+ Redirected bool

+ RowDataType hybridqp.RowDataType

+ State chan Chunk

+ func NewChunkPort(rowDataType hybridqp.RowDataType) *ChunkPort

+ func (p *ChunkPort) Close()

+ func (p *ChunkPort) Connect(to Port)

+ func (p *ChunkPort) ConnectionId() uintptr

+ func (p *ChunkPort) Equal(to Port) bool

+ func (p *ChunkPort) Redirect(to Port)

+ func (p *ChunkPort) Release()

+ type ChunkPorts []*ChunkPort

+ func (ps ChunkPorts) Close()

+ type ChunkShuffleTransWorkHelper struct

+ CloseFn func()

+ ConsumeFn func(Chunk) bool

+ GenerateFn func() Chunk

+ GetInputsFn func() ChunkPorts

+ GetOutputsFn func() ChunkPorts

+ func (helper ChunkShuffleTransWorkHelper) Generate(ctx context.Context) error

+ func (helper ChunkShuffleTransWorkHelper) Work(ctx context.Context) error

+ type ChunkSinkWorkHelper struct

+ ConsumeFn func(Chunk)

+ GetInputFn func() ChunkPort

+ func (helper ChunkSinkWorkHelper) Work(ctx context.Context) error

+ type ChunkSourceWorkHelper struct

+ CloseFn func()

+ GenerateFn func() Chunk

+ GetOutputFn func() ChunkPort

+ func (helper ChunkSourceWorkHelper) Work(ctx context.Context) error

+ type ChunkStruct struct

+ type ChunkTags struct

+ func GetChunkTags() *ChunkTags

+ func NewChunkTags(pts influx.PointTags, dimensions []string) *ChunkTags

+ func NewChunkTagsV2(subset []byte) *ChunkTags

+ func ParseChunkTags(s string) *ChunkTags

+ func (ct *ChunkTags) GetChunkTagAndValues() ([]string, []string)

+ func (ct *ChunkTags) GetChunkTagValue(name string) (string, bool)

+ func (ct *ChunkTags) GetTag() []byte

+ func (ct *ChunkTags) Instance() transport.Codec

+ func (ct *ChunkTags) KeepKeys(keys []string) *ChunkTags

+ func (ct *ChunkTags) KeyValues() map[string]string

+ func (ct *ChunkTags) Marshal(buf []byte) ([]byte, error)

+ func (ct *ChunkTags) Reset()

+ func (ct *ChunkTags) Size() int

+ func (ct *ChunkTags) Subset(keys []string) []byte

+ func (ct *ChunkTags) Unmarshal(buf []byte) error

+ type ChunkValuer struct

+ func NewChunkValuer() *ChunkValuer

+ func (c *ChunkValuer) AtChunkRow(chunk Chunk, index int)

+ func (c *ChunkValuer) SetValuer(_ influxql.Valuer, _ int)

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

+ type ChunkWriter interface

+ Close func()

+ Write func(Chunk)

+ type CircularChunkPool struct

+ func NewCircularChunkPool(chunkNum int, chunkBuilder *ChunkBuilder) *CircularChunkPool

+ func (cp *CircularChunkPool) GetChunk() Chunk

+ func (cp *CircularChunkPool) Release()

+ type CoProcessor interface

+ WorkOnChunk func(Chunk, Chunk, *IteratorParams)

+ func AppendColumnsIteratorHelper(rowDataType hybridqp.RowDataType) CoProcessor

+ func FixedColumnsIteratorHelper(rowDataType hybridqp.RowDataType) CoProcessor

+ func FixedMergeColumnsIteratorHelper(rowDataType hybridqp.RowDataType) CoProcessor

+ func NewAlignCoProcessor(rowDataType hybridqp.RowDataType) CoProcessor

+ func NewIntervalCoProcessor(rowDataType hybridqp.RowDataType) CoProcessor

+ func NewSlidingWindowProcessors(inRowDataType, outRowDataType hybridqp.RowDataType, ...) (CoProcessor, int, int)

+ type CoProcessorImpl struct

+ Routines []Routine

+ func NewCoProcessorImpl(routines ...Routine) *CoProcessorImpl

+ func (p *CoProcessorImpl) AppendRoutine(routines ...Routine)

+ func (p *CoProcessorImpl) WorkOnChunk(in Chunk, out Chunk, params *IteratorParams)

+ type Column interface

+ AppendBooleanValues func(...bool)

+ AppendColumnTimes func(...int64)

+ AppendFloatValues func(...float64)

+ AppendIntegerValues func(...int64)

+ AppendManyNil func(num int)

+ AppendManyNotNil func(num int)

+ AppendNil func()

+ AppendNilsV2 func(dat ...bool)

+ AppendStringBytes func([]byte, []uint32)

+ AppendStringValues func(...string)

+ BitMap func() *Bitmap

+ BooleanValue func(int) bool

+ BooleanValues func() []bool

+ CheckColumn func(int)

+ CloneStringValues func([]byte, []uint32)

+ ColumnTime func(int) int64

+ ColumnTimes func() []int64

+ DataType func() influxql.DataType

+ FloatValue func(int) float64

+ FloatValues func() []float64

+ GetRangeValueIndexV2 func(bmStart, bmEnd int) (s int, e int)

+ GetStringBytes func() ([]byte, []uint32)

+ GetStringValueBytes func(valueBits []byte, value []string, start, end int) ([]byte, []string)

+ GetTimeIndex func(valIdx int) int

+ GetValueIndexV2 func(start int) int

+ IntegerValue func(int) int64

+ IntegerValues func() []int64

+ IsEmpty func() bool

+ IsNilV2 func(int) bool

+ Length func() int

+ Marshal func([]byte) ([]byte, error)

+ NilCount func() int

+ NilsV2 func() *Bitmap

+ Reset func()

+ SetBooleanValues func([]bool)

+ SetColumnTimes func([]int64)

+ SetFloatValues func([]float64)

+ SetIntegerValues func([]int64)

+ SetNilsBitmap func(new *Bitmap)

+ SetStringValues func([]byte, []uint32)

+ Size func() int

+ StringValue func(int) string

+ StringValuesRange func(dst []string, start, end int) []string

+ StringValuesV2 func(dst []string) []string

+ Unmarshal func([]byte) error

+ type ColumnImpl struct

+ func NewColumnImpl(dataType influxql.DataType) *ColumnImpl

+ func (c *ColumnImpl) AppendBooleanValues(values ...bool)

+ func (c *ColumnImpl) AppendColumnTimes(values ...int64)

+ func (c *ColumnImpl) AppendFloatValues(values ...float64)

+ func (c *ColumnImpl) AppendIntegerValues(values ...int64)

+ func (c *ColumnImpl) AppendManyNil(num int)

+ func (c *ColumnImpl) AppendManyNotNil(num int)

+ func (c *ColumnImpl) AppendNil()

+ func (c *ColumnImpl) AppendNilsV2(dat ...bool)

+ func (c *ColumnImpl) AppendStringBytes(val []byte, offset []uint32)

+ func (c *ColumnImpl) AppendStringValues(values ...string)

+ func (c *ColumnImpl) AppendTimes(times ...int64)

+ func (c *ColumnImpl) BitMap() *Bitmap

+ func (c *ColumnImpl) BooleanValue(idx int) bool

+ func (c *ColumnImpl) BooleanValues() []bool

+ func (c *ColumnImpl) CheckColumn(length int)

+ func (c *ColumnImpl) CloneStringValues(val []byte, offset []uint32)

+ func (c *ColumnImpl) ColumnTime(idx int) int64

+ func (c *ColumnImpl) ColumnTimes() []int64

+ func (c *ColumnImpl) DataType() influxql.DataType

+ func (c *ColumnImpl) FloatValue(idx int) float64

+ func (c *ColumnImpl) FloatValues() []float64

+ func (c *ColumnImpl) GetRangeValueIndexV2(bmStart, bmEnd int) (int, int)

+ func (c *ColumnImpl) GetStringBytes() ([]byte, []uint32)

+ func (c *ColumnImpl) GetStringValueBytes(valueBits []byte, value []string, start, end int) ([]byte, []string)

+ func (c *ColumnImpl) GetTimeIndex(valIdx int) int

+ func (c *ColumnImpl) GetValueIndexV2(start int) int

+ func (c *ColumnImpl) Instance() transport.Codec

+ func (c *ColumnImpl) IntegerValue(idx int) int64

+ func (c *ColumnImpl) IntegerValues() []int64

+ func (c *ColumnImpl) IsEmpty() bool

+ func (c *ColumnImpl) IsNilV2(idx int) bool

+ func (c *ColumnImpl) Length() int

+ func (c *ColumnImpl) Marshal(buf []byte) ([]byte, error)

+ func (c *ColumnImpl) NilCount() int

+ func (c *ColumnImpl) NilsV2() *Bitmap

+ func (c *ColumnImpl) Reset()

+ func (c *ColumnImpl) SetBooleanValues(values []bool)

+ func (c *ColumnImpl) SetColumnTimes(values []int64)

+ func (c *ColumnImpl) SetFloatValues(values []float64)

+ func (c *ColumnImpl) SetIntegerValues(values []int64)

+ func (c *ColumnImpl) SetNilsBitmap(new *Bitmap)

+ func (c *ColumnImpl) SetStringValues(val []byte, offset []uint32)

+ func (c *ColumnImpl) Size() int

+ func (c *ColumnImpl) StringValue(idx int) string

+ func (c *ColumnImpl) StringValuesRange(dst []string, start, end int) []string

+ func (c *ColumnImpl) StringValuesV2(dst []string) []string

+ func (c *ColumnImpl) Time(idx int) int64

+ func (c *ColumnImpl) Times() []int64

+ func (c *ColumnImpl) Unmarshal(buf []byte) error

+ type ConditionExprVisitor struct

+ func NewConditionExprVisitor() *ConditionExprVisitor

+ func (c *ConditionExprVisitor) Visit(n influxql.Node) influxql.Visitor

+ type ContextKey string

+ const NowKey

+ type DAG struct

+ ProcessorMap map[Processor]VertexId

+ Vertexs Vertexs

+ func NewDAG(processors Processors) *DAG

+ func (dag *DAG) AddEdge(edges Edges, edge *Edge, from Processor, to Processor) (Edges, error)

+ func (dag *DAG) AddEdges(id VertexId, inputmap map[uintptr]VertexId, outputmap map[uintptr]VertexId) error

+ func (dag *DAG) CyclicGraph() bool

+ func (dag *DAG) Explain(fn func(*DAG, *strings.Builder) VertexWriter) VertexWriter

+ func (dag *DAG) OrphanVertexs() []VertexId

+ func (dag *DAG) Path() int

+ func (dag *DAG) Processors() Processors

+ func (dag *DAG) SinkVertexs() []VertexId

+ func (dag *DAG) Size() int

+ func (dag *DAG) SourceVertexs() []VertexId

+ func (dag *DAG) Span() int

+ func (dag *DAG) Walk(id VertexId, backward bool, fn WalkFn, m map[VertexId]int) error

+ type DAGBuilder struct

+ func NewDAGBuilder(opt query.ProcessorOptions) *DAGBuilder

+ func (b *DAGBuilder) Build(plan hybridqp.QueryNode) (*DAG, error)

+ func (b *DAGBuilder) Visit(plan hybridqp.QueryNode) LogicalPlanVisitor

+ type DataMapStruct struct

+ type DataMaps struct

+ func (d DataMaps) Len() int

+ func (d DataMaps) Less(i, j int) bool

+ func (d DataMaps) Swap(i, j int)

+ type Database struct

+ func NewDatabase(name string, rp string) *Database

+ func (d *Database) AddTable(tbl *Table) error

+ func (d *Database) Name() string

+ func (d *Database) Path() string

+ func (d *Database) Table(name string) (*Table, error)

+ type Edge struct

+ Backward bool

+ InputNumber int

+ OutputNumber int

+ To VertexId

+ func NewEdge(to VertexId, backward bool, inputNumber int, outputNumber int) *Edge

+ type Edges []*Edge

+ type ElapsedItem struct

+ func NewElapsedItem(interval hybridqp.Interval) *ElapsedItem

+ func (f *ElapsedItem) AppendItem(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *ElapsedItem) AppendItemFastFunc(c Chunk, _ int, start, end int, sameInterval bool)

+ func (f *ElapsedItem) AppendItemSlowFunc(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *ElapsedItem) GetBaseTransData() BaseTransData

+ func (f *ElapsedItem) Len() int

+ func (f *ElapsedItem) PrevNil() bool

+ func (f *ElapsedItem) Reset()

+ func (f *ElapsedItem) ResetPrev()

+ type EndGroup struct

+ func NewEndGroup() *EndGroup

+ func (g *EndGroup) Execute(planner HeuPlanner)

+ func (g *EndGroup) Initialize(clearCache bool)

+ type EndPointPair struct

+ Chunk Chunk

+ Ordinal int

+ type EquivalenceExprRewriter struct

+ func (w *EquivalenceExprRewriter) Visit(_ influxql.Node) influxql.Visitor

+ type Error struct

+ func (e *Error) Instance() transport.Codec

+ func (e *Error) Marshal(buf []byte) ([]byte, error)

+ func (e *Error) Size() int

+ func (e *Error) Unmarshal(buf []byte) error

+ type ErrorSignals struct

+ func NewErrorSignals(chCount int) *ErrorSignals

+ func (s *ErrorSignals) Close()

+ func (s *ErrorSignals) Dispatch()

+ func (s *ErrorSignals) Wait(callback func())

+ type Errs struct

+ func NewErrs(chCount int) *Errs

+ func (s *Errs) Close()

+ func (s *Errs) Dispatch(err error)

+ func (s *Errs) Wait(callback func())

+ type ExchangeRole uint8

+ const CONSUMER_ROLE

+ const PRODUCER_ROLE

+ const UNKNOWN_ROLE

+ type ExchangeType uint8

+ const NODE_EXCHANGE

+ const READER_EXCHANGE

+ const SERIES_EXCHANGE

+ const SHARD_EXCHANGE

+ const UNKNOWN_EXCHANGE

+ type ExecutorBuilder struct

+ func NewIndexScanExecutorBuilder(traits *StoreExchangeTraits, enableBinaryTreeMerge int64) *ExecutorBuilder

+ func NewMocStoreExecutorBuilder(traits *StoreExchangeTraits, enableBinaryTreeMerge int64) *ExecutorBuilder

+ func NewQueryExecutorBuilder(enableBinaryTreeMerge int64) *ExecutorBuilder

+ func NewScannerStoreExecutorBuilder(traits *StoreExchangeTraits, s hybridqp.StoreEngine, req *RemoteQuery, ...) *ExecutorBuilder

+ func NewStoreExecutorBuilder(traits *StoreExchangeTraits, enableBinaryTreeMerge int64) *ExecutorBuilder

+ func (builder *ExecutorBuilder) Analyze(span *tracing.Span)

+ func (builder *ExecutorBuilder) Build(node hybridqp.QueryNode) (hybridqp.Executor, error)

+ type ExprRewriteRule interface

+ Rewrite func(hybridqp.Catalog)

+ String func() string

+ type ExprRewriteRules []ExprRewriteRule

+ func (rs ExprRewriteRules) Rewrite(schema hybridqp.Catalog)

+ type FillItem struct

+ func NewFillItem() *FillItem

+ func (f *FillItem) ReSet()

+ func (f *FillItem) Set(prevReadAt, inputReadAt int, interval, start int64, fillValue interface{})

+ type FillProcessor interface

+ func NewFillProcessor(rowDataType hybridqp.RowDataType, schema *QuerySchema) ([]FillProcessor, error)

+ func NewLinearFillProcessor(rowDataType hybridqp.RowDataType) []FillProcessor

+ func NewNullFillProcessor(rowDataType hybridqp.RowDataType, schema *QuerySchema) []FillProcessor

+ func NewNumberFillProcessor(rowDataType hybridqp.RowDataType) []FillProcessor

+ func NewPreviousFillProcessor(rowDataType hybridqp.RowDataType) []FillProcessor

+ type FillTransform struct

+ Inputs ChunkPorts

+ Outputs ChunkPorts

+ func NewFillTransform(inRowDataType []hybridqp.RowDataType, outRowDataType []hybridqp.RowDataType, ...) (*FillTransform, error)

+ func (trans *FillTransform) Close()

+ func (trans *FillTransform) Explain() []ValuePair

+ func (trans *FillTransform) GetInputNumber(port Port) int

+ func (trans *FillTransform) GetInputs() Ports

+ func (trans *FillTransform) GetOutputNumber(port Port) int

+ func (trans *FillTransform) GetOutputs() Ports

+ func (trans *FillTransform) Name() string

+ func (trans *FillTransform) Work(ctx context.Context) error

+ type FillTransformCreator struct

+ func (c *FillTransformCreator) Create(plan LogicalPlan, _ query.ProcessorOptions) (Processor, error)

+ type FilterBlankTransform struct

+ Inputs ChunkPorts

+ Outputs ChunkPorts

+ func NewFilterBlankTransform(inRowDataTypes []hybridqp.RowDataType, outRowDataTypes []hybridqp.RowDataType, ...) *FilterBlankTransform

+ func (trans *FilterBlankTransform) Close()

+ func (trans *FilterBlankTransform) Explain() []ValuePair

+ func (trans *FilterBlankTransform) GetInputNumber(port Port) int

+ func (trans *FilterBlankTransform) GetInputs() Ports

+ func (trans *FilterBlankTransform) GetOutputNumber(port Port) int

+ func (trans *FilterBlankTransform) GetOutputs() Ports

+ func (trans *FilterBlankTransform) Name() string

+ func (trans *FilterBlankTransform) Work(ctx context.Context) error

+ type FilterBlankTransformCreator struct

+ func (c *FilterBlankTransformCreator) Create(plan LogicalPlan, opt query.ProcessorOptions) (Processor, error)

+ type FilterTransform struct

+ CoProcessor CoProcessor

+ Input *ChunkPort

+ Output *ChunkPort

+ ResultChunkPool *CircularChunkPool

+ func NewFilterTransform(inRowDataType hybridqp.RowDataType, outRowDataType hybridqp.RowDataType, ...) *FilterTransform

+ func (trans *FilterTransform) Close()

+ func (trans *FilterTransform) Explain() []ValuePair

+ func (trans *FilterTransform) GetInputNumber(port Port) int

+ func (trans *FilterTransform) GetInputs() Ports

+ func (trans *FilterTransform) GetOutputNumber(port Port) int

+ func (trans *FilterTransform) GetOutputs() Ports

+ func (trans *FilterTransform) Name() string

+ func (trans *FilterTransform) Release() error

+ func (trans *FilterTransform) Work(ctx context.Context) error

+ type FilterTransformCreator struct

+ func (c *FilterTransformCreator) Create(plan LogicalPlan, opt query.ProcessorOptions) (Processor, error)

+ type Finish struct

+ func (e *Finish) Instance() transport.Codec

+ func (e *Finish) Marshal(buf []byte) ([]byte, error)

+ func (e *Finish) Size() int

+ func (e *Finish) Unmarshal(_ []byte) error

+ type Float64AppendIterator struct

+ func NewFloat64AppendIterator() *Float64AppendIterator

+ func (f *Float64AppendIterator) Next(endpoint *IteratorEndpoint, params *IteratorParams)

+ type Float64LimitIterator struct

+ func NewFloat64LimitIterator() *Float64LimitIterator

+ func (f *Float64LimitIterator) Next(endpoint *IteratorEndpoint, params *IteratorParams)

+ type Float64MergeIterator struct

+ func NewFloat64MergeIterator() *Float64MergeIterator

+ func (f *Float64MergeIterator) Next(endpoint *IteratorEndpoint, params *IteratorParams)

+ type FloatAlignIterator struct

+ func NewFloatAlignIterator() *FloatAlignIterator

+ func (f *FloatAlignIterator) Next(endpoint *IteratorEndpoint, _ *IteratorParams)

+ type FloatColFloatDistinctIterator struct

+ func NewFloatColFloatDistinctIterator(inOrdinal, outOrdinal int) *FloatColFloatDistinctIterator

+ func (r *FloatColFloatDistinctIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type FloatColFloatHeapIterator struct

+ func NewFloatColFloatHeapIterator(inOrdinal, outOrdinal int, auxProcessor []*AuxProcessor, ...) *FloatColFloatHeapIterator

+ func (r *FloatColFloatHeapIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type FloatColFloatIntegralIterator struct

+ func NewFloatColFloatIntegralIterator(isSingleCall bool, inOrdinal, outOrdinal int, rowDataType hybridqp.RowDataType, ...) *FloatColFloatIntegralIterator

+ func (r *FloatColFloatIntegralIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type FloatColFloatIterator struct

+ func NewFloatColFloatIterator(fn FloatColFloatReduce, fv FloatColFloatMerge, isSingleCall bool, ...) *FloatColFloatIterator

+ func (r *FloatColFloatIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type FloatColFloatMerge func(prevPoint, currPoint *FloatPoint)

+ type FloatColFloatRateFinalReduce func(firstTime, lastTime int64, firstValue, lastValue float64, ...) (v float64, isNil bool)

+ type FloatColFloatRateIterator struct

+ func NewFloatColFloatRateIterator(fn FloatColFloatRateMiddleReduce, fv FloatColFloatRateFinalReduce, ...) *FloatColFloatRateIterator

+ func (r *FloatColFloatRateIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type FloatColFloatRateMerge func(prevPoints [2]*FloatPoint, interval *hybridqp.Interval) (v float64, isNil bool)

+ type FloatColFloatRateMiddleReduce func(c Chunk, ordinal, start, end int) (firstIndex, lastIndex int, firstValue, lastValue float64, isNil bool)

+ type FloatColFloatRateUpdate func(prevPoints, currPoints [2]*FloatPoint)

+ type FloatColFloatReduce func(c Chunk, ordinal, start, end int) (index int, value float64, isNil bool)

+ type FloatColFloatSampleIterator struct

+ func NewFloatColFloatSampleIterator(sampleNum int, isSingleCall bool, inOrdinal, outOrdinal int, ...) *FloatColFloatSampleIterator

+ func (r *FloatColFloatSampleIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type FloatColFloatSliceIterator struct

+ func NewFloatColFloatSliceIterator(fn FloatColReduceSliceReduce, isSingleCall bool, inOrdinal, outOrdinal int, ...) *FloatColFloatSliceIterator

+ func (r *FloatColFloatSliceIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type FloatColFloatTransIterator struct

+ func NewFloatColFloatTransIterator(isSingleCall bool, inOrdinal, outOrdinal int, rowDataType hybridqp.RowDataType, ...) *FloatColFloatTransIterator

+ func (r *FloatColFloatTransIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type FloatColFloatWindowReduce func(c Chunk, ordinal, start, end int) (index int, value float64, isNil bool)

+ type FloatColIntegerIterator struct

+ func NewFloatColIntegerIterator(fn FloatColIntegerReduce, fv FloatColIntegerMerge, isSingleCall bool, ...) *FloatColIntegerIterator

+ func (r *FloatColIntegerIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type FloatColIntegerMerge func(prevPoint, currPoint *IntegerPoint)

+ type FloatColIntegerReduce func(c Chunk, ordinal, start, end int) (index int, value int64, isNil bool)

+ type FloatColIntegerWindowReduce func(c Chunk, ordinal, start, end int) (index int, value int64, isNil bool)

+ type FloatColReduceSliceReduce func(floatItem *FloatSliceItem) (index int, time int64, value float64, isNil bool)

+ func NewFloatPercentileReduce(percentile float64) FloatColReduceSliceReduce

+ func NewFloatStddevReduce() FloatColReduceSliceReduce

+ type FloatCumulativeSumItem struct

+ func NewFloatCumulativeSumItem() *FloatCumulativeSumItem

+ func (f *FloatCumulativeSumItem) AppendItem(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *FloatCumulativeSumItem) AppendItemFastFunc(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *FloatCumulativeSumItem) AppendItemSlowFunc(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *FloatCumulativeSumItem) GetBaseTransData() BaseTransData

+ func (f *FloatCumulativeSumItem) Len() int

+ func (f *FloatCumulativeSumItem) PrevNil() bool

+ func (f *FloatCumulativeSumItem) Reset()

+ func (f *FloatCumulativeSumItem) ResetPrev()

+ type FloatDerivativeItem struct

+ func NewFloatDerivativeItem(isNonNegative, ascending bool, interval hybridqp.Interval) *FloatDerivativeItem

+ func (f *FloatDerivativeItem) AppendItem(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *FloatDerivativeItem) AppendItemFastFunc(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *FloatDerivativeItem) AppendItemSlowFunc(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *FloatDerivativeItem) GetBaseTransData() BaseTransData

+ func (f *FloatDerivativeItem) Len() int

+ func (f *FloatDerivativeItem) PrevNil() bool

+ func (f *FloatDerivativeItem) Reset()

+ func (f *FloatDerivativeItem) ResetPrev()

+ type FloatDifferenceItem struct

+ func NewFloatDifferenceItem(isNonNegative bool, diff floatDifference) *FloatDifferenceItem

+ func (f *FloatDifferenceItem) AppendItem(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *FloatDifferenceItem) AppendItemFastFunc(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *FloatDifferenceItem) AppendItemSlowFunc(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *FloatDifferenceItem) GetBaseTransData() BaseTransData

+ func (f *FloatDifferenceItem) Len() int

+ func (f *FloatDifferenceItem) PrevNil() bool

+ func (f *FloatDifferenceItem) Reset()

+ func (f *FloatDifferenceItem) ResetPrev()

+ type FloatDistinctItem struct

+ func NewFloatDistinctItem() *FloatDistinctItem

+ func (f *FloatDistinctItem) Len() int

+ func (f *FloatDistinctItem) Less(i, j int) bool

+ func (f *FloatDistinctItem) Nil() bool

+ func (f *FloatDistinctItem) Reset()

+ func (f *FloatDistinctItem) Swap(i, j int)

+ type FloatHeapItem struct

+ func NewFloatHeapItem(n int, cmpByValue, cmpByTime func(a, b *FloatPointItem) bool) *FloatHeapItem

+ func (f *FloatHeapItem) Len() int

+ func (f *FloatHeapItem) Less(i, j int) bool

+ func (f *FloatHeapItem) Pop() interface{}

+ func (f *FloatHeapItem) Push(x interface{})

+ func (f *FloatHeapItem) Reset()

+ func (f *FloatHeapItem) Swap(i, j int)

+ type FloatIntegralItem struct

+ func NewFloatIntegralItem(interval hybridqp.Interval, opt query.ProcessorOptions) *FloatIntegralItem

+ func (f *FloatIntegralItem) AppendItem(c Chunk, ordinal int, start, end int, sameInterval, sameTag bool)

+ func (f *FloatIntegralItem) AppendItemFastFunc(c Chunk, ordinal int, start, end int, sameInterval bool, sameTag bool)

+ func (f *FloatIntegralItem) AppendItemSlowFunc(c Chunk, ordinal int, vs, ve int, sameInterval, sameTag bool)

+ func (f *FloatIntegralItem) CalculateUnit(index int, time int64, value float64)

+ func (f *FloatIntegralItem) Len() int

+ func (f *FloatIntegralItem) Nil() bool

+ func (f *FloatIntegralItem) Reset()

+ func (f *FloatIntegralItem) StartNewInterval(time int64)

+ type FloatIntervalIterator struct

+ func NewFloatIntervalIterator() *FloatIntervalIterator

+ func (f *FloatIntervalIterator) Next(endpoint *IteratorEndpoint, _ *IteratorParams)

+ type FloatLinearFillProcessor struct

+ func NewFloatLinearFillProcessor(inOrdinal, outOrdinal int) *FloatLinearFillProcessor

+ type FloatMovingAverageItem struct

+ func NewFloatMovingAverageItem(n int) *FloatMovingAverageItem

+ func (f *FloatMovingAverageItem) AppendItem(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *FloatMovingAverageItem) AppendItemFastFunc(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *FloatMovingAverageItem) AppendItemSlowFunc(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *FloatMovingAverageItem) GetBaseTransData() BaseTransData

+ func (f *FloatMovingAverageItem) Len() int

+ func (f *FloatMovingAverageItem) PrevNil() bool

+ func (f *FloatMovingAverageItem) Reset()

+ func (f *FloatMovingAverageItem) ResetPrev()

+ type FloatNullFillProcessor struct

+ func NewFloatNullFillProcessor(inOrdinal, outOrdinal int) *FloatNullFillProcessor

+ type FloatNumberFillProcessor struct

+ func NewFloatNumberFillProcessor(inOrdinal, outOrdinal int) *FloatNumberFillProcessor

+ type FloatPoint struct

+ func (p *FloatPoint) Assign(c *FloatPoint)

+ func (p *FloatPoint) Reset()

+ func (p *FloatPoint) Set(index int, time int64, value float64)

+ type FloatPointItem struct

+ func NewFloatPointItem(time int64, value float64) *FloatPointItem

+ type FloatPointMerge func(prevPoint, currPoint *FloatPoint)

+ type FloatPreviousFillProcessor struct

+ func NewFloatPreviousFillProcessor(inOrdinal, outOrdinal int) *FloatPreviousFillProcessor

+ type FloatSampleItem struct

+ func NewFloatSampleItem(items []FloatPointItem) *FloatSampleItem

+ func (f *FloatSampleItem) Len() int

+ func (f *FloatSampleItem) Less(i, j int) bool

+ func (f *FloatSampleItem) Reset()

+ func (f *FloatSampleItem) Swap(i, j int)

+ type FloatSliceItem struct

+ func NewFloatSliceItem() *FloatSliceItem

+ func (f *FloatSliceItem) AppendItem(c Chunk, ordinal, start, end int)

+ func (f *FloatSliceItem) Len() int

+ func (f *FloatSliceItem) Less(i, j int) bool

+ func (f *FloatSliceItem) Reset()

+ func (f *FloatSliceItem) Swap(i, j int)

+ type FloatSlidingWindow struct

+ func NewFloatSlidingWindow(slidingNum int) *FloatSlidingWindow

+ func (w *FloatSlidingWindow) IsNil() bool

+ func (w *FloatSlidingWindow) Len() int

+ func (w *FloatSlidingWindow) Reset()

+ func (w *FloatSlidingWindow) SetPoint(value float64, isNil bool, index int)

+ type FloatSlidingWindowFloatIterator struct

+ func NewFloatSlidingWindowFloatIterator(fwr FloatColFloatWindowReduce, fpm FloatPointMerge, fwm FloatWindowMerge, ...) *FloatSlidingWindowFloatIterator

+ func (r *FloatSlidingWindowFloatIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type FloatSlidingWindowIntegerIterator struct

+ func NewFloatSlidingWindowIntegerIterator(fwr FloatColIntegerWindowReduce, fpm IntegerPointMerge, fwm IntegerWindowMerge, ...) *FloatSlidingWindowIntegerIterator

+ func (r *FloatSlidingWindowIntegerIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type FloatTimeColFloatIterator struct

+ func NewFloatTimeColFloatIterator(fn FloatTimeColFloatReduce, fv FloatTimeColFloatMerge, ...) *FloatTimeColFloatIterator

+ func (r *FloatTimeColFloatIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type FloatTimeColFloatMerge func(prevPoint, currPoint *FloatPoint)

+ type FloatTimeColFloatReduce func(c Chunk, ordinal, start, end int) (index int, value float64, isNil bool)

+ type FloatWindowMerge func(prevWindow, currWindow *FloatSlidingWindow, fpm FloatPointMerge)

+ type GraphIterator struct

+ func NewGraphIterator(capacity int) *GraphIterator

+ func (iter *GraphIterator) HasNext() bool

+ func (iter *GraphIterator) Next() *HeuVertex

+ func (iter *GraphIterator) Reset()

+ func (iter *GraphIterator) Size() int

+ func (iter *GraphIterator) Visit(vertex *HeuVertex) HeuDagVisitor

+ type GroupByTransform struct

+ func NewGroupByTransform(inRowDataType hybridqp.RowDataType, outRowDataType hybridqp.RowDataType, ...) *GroupByTransform

+ func (trans *GroupByTransform) Close()

+ func (trans *GroupByTransform) Explain() []ValuePair

+ func (trans *GroupByTransform) GetInputNumber(_ Port) int

+ func (trans *GroupByTransform) GetInputs() Ports

+ func (trans *GroupByTransform) GetOutputNumber(_ Port) int

+ func (trans *GroupByTransform) GetOutputs() Ports

+ func (trans *GroupByTransform) Name() string

+ func (trans *GroupByTransform) Release() error

+ func (trans *GroupByTransform) Work(ctx context.Context) error

+ type GroupByTransformCreator struct

+ func (c *GroupByTransformCreator) Create(plan LogicalPlan, opt query.ProcessorOptions) (Processor, error)

+ type Handler func(interface{}) error

+ type HeapItems struct

+ Items []*Item

+ func (h *HeapItems) GetBreakPoint() *BreakPoint

+ func (h *HeapItems) Len() int

+ func (h *HeapItems) Less(i, j int) bool

+ func (h *HeapItems) Pop() interface{}

+ func (h *HeapItems) Push(x interface{})

+ func (h *HeapItems) Swap(i, j int)

+ type HeuDag struct

+ func NewHeuDag() *HeuDag

+ func (dag *HeuDag) AddEdge(from *HeuVertex, to *HeuVertex) bool

+ func (dag *HeuDag) AddVerteix(vertex *HeuVertex) bool

+ func (dag *HeuDag) AllParents(vertex *HeuVertex) []*HeuVertex

+ func (dag *HeuDag) Contains(vertex *HeuVertex) bool

+ func (dag *HeuDag) DigestSize() int

+ func (dag *HeuDag) EdgeSize() int

+ func (dag *HeuDag) GetGraphIterator(vertex *HeuVertex, matchOrder HeuMatchOrder) *GraphIterator

+ func (dag *HeuDag) GetVertexByDigest(digest string) (*HeuVertex, bool)

+ func (dag *HeuDag) RemoveEdge(from *HeuVertex, to *HeuVertex)

+ func (dag *HeuDag) RemoveVertex(vertex *HeuVertex)

+ func (dag *HeuDag) UpdateVerteix(vertex *HeuVertex, node hybridqp.QueryNode)

+ func (dag *HeuDag) VertexSize() int

+ func (dag *HeuDag) WalkHeuDag(visitor HeuDagVisitor, vertex *HeuVertex)

+ type HeuDagVisitor interface

+ Visit func(vertex *HeuVertex) HeuDagVisitor

+ type HeuEdge struct

+ func NewHeuEdge(from *HeuVertex, to *HeuVertex) *HeuEdge

+ type HeuInstruction interface

+ Execute func(HeuPlanner)

+ Initialize func(bool)

+ type HeuMatchOrder uint8

+ const ARBITRARY

+ const BOTTOM_UP

+ const DEPTH_FIRST

+ const TOP_DOWN

+ type HeuPlanner interface

+ ExecuteInstruction func(HeuInstruction)

+ Vertex func(node hybridqp.QueryNode) (*HeuVertex, bool)

+ type HeuPlannerImpl struct

+ func NewHeuPlannerImpl(program *HeuProgram) *HeuPlannerImpl

+ func (p *HeuPlannerImpl) AddRule(rule OptRule) bool

+ func (p *HeuPlannerImpl) ExecuteInstruction(instruction HeuInstruction)

+ func (p *HeuPlannerImpl) FindBestExp() hybridqp.QueryNode

+ func (p *HeuPlannerImpl) SetRoot(root hybridqp.QueryNode)

+ func (p *HeuPlannerImpl) Transformations() int

+ func (p *HeuPlannerImpl) Vertex(node hybridqp.QueryNode) (*HeuVertex, bool)

+ func (p *HeuPlannerImpl) Visit(node hybridqp.QueryNode) hybridqp.QueryNodeVisitor

+ type HeuProgram struct

+ func NewHeuProgram(instructions []HeuInstruction) *HeuProgram

+ func (p *HeuProgram) Initialize(clearCache bool)

+ type HeuProgramBuilder struct

+ func NewHeuProgramBuilder() *HeuProgramBuilder

+ func (b *HeuProgramBuilder) AddRuleCatagory(ruleCatagory OptRuleCatagory) *HeuProgramBuilder

+ func (b *HeuProgramBuilder) Build() *HeuProgram

+ func (b *HeuProgramBuilder) Clear()

+ type HeuVertex struct

+ func NewHeuVertex(node hybridqp.QueryNode) *HeuVertex

+ func (v *HeuVertex) ApplyTrait(trait hybridqp.Trait)

+ func (v *HeuVertex) Children() []hybridqp.QueryNode

+ func (v *HeuVertex) Clone() hybridqp.QueryNode

+ func (v *HeuVertex) DeriveOperations()

+ func (v *HeuVertex) Digest() string

+ func (v *HeuVertex) Dummy() bool

+ func (v *HeuVertex) Equals(rhs *HeuVertex) bool

+ func (v *HeuVertex) GetParentVertex(vertex *HeuVertex) *HeuVertex

+ func (v *HeuVertex) ID() uint64

+ func (v *HeuVertex) MarshalBinary() ([]byte, error)

+ func (v *HeuVertex) Node() hybridqp.QueryNode

+ func (v *HeuVertex) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (v *HeuVertex) ReplaceChildren(children []hybridqp.QueryNode)

+ func (v *HeuVertex) ReplaceNode(node hybridqp.QueryNode)

+ func (v *HeuVertex) RowDataType() hybridqp.RowDataType

+ func (v *HeuVertex) RowExprOptions() []hybridqp.ExprOptions

+ func (v *HeuVertex) Schema() hybridqp.Catalog

+ func (v *HeuVertex) SetInputs(_ []hybridqp.QueryNode)

+ func (v *HeuVertex) SetSchema(schema hybridqp.Catalog)

+ func (v *HeuVertex) String() string

+ func (v *HeuVertex) SubTreeEqual(vertex *HeuVertex) bool

+ func (v *HeuVertex) Trait() hybridqp.Trait

+ func (v *HeuVertex) Type() string

+ func (v *HeuVertex) UnmarshalBinary(_ *internal.QueryNode) error

+ type HeuVertexInfo struct

+ func NewHeuVertexInfo() *HeuVertexInfo

+ func (info *HeuVertexInfo) AddBackwardEdge(edge *HeuEdge)

+ func (info *HeuVertexInfo) AddDirectEdge(edge *HeuEdge)

+ type HeuVertexWriter interface

+ Explain func(*HeuVertex)

+ Item func(string, interface{})

+ String func() string

+ type HeuVertexs []*HeuVertex

+ func (hvs HeuVertexs) IndexOf(vertex *HeuVertex) int

+ type HttpChunkSender struct

+ ResetTime bool

+ RowChunk RowChunk

+ func NewHttpChunkSender(opt query.ProcessorOptions, colLength int) *HttpChunkSender

+ func (w *HttpChunkSender) Close()

+ func (w *HttpChunkSender) GetRows(chunk Chunk) models.Rows

+ func (w *HttpChunkSender) Write(chunk Chunk, lastChunk bool) bool

+ type HttpSenderHintTransform struct

+ Writer *HttpChunkSender

+ func NewHttpSenderHintTransform(inRowDataType hybridqp.RowDataType, schema *QuerySchema) *HttpSenderHintTransform

+ func (trans *HttpSenderHintTransform) Close()

+ func (trans *HttpSenderHintTransform) Explain() []ValuePair

+ func (trans *HttpSenderHintTransform) GetInputNumber(_ Port) int

+ func (trans *HttpSenderHintTransform) GetInputs() Ports

+ func (trans *HttpSenderHintTransform) GetOutputNumber(_ Port) int

+ func (trans *HttpSenderHintTransform) GetOutputs() Ports

+ func (trans *HttpSenderHintTransform) Name() string

+ func (trans *HttpSenderHintTransform) Work(ctx context.Context) error

+ type HttpSenderHintTransformCreator struct

+ func (c *HttpSenderHintTransformCreator) Create(plan LogicalPlan, _ query.ProcessorOptions) (Processor, error)

+ type HttpSenderTransform struct

+ Sender *http.ResponseWriter

+ Writer *HttpChunkSender

+ func NewHttpSenderTransform(inRowDataType hybridqp.RowDataType, schema *QuerySchema) *HttpSenderTransform

+ func (trans *HttpSenderTransform) Close()

+ func (trans *HttpSenderTransform) Explain() []ValuePair

+ func (trans *HttpSenderTransform) GetInputNumber(_ Port) int

+ func (trans *HttpSenderTransform) GetInputs() Ports

+ func (trans *HttpSenderTransform) GetOutputNumber(_ Port) int

+ func (trans *HttpSenderTransform) GetOutputs() Ports

+ func (trans *HttpSenderTransform) Name() string

+ func (trans *HttpSenderTransform) Work(ctx context.Context) error

+ type HttpSenderTransformCreator struct

+ func (c *HttpSenderTransformCreator) Create(plan LogicalPlan, _ query.ProcessorOptions) (Processor, error)

+ type IndexScanExtraInfo struct

+ Req *RemoteQuery

+ ShardID uint64

+ Store hybridqp.StoreEngine

+ UnRefDbPt UnRefDbPt

+ func (e *IndexScanExtraInfo) Clone() *IndexScanExtraInfo

+ type IndexScanTransform struct

+ NewChunk Chunk

+ func NewIndexScanTransform(outRowDataType hybridqp.RowDataType, ops []hybridqp.ExprOptions, ...) *IndexScanTransform

+ func (trans *IndexScanTransform) Close()

+ func (trans *IndexScanTransform) Explain() []ValuePair

+ func (trans *IndexScanTransform) GetInputNumber(_ Port) int

+ func (trans *IndexScanTransform) GetInputs() Ports

+ func (trans *IndexScanTransform) GetOutputNumber(_ Port) int

+ func (trans *IndexScanTransform) GetOutputs() Ports

+ func (trans *IndexScanTransform) Name() string

+ func (trans *IndexScanTransform) Release() error

+ func (trans *IndexScanTransform) Work(ctx context.Context) error

+ type IndexScanTransformCreator struct

+ func (c *IndexScanTransformCreator) Create(plan LogicalPlan, opt query.ProcessorOptions) (Processor, error)

+ type Int64AppendIterator struct

+ func NewInt64AppendIterator() *Int64AppendIterator

+ func (f *Int64AppendIterator) Next(endpoint *IteratorEndpoint, params *IteratorParams)

+ type Int64LimitIterator struct

+ func NewInt64LimitIterator() *Int64LimitIterator

+ func (f *Int64LimitIterator) Next(endpoint *IteratorEndpoint, params *IteratorParams)

+ type Int64MergeIterator struct

+ func NewInt64MergeIterator() *Int64MergeIterator

+ func (f *Int64MergeIterator) Next(endpoint *IteratorEndpoint, params *IteratorParams)

+ type IntegerAlignIterator struct

+ func NewIntegerAlignIterator() *IntegerAlignIterator

+ func (f *IntegerAlignIterator) Next(endpoint *IteratorEndpoint, _ *IteratorParams)

+ type IntegerColFloatIntegralIterator struct

+ func NewIntegerColFloatIntegralIterator(isSingleCall bool, inOrdinal, outOrdinal int, rowDataType hybridqp.RowDataType, ...) *IntegerColFloatIntegralIterator

+ func (r *IntegerColFloatIntegralIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type IntegerColFloatIterator struct

+ func NewIntegerColFloatIterator(fn IntegerColFloatReduce, fv IntegerColFloatMerge, isSingleCall bool, ...) *IntegerColFloatIterator

+ func (r *IntegerColFloatIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type IntegerColFloatMerge func(prevPoint, currPoint *FloatPoint)

+ type IntegerColFloatRateFinalReduce func(firstTime, lastTime int64, firstValue, lastValue int64, ...) (v float64, isNil bool)

+ type IntegerColFloatRateIterator struct

+ func NewIntegerColFloatRateIterator(fn IntegerColFloatRateMiddleReduce, fv IntegerColFloatRateFinalReduce, ...) *IntegerColFloatRateIterator

+ func (r *IntegerColFloatRateIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type IntegerColFloatRateMerge func(prevPoints [2]*IntegerPoint, interval *hybridqp.Interval) (v float64, isNil bool)

+ type IntegerColFloatRateMiddleReduce func(c Chunk, ordinal, start, end int) (firstIndex, lastIndex int, firstValue, lastValue int64, isNil bool)

+ type IntegerColFloatRateUpdate func(prevPoints, currPoints [2]*IntegerPoint)

+ type IntegerColFloatReduce func(c Chunk, ordinal, start, end int) (index int, value float64, isNil bool)

+ type IntegerColFloatTransIterator struct

+ func NewIntegerColFloatTransIterator(isSingleCall bool, inOrdinal, outOrdinal int, rowDataType hybridqp.RowDataType, ...) *IntegerColFloatTransIterator

+ func (r *IntegerColFloatTransIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type IntegerColIntegerDistinctIterator struct

+ func NewIntegerColIntegerDistinctIterator(inOrdinal, outOrdinal int) *IntegerColIntegerDistinctIterator

+ func (r *IntegerColIntegerDistinctIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type IntegerColIntegerHeapIterator struct

+ func NewIntegerColIntegerHeapIterator(inOrdinal, outOrdinal int, auxProcessor []*AuxProcessor, ...) *IntegerColIntegerHeapIterator

+ func (r *IntegerColIntegerHeapIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type IntegerColIntegerIterator struct

+ func NewIntegerColIntegerIterator(fn IntegerColIntegerReduce, fv IntegerColIntegerMerge, isSingleCall bool, ...) *IntegerColIntegerIterator

+ func (r *IntegerColIntegerIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type IntegerColIntegerMerge func(prevPoint, currPoint *IntegerPoint)

+ type IntegerColIntegerReduce func(c Chunk, ordinal, start, end int) (index int, value int64, isNil bool)

+ type IntegerColIntegerSampleIterator struct

+ func NewIntegerColIntegerSampleIterator(sampleNum int, isSingleCall bool, inOrdinal, outOrdinal int, ...) *IntegerColIntegerSampleIterator

+ func (r *IntegerColIntegerSampleIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type IntegerColIntegerSliceIterator struct

+ func NewIntegerColIntegerSliceIterator(fn IntegerColReduceSliceReduce, isSingleCall bool, inOrdinal, outOrdinal int, ...) *IntegerColIntegerSliceIterator

+ func (r *IntegerColIntegerSliceIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type IntegerColIntegerTransIterator struct

+ func NewIntegerColIntegerTransIterator(isSingleCall bool, inOrdinal, outOrdinal int, rowDataType hybridqp.RowDataType, ...) *IntegerColIntegerTransIterator

+ func (r *IntegerColIntegerTransIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type IntegerColIntegerWindowReduce func(c Chunk, ordinal, start, end int) (index int, value int64, isNil bool)

+ type IntegerColReduceSliceReduce func(integerItem *IntegerSliceItem) (index int, time int64, value float64, isNil bool)

+ func NewIntegerPercentileReduce(percentile float64) IntegerColReduceSliceReduce

+ func NewIntegerStddevReduce() IntegerColReduceSliceReduce

+ type IntegerCumulativeSumItem struct

+ func NewIntegerCumulativeSumItem() *IntegerCumulativeSumItem

+ func (f *IntegerCumulativeSumItem) AppendItem(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *IntegerCumulativeSumItem) AppendItemFastFunc(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *IntegerCumulativeSumItem) AppendItemSlowFunc(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *IntegerCumulativeSumItem) GetBaseTransData() BaseTransData

+ func (f *IntegerCumulativeSumItem) Len() int

+ func (f *IntegerCumulativeSumItem) PrevNil() bool

+ func (f *IntegerCumulativeSumItem) Reset()

+ func (f *IntegerCumulativeSumItem) ResetPrev()

+ type IntegerDerivativeItem struct

+ func NewIntegerDerivativeItem(isNonNegative, ascending bool, interval hybridqp.Interval) *IntegerDerivativeItem

+ func (f *IntegerDerivativeItem) AppendItem(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *IntegerDerivativeItem) AppendItemFastFunc(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *IntegerDerivativeItem) AppendItemSlowFunc(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *IntegerDerivativeItem) GetBaseTransData() BaseTransData

+ func (f *IntegerDerivativeItem) Len() int

+ func (f *IntegerDerivativeItem) PrevNil() bool

+ func (f *IntegerDerivativeItem) Reset()

+ func (f *IntegerDerivativeItem) ResetPrev()

+ type IntegerDifferenceItem struct

+ func NewIntegerDifferenceItem(isNonNegative bool, diff integerDifference) *IntegerDifferenceItem

+ func (f *IntegerDifferenceItem) AppendItem(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *IntegerDifferenceItem) AppendItemFastFunc(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *IntegerDifferenceItem) AppendItemSlowFunc(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *IntegerDifferenceItem) GetBaseTransData() BaseTransData

+ func (f *IntegerDifferenceItem) Len() int

+ func (f *IntegerDifferenceItem) PrevNil() bool

+ func (f *IntegerDifferenceItem) Reset()

+ func (f *IntegerDifferenceItem) ResetPrev()

+ type IntegerDistinctItem struct

+ func NewIntegerDistinctItem() *IntegerDistinctItem

+ func (f *IntegerDistinctItem) Len() int

+ func (f *IntegerDistinctItem) Less(i, j int) bool

+ func (f *IntegerDistinctItem) Nil() bool

+ func (f *IntegerDistinctItem) Reset()

+ func (f *IntegerDistinctItem) Swap(i, j int)

+ type IntegerHeapItem struct

+ func NewIntegerHeapItem(n int, cmpByValue, cmpByTime func(a, b *IntegerPointItem) bool) *IntegerHeapItem

+ func (f *IntegerHeapItem) Len() int

+ func (f *IntegerHeapItem) Less(i, j int) bool

+ func (f *IntegerHeapItem) Pop() interface{}

+ func (f *IntegerHeapItem) Push(x interface{})

+ func (f *IntegerHeapItem) Reset()

+ func (f *IntegerHeapItem) Swap(i, j int)

+ type IntegerIntegralItem struct

+ func NewIntegerIntegralItem(interval hybridqp.Interval, opt query.ProcessorOptions) *IntegerIntegralItem

+ func (f *IntegerIntegralItem) AppendItem(c Chunk, ordinal int, start, end int, sameInterval, sameTag bool)

+ func (f *IntegerIntegralItem) AppendItemFastFunc(c Chunk, ordinal int, start, end int, sameInterval bool, sameTag bool)

+ func (f *IntegerIntegralItem) AppendItemSlowFunc(c Chunk, ordinal int, vs, ve int, sameInterval, sameTag bool)

+ func (f *IntegerIntegralItem) CalculateUnit(index int, time int64, value float64)

+ func (f *IntegerIntegralItem) Len() int

+ func (f *IntegerIntegralItem) Nil() bool

+ func (f *IntegerIntegralItem) Reset()

+ func (f *IntegerIntegralItem) StartNewInterval(time int64)

+ type IntegerIntervalIterator struct

+ func NewIntegerIntervalIterator() *IntegerIntervalIterator

+ func (f *IntegerIntervalIterator) Next(endpoint *IteratorEndpoint, _ *IteratorParams)

+ type IntegerLinearFillProcessor struct

+ func NewIntegerLinearFillProcessor(inOrdinal, outOrdinal int) *IntegerLinearFillProcessor

+ type IntegerMovingAverageItem struct

+ func NewIntegerMovingAverageItem(n int) *IntegerMovingAverageItem

+ func (f *IntegerMovingAverageItem) AppendItem(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *IntegerMovingAverageItem) AppendItemFastFunc(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *IntegerMovingAverageItem) AppendItemSlowFunc(c Chunk, ordinal int, start, end int, sameInterval bool)

+ func (f *IntegerMovingAverageItem) GetBaseTransData() BaseTransData

+ func (f *IntegerMovingAverageItem) Len() int

+ func (f *IntegerMovingAverageItem) PrevNil() bool

+ func (f *IntegerMovingAverageItem) Reset()

+ func (f *IntegerMovingAverageItem) ResetPrev()

+ type IntegerNullFillProcessor struct

+ func NewIntegerNullFillProcessor(inOrdinal, outOrdinal int) *IntegerNullFillProcessor

+ type IntegerNumberFillProcessor struct

+ func NewIntegerNumberFillProcessor(inOrdinal, outOrdinal int) *IntegerNumberFillProcessor

+ type IntegerPoint struct

+ func (p *IntegerPoint) Assign(c *IntegerPoint)

+ func (p *IntegerPoint) Reset()

+ func (p *IntegerPoint) Set(index int, time int64, value int64)

+ type IntegerPointItem struct

+ func NewIntegerPointItem(time int64, value int64) *IntegerPointItem

+ type IntegerPointMerge func(prevPoint, currPoint *IntegerPoint)

+ type IntegerPreviousFillProcessor struct

+ func NewIntegerPreviousFillProcessor(inOrdinal, outOrdinal int) *IntegerPreviousFillProcessor

+ type IntegerSampleItem struct

+ func NewIntegerSampleItem(items []IntegerPointItem) *IntegerSampleItem

+ func (f *IntegerSampleItem) Len() int

+ func (f *IntegerSampleItem) Less(i, j int) bool

+ func (f *IntegerSampleItem) Reset()

+ func (f *IntegerSampleItem) Swap(i, j int)

+ type IntegerSliceItem struct

+ func NewIntegerSliceItem() *IntegerSliceItem

+ func (f *IntegerSliceItem) AppendItem(c Chunk, ordinal, start, end int)

+ func (f *IntegerSliceItem) Len() int

+ func (f *IntegerSliceItem) Less(i, j int) bool

+ func (f *IntegerSliceItem) Reset()

+ func (f *IntegerSliceItem) Swap(i, j int)

+ type IntegerSlidingWindow struct

+ func NewIntegerSlidingWindow(slidingNum int) *IntegerSlidingWindow

+ func (w *IntegerSlidingWindow) IsNil() bool

+ func (w *IntegerSlidingWindow) Len() int

+ func (w *IntegerSlidingWindow) Reset()

+ func (w *IntegerSlidingWindow) SetPoint(value int64, isNil bool, index int)

+ type IntegerSlidingWindowIntegerIterator struct

+ func NewIntegerSlidingWindowIntegerIterator(fwr IntegerColIntegerWindowReduce, fpm IntegerPointMerge, ...) *IntegerSlidingWindowIntegerIterator

+ func (r *IntegerSlidingWindowIntegerIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type IntegerTimeColIntegerIterator struct

+ func NewIntegerTimeColIntegerIterator(fn IntegerTimeColIntegerReduce, fv IntegerTimeColIntegerMerge, ...) *IntegerTimeColIntegerIterator

+ func (r *IntegerTimeColIntegerIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type IntegerTimeColIntegerMerge func(prevPoint, currPoint *IntegerPoint)

+ type IntegerTimeColIntegerReduce func(c Chunk, ordinal, start, end int) (index int, value int64, isNil bool)

+ type IntegerWindowMerge func(prevWindow, currWindow *IntegerSlidingWindow, fpm IntegerPointMerge)

+ type IntervalToProjectInSubQueryRule struct

+ func NewIntervalToProjectInSubQueryRule(description string) *IntervalToProjectInSubQueryRule

+ func (r *IntervalToProjectInSubQueryRule) Catagory() OptRuleCatagory

+ func (r *IntervalToProjectInSubQueryRule) Equals(rhs OptRule) bool

+ func (r *IntervalToProjectInSubQueryRule) OnMatch(call *OptRuleCall)

+ func (r *IntervalToProjectInSubQueryRule) ToString() string

+ type IntervalTransform struct

+ Inputs ChunkPorts

+ Outputs ChunkPorts

+ func NewIntervalTransform(inRowDataTypes []hybridqp.RowDataType, outRowDataTypes []hybridqp.RowDataType, ...) *IntervalTransform

+ func (trans *IntervalTransform) Close()

+ func (trans *IntervalTransform) Explain() []ValuePair

+ func (trans *IntervalTransform) GetInputNumber(port Port) int

+ func (trans *IntervalTransform) GetInputs() Ports

+ func (trans *IntervalTransform) GetOutputNumber(port Port) int

+ func (trans *IntervalTransform) GetOutputs() Ports

+ func (trans *IntervalTransform) Name() string

+ func (trans *IntervalTransform) Work(ctx context.Context) error

+ type IntervalTransformCreator struct

+ func (c *IntervalTransformCreator) Create(plan LogicalPlan, opt query.ProcessorOptions) (Processor, error)

+ type Item struct

+ ChunkBuf Chunk

+ Index int

+ Input int

+ IntervalIndex int

+ TagIndex int

+ func NewItem(in int, c Chunk) *Item

+ func (it *Item) GetTag(i int) (ChunkTags, bool)

+ func (it *Item) GetTimeAndTag(i int) (int64, ChunkTags, bool)

+ func (it *Item) IntervalLen() int

+ func (it *Item) IsEmpty() bool

+ func (it *Item) IsSortedEmpty() bool

+ func (it *Item) Len() int

+ func (it *Item) TagSwitch(i int) bool

+ type Iterator interface

+ Next func(*IteratorEndpoint, *IteratorParams)

+ type IteratorEndpoint struct

+ InputPoint EndPointPair

+ OutputPoint EndPointPair

+ type IteratorParams struct

+ Table ReflectionTable

+ type LimitPushdownToExchangeRule struct

+ func NewLimitPushdownToExchangeRule(description string) *LimitPushdownToExchangeRule

+ func (r *LimitPushdownToExchangeRule) Catagory() OptRuleCatagory

+ func (r *LimitPushdownToExchangeRule) Equals(rhs OptRule) bool

+ func (r *LimitPushdownToExchangeRule) OnMatch(call *OptRuleCall)

+ func (r *LimitPushdownToExchangeRule) ToString() string

+ type LimitPushdownToReaderRule struct

+ func NewLimitPushdownToReaderRule(description string) *LimitPushdownToReaderRule

+ func (r *LimitPushdownToReaderRule) Catagory() OptRuleCatagory

+ func (r *LimitPushdownToReaderRule) Equals(rhs OptRule) bool

+ func (r *LimitPushdownToReaderRule) OnMatch(call *OptRuleCall)

+ func (r *LimitPushdownToReaderRule) ToString() string

+ type LimitPushdownToSeriesRule struct

+ func NewLimitPushdownToSeriesRule(description string) *LimitPushdownToSeriesRule

+ func (r *LimitPushdownToSeriesRule) Catagory() OptRuleCatagory

+ func (r *LimitPushdownToSeriesRule) Equals(rhs OptRule) bool

+ func (r *LimitPushdownToSeriesRule) OnMatch(call *OptRuleCall)

+ func (r *LimitPushdownToSeriesRule) ToString() string

+ type LimitTransform struct

+ ChunkInit bool

+ CoProcessor CoProcessor

+ Count int

+ CurrItem Chunk

+ Inputs ChunkPorts

+ IntervalIndex int

+ LimitHelper func()

+ NewChunk Chunk

+ Opt query.ProcessorOptions

+ Outputs ChunkPorts

+ PreTag ChunkTags

+ TagIndex int

+ func NewLimitTransform(inRowDataType []hybridqp.RowDataType, outRowDataType []hybridqp.RowDataType, ...) *LimitTransform

+ func (trans *LimitTransform) AppendPoint(chunk Chunk, in int)

+ func (trans *LimitTransform) AppendPoints(chunk Chunk, in int)

+ func (trans *LimitTransform) Close()

+ func (trans *LimitTransform) Explain() []ValuePair

+ func (trans *LimitTransform) GetInputNumber(port Port) int

+ func (trans *LimitTransform) GetInputs() Ports

+ func (trans *LimitTransform) GetMultiRowsIndexPara() int

+ func (trans *LimitTransform) GetOutputNumber(port Port) int

+ func (trans *LimitTransform) GetOutputs() Ports

+ func (trans *LimitTransform) GetSingleRowPara() int

+ func (trans *LimitTransform) IntervalIndexGen()

+ func (trans *LimitTransform) MultipleRowsIgnoreTagLimitHelper()

+ func (trans *LimitTransform) MultipleRowsLimitHelper()

+ func (trans *LimitTransform) Name() string

+ func (trans *LimitTransform) SameGroup(i int) bool

+ func (trans *LimitTransform) SendChunk()

+ func (trans *LimitTransform) SetDag(dag *TransformDag)

+ func (trans *LimitTransform) SetVertex(vertex *TransformVertex)

+ func (trans *LimitTransform) SingleRowIgnoreTagLimitHelper()

+ func (trans *LimitTransform) SingleRowLimitHelper()

+ func (trans *LimitTransform) Visit(vertex *TransformVertex) TransformVertexVisitor

+ func (trans *LimitTransform) Work(ctx context.Context) error

+ type LimitTransformCreator struct

+ func (c *LimitTransformCreator) Create(plan LogicalPlan, opt query.ProcessorOptions) (Processor, error)

+ type LimitTransformParameters struct

+ Limit int

+ LimitType hybridqp.LimitType

+ Offset int

+ type LogicalAggregate struct

+ func NewCountDistinctAggregate(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalAggregate

+ func NewLogicalAggregate(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalAggregate

+ func NewLogicalTagSetAggregate(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalAggregate

+ func (p *LogicalAggregate) Children() []hybridqp.QueryNode

+ func (p *LogicalAggregate) Clone() hybridqp.QueryNode

+ func (p *LogicalAggregate) CountToSum()

+ func (p *LogicalAggregate) DeriveOperations()

+ func (p *LogicalAggregate) Digest() string

+ func (p *LogicalAggregate) Dummy() bool

+ func (p *LogicalAggregate) Explain(writer LogicalPlanWriter)

+ func (p *LogicalAggregate) ForwardCallArgs()

+ func (p *LogicalAggregate) MarshalBinary() ([]byte, error)

+ func (p *LogicalAggregate) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalAggregate) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalAggregate) RowDataType() hybridqp.RowDataType

+ func (p *LogicalAggregate) RowExprOptions() []hybridqp.ExprOptions

+ func (p *LogicalAggregate) Schema() hybridqp.Catalog

+ func (p *LogicalAggregate) SetInputs(inputs []hybridqp.QueryNode)

+ func (p *LogicalAggregate) String() string

+ func (p *LogicalAggregate) Type() string

+ func (p *LogicalAggregate) UnmarshalBinary(pb *internal.QueryNode) error

+ type LogicalAlign struct

+ func NewLogicalAlign(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalAlign

+ func (p *LogicalAlign) Children() []hybridqp.QueryNode

+ func (p *LogicalAlign) Clone() hybridqp.QueryNode

+ func (p *LogicalAlign) DeriveOperations()

+ func (p *LogicalAlign) Digest() string

+ func (p *LogicalAlign) Dummy() bool

+ func (p *LogicalAlign) Explain(writer LogicalPlanWriter)

+ func (p *LogicalAlign) MarshalBinary() ([]byte, error)

+ func (p *LogicalAlign) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalAlign) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalAlign) RowDataType() hybridqp.RowDataType

+ func (p *LogicalAlign) RowExprOptions() []hybridqp.ExprOptions

+ func (p *LogicalAlign) Schema() hybridqp.Catalog

+ func (p *LogicalAlign) SetInputs(inputs []hybridqp.QueryNode)

+ func (p *LogicalAlign) String() string

+ func (p *LogicalAlign) Type() string

+ func (p *LogicalAlign) UnmarshalBinary(pb *internal.QueryNode) error

+ type LogicalDedupe struct

+ func NewLogicalDedupe(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalDedupe

+ func (p *LogicalDedupe) Children() []hybridqp.QueryNode

+ func (p *LogicalDedupe) Clone() hybridqp.QueryNode

+ func (p *LogicalDedupe) Digest() string

+ func (p *LogicalDedupe) Dummy() bool

+ func (p *LogicalDedupe) Explain(writer LogicalPlanWriter)

+ func (p *LogicalDedupe) MarshalBinary() ([]byte, error)

+ func (p *LogicalDedupe) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalDedupe) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalDedupe) RowDataType() hybridqp.RowDataType

+ func (p *LogicalDedupe) RowExprOptions() []hybridqp.ExprOptions

+ func (p *LogicalDedupe) Schema() hybridqp.Catalog

+ func (p *LogicalDedupe) SetInputs(inputs []hybridqp.QueryNode)

+ func (p *LogicalDedupe) String() string

+ func (p *LogicalDedupe) Type() string

+ func (p *LogicalDedupe) UnmarshalBinary(pb *internal.QueryNode) error

+ type LogicalDummyShard struct

+ func NewLogicalDummyShard(readers [][]interface{}) *LogicalDummyShard

+ func (p *LogicalDummyShard) Children() []hybridqp.QueryNode

+ func (p *LogicalDummyShard) Clone() hybridqp.QueryNode

+ func (p *LogicalDummyShard) Digest() string

+ func (p *LogicalDummyShard) Explain(writer LogicalPlanWriter)

+ func (p *LogicalDummyShard) ExplainIterms(writer LogicalPlanWriter)

+ func (p *LogicalDummyShard) Readers() [][]interface{}

+ func (p *LogicalDummyShard) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalDummyShard) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalDummyShard) String() string

+ func (p *LogicalDummyShard) Type() string

+ type LogicalExchange struct

+ func NewLogicalExchange(input hybridqp.QueryNode, eType ExchangeType, eTraits []hybridqp.Trait, ...) *LogicalExchange

+ func (p *LogicalExchange) AddTrait(trait interface{})

+ func (p *LogicalExchange) Children() []hybridqp.QueryNode

+ func (p *LogicalExchange) Clone() hybridqp.QueryNode

+ func (p *LogicalExchange) DeriveOperations()

+ func (p *LogicalExchange) Digest() string

+ func (p *LogicalExchange) ExchangeRole() ExchangeRole

+ func (p *LogicalExchange) ExchangeType() ExchangeType

+ func (p *LogicalExchange) Explain(writer LogicalPlanWriter)

+ func (p *LogicalExchange) ExplainIterms(writer LogicalPlanWriter)

+ func (p *LogicalExchange) MarshalBinary() ([]byte, error)

+ func (p *LogicalExchange) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalExchange) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalExchange) SetInputs(inputs []hybridqp.QueryNode)

+ func (p *LogicalExchange) String() string

+ func (p *LogicalExchange) ToProducer()

+ func (p *LogicalExchange) Type() string

+ func (p *LogicalExchange) UnmarshalBinary(pb *internal.QueryNode) error

+ type LogicalFill struct

+ func NewLogicalFill(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalFill

+ func (p *LogicalFill) Children() []hybridqp.QueryNode

+ func (p *LogicalFill) Clone() hybridqp.QueryNode

+ func (p *LogicalFill) DeriveOperations()

+ func (p *LogicalFill) Digest() string

+ func (p *LogicalFill) Dummy() bool

+ func (p *LogicalFill) Explain(writer LogicalPlanWriter)

+ func (p *LogicalFill) MarshalBinary() ([]byte, error)

+ func (p *LogicalFill) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalFill) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalFill) RowDataType() hybridqp.RowDataType

+ func (p *LogicalFill) RowExprOptions() []hybridqp.ExprOptions

+ func (p *LogicalFill) Schema() hybridqp.Catalog

+ func (p *LogicalFill) SetInputs(inputs []hybridqp.QueryNode)

+ func (p *LogicalFill) String() string

+ func (p *LogicalFill) Type() string

+ func (p *LogicalFill) UnmarshalBinary(pb *internal.QueryNode) error

+ type LogicalFilter struct

+ func NewLogicalFilter(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalFilter

+ func (p *LogicalFilter) Children() []hybridqp.QueryNode

+ func (p *LogicalFilter) Clone() hybridqp.QueryNode

+ func (p *LogicalFilter) DeriveOperations()

+ func (p *LogicalFilter) Digest() string

+ func (p *LogicalFilter) Dummy() bool

+ func (p *LogicalFilter) Explain(writer LogicalPlanWriter)

+ func (p *LogicalFilter) MarshalBinary() ([]byte, error)

+ func (p *LogicalFilter) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalFilter) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalFilter) RowDataType() hybridqp.RowDataType

+ func (p *LogicalFilter) RowExprOptions() []hybridqp.ExprOptions

+ func (p *LogicalFilter) Schema() hybridqp.Catalog

+ func (p *LogicalFilter) SetInputs(inputs []hybridqp.QueryNode)

+ func (p *LogicalFilter) String() string

+ func (p *LogicalFilter) Type() string

+ func (p *LogicalFilter) UnmarshalBinary(pb *internal.QueryNode) error

+ type LogicalFilterBlank struct

+ func NewLogicalFilterBlank(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalFilterBlank

+ func (p *LogicalFilterBlank) Children() []hybridqp.QueryNode

+ func (p *LogicalFilterBlank) Clone() hybridqp.QueryNode

+ func (p *LogicalFilterBlank) DeriveOperations()

+ func (p *LogicalFilterBlank) Digest() string

+ func (p *LogicalFilterBlank) Dummy() bool

+ func (p *LogicalFilterBlank) Explain(writer LogicalPlanWriter)

+ func (p *LogicalFilterBlank) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalFilterBlank) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalFilterBlank) RowDataType() hybridqp.RowDataType

+ func (p *LogicalFilterBlank) RowExprOptions() []hybridqp.ExprOptions

+ func (p *LogicalFilterBlank) Schema() hybridqp.Catalog

+ func (p *LogicalFilterBlank) String() string

+ func (p *LogicalFilterBlank) Type() string

+ type LogicalGroupBy struct

+ func NewLogicalGroupBy(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalGroupBy

+ func (p *LogicalGroupBy) Children() []hybridqp.QueryNode

+ func (p *LogicalGroupBy) Clone() hybridqp.QueryNode

+ func (p *LogicalGroupBy) DeriveOperations()

+ func (p *LogicalGroupBy) Digest() string

+ func (p *LogicalGroupBy) Explain(writer LogicalPlanWriter)

+ func (p *LogicalGroupBy) ExplainIterms(writer LogicalPlanWriter)

+ func (p *LogicalGroupBy) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalGroupBy) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalGroupBy) String() string

+ func (p *LogicalGroupBy) Type() string

+ type LogicalHttpSender struct

+ func NewLogicalHttpSender(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalHttpSender

+ func (p *LogicalHttpSender) Children() []hybridqp.QueryNode

+ func (p *LogicalHttpSender) Clone() hybridqp.QueryNode

+ func (p *LogicalHttpSender) DeriveOperations()

+ func (p *LogicalHttpSender) Digest() string

+ func (p *LogicalHttpSender) Dummy() bool

+ func (p *LogicalHttpSender) Explain(writer LogicalPlanWriter)

+ func (p *LogicalHttpSender) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalHttpSender) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalHttpSender) RowDataType() hybridqp.RowDataType

+ func (p *LogicalHttpSender) RowExprOptions() []hybridqp.ExprOptions

+ func (p *LogicalHttpSender) Schema() hybridqp.Catalog

+ func (p *LogicalHttpSender) String() string

+ func (p *LogicalHttpSender) Type() string

+ type LogicalHttpSenderHint struct

+ func NewLogicalHttpSenderHint(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalHttpSenderHint

+ func (p *LogicalHttpSenderHint) Children() []hybridqp.QueryNode

+ func (p *LogicalHttpSenderHint) Clone() hybridqp.QueryNode

+ func (p *LogicalHttpSenderHint) DeriveOperations()

+ func (p *LogicalHttpSenderHint) Digest() string

+ func (p *LogicalHttpSenderHint) Dummy() bool

+ func (p *LogicalHttpSenderHint) Explain(writer LogicalPlanWriter)

+ func (p *LogicalHttpSenderHint) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalHttpSenderHint) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalHttpSenderHint) RowDataType() hybridqp.RowDataType

+ func (p *LogicalHttpSenderHint) RowExprOptions() []hybridqp.ExprOptions

+ func (p *LogicalHttpSenderHint) Schema() hybridqp.Catalog

+ func (p *LogicalHttpSenderHint) String() string

+ func (p *LogicalHttpSenderHint) Type() string

+ type LogicalIndexScan struct

+ func NewLogicalIndexScan(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalIndexScan

+ func (p *LogicalIndexScan) Children() []hybridqp.QueryNode

+ func (p *LogicalIndexScan) Clone() hybridqp.QueryNode

+ func (p *LogicalIndexScan) DeriveOperations()

+ func (p *LogicalIndexScan) Digest() string

+ func (p *LogicalIndexScan) Dummy() bool

+ func (p *LogicalIndexScan) Explain(writer LogicalPlanWriter)

+ func (p *LogicalIndexScan) MarshalBinary() ([]byte, error)

+ func (p *LogicalIndexScan) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalIndexScan) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalIndexScan) RowDataType() hybridqp.RowDataType

+ func (p *LogicalIndexScan) RowExprOptions() []hybridqp.ExprOptions

+ func (p *LogicalIndexScan) Schema() hybridqp.Catalog

+ func (p *LogicalIndexScan) SetInputs(inputs []hybridqp.QueryNode)

+ func (p *LogicalIndexScan) String() string

+ func (p *LogicalIndexScan) Type() string

+ func (p *LogicalIndexScan) UnmarshalBinary(pb *internal.QueryNode) error

+ type LogicalInterval struct

+ func NewLogicalInterval(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalInterval

+ func (p *LogicalInterval) Children() []hybridqp.QueryNode

+ func (p *LogicalInterval) Clone() hybridqp.QueryNode

+ func (p *LogicalInterval) DeriveOperations()

+ func (p *LogicalInterval) Digest() string

+ func (p *LogicalInterval) Dummy() bool

+ func (p *LogicalInterval) Explain(writer LogicalPlanWriter)

+ func (p *LogicalInterval) MarshalBinary() ([]byte, error)

+ func (p *LogicalInterval) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalInterval) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalInterval) RowDataType() hybridqp.RowDataType

+ func (p *LogicalInterval) RowExprOptions() []hybridqp.ExprOptions

+ func (p *LogicalInterval) Schema() hybridqp.Catalog

+ func (p *LogicalInterval) SetInputs(inputs []hybridqp.QueryNode)

+ func (p *LogicalInterval) String() string

+ func (p *LogicalInterval) Type() string

+ func (p *LogicalInterval) UnmarshalBinary(pb *internal.QueryNode) error

+ type LogicalLimit struct

+ LimitPara LimitTransformParameters

+ func NewLogicalLimit(input hybridqp.QueryNode, schema hybridqp.Catalog, ...) *LogicalLimit

+ func (p *LogicalLimit) Children() []hybridqp.QueryNode

+ func (p *LogicalLimit) Clone() hybridqp.QueryNode

+ func (p *LogicalLimit) DeriveOperations()

+ func (p *LogicalLimit) Digest() string

+ func (p *LogicalLimit) Dummy() bool

+ func (p *LogicalLimit) Explain(writer LogicalPlanWriter)

+ func (p *LogicalLimit) MarshalBinary() ([]byte, error)

+ func (p *LogicalLimit) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalLimit) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalLimit) RowDataType() hybridqp.RowDataType

+ func (p *LogicalLimit) RowExprOptions() []hybridqp.ExprOptions

+ func (p *LogicalLimit) Schema() hybridqp.Catalog

+ func (p *LogicalLimit) SetInputs(inputs []hybridqp.QueryNode)

+ func (p *LogicalLimit) String() string

+ func (p *LogicalLimit) Type() string

+ func (p *LogicalLimit) UnmarshalBinary(pb *internal.QueryNode) error

+ type LogicalMerge struct

+ func NewLogicalMerge(inputs []hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalMerge

+ func (p *LogicalMerge) Children() []hybridqp.QueryNode

+ func (p *LogicalMerge) Clone() hybridqp.QueryNode

+ func (p *LogicalMerge) DeriveOperations()

+ func (p *LogicalMerge) Digest() string

+ func (p *LogicalMerge) Dummy() bool

+ func (p *LogicalMerge) Explain(writer LogicalPlanWriter)

+ func (p *LogicalMerge) MarshalBinary() ([]byte, error)

+ func (p *LogicalMerge) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalMerge) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalMerge) RowDataType() hybridqp.RowDataType

+ func (p *LogicalMerge) RowExprOptions() []hybridqp.ExprOptions

+ func (p *LogicalMerge) Schema() hybridqp.Catalog

+ func (p *LogicalMerge) SetInputs(inputs []hybridqp.QueryNode)

+ func (p *LogicalMerge) String() string

+ func (p *LogicalMerge) Type() string

+ func (p *LogicalMerge) UnmarshalBinary(pb *internal.QueryNode) error

+ type LogicalMst struct

+ func NewLogicalMst(rt hybridqp.RowDataType) *LogicalMst

+ func (p *LogicalMst) Children() []hybridqp.QueryNode

+ func (p *LogicalMst) Clone() hybridqp.QueryNode

+ func (p *LogicalMst) Digest() string

+ func (p *LogicalMst) Dummy() bool

+ func (p *LogicalMst) Explain(writer LogicalPlanWriter)

+ func (p *LogicalMst) MarshalBinary() ([]byte, error)

+ func (p *LogicalMst) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalMst) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalMst) RowDataType() hybridqp.RowDataType

+ func (p *LogicalMst) RowExprOptions() []hybridqp.ExprOptions

+ func (p *LogicalMst) Schema() hybridqp.Catalog

+ func (p *LogicalMst) SetInputs(inputs []hybridqp.QueryNode)

+ func (p *LogicalMst) String() string

+ func (p *LogicalMst) Type() string

+ func (p *LogicalMst) UnmarshalBinary(pb *internal.QueryNode) error

+ type LogicalOrderBy struct

+ func NewLogicalOrderBy(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalOrderBy

+ func (p *LogicalOrderBy) Children() []hybridqp.QueryNode

+ func (p *LogicalOrderBy) Clone() hybridqp.QueryNode

+ func (p *LogicalOrderBy) DeriveOperations()

+ func (p *LogicalOrderBy) Digest() string

+ func (p *LogicalOrderBy) Explain(writer LogicalPlanWriter)

+ func (p *LogicalOrderBy) ExplainIterms(writer LogicalPlanWriter)

+ func (p *LogicalOrderBy) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalOrderBy) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalOrderBy) String() string

+ func (p *LogicalOrderBy) Type() string

+ type LogicalPlan interface

+ Explain func(LogicalPlanWriter)

+ Schema func() hybridqp.Catalog

+ type LogicalPlanBase struct

+ func NewLogicalPlanBase(schema hybridqp.Catalog, rt hybridqp.RowDataType, ops []hybridqp.ExprOptions) *LogicalPlanBase

+ func (p *LogicalPlanBase) ApplyTrait(trait hybridqp.Trait)

+ func (p *LogicalPlanBase) DeriveOperations()

+ func (p *LogicalPlanBase) Dummy() bool

+ func (p *LogicalPlanBase) ExplainIterms(writer LogicalPlanWriter)

+ func (p *LogicalPlanBase) ForwardInit(input hybridqp.QueryNode)

+ func (p *LogicalPlanBase) ID() uint64

+ func (p *LogicalPlanBase) MarshalBinary() ([]byte, error)

+ func (p *LogicalPlanBase) RowDataType() hybridqp.RowDataType

+ func (p *LogicalPlanBase) RowExprOptions() []hybridqp.ExprOptions

+ func (p *LogicalPlanBase) Schema() hybridqp.Catalog

+ func (p *LogicalPlanBase) SetInputs(_ []hybridqp.QueryNode)

+ func (p *LogicalPlanBase) SetSchema(schema hybridqp.Catalog)

+ func (p *LogicalPlanBase) Trait() hybridqp.Trait

+ func (p *LogicalPlanBase) UnmarshalBinary(_ *internal.QueryNode) error

+ type LogicalPlanBuilder interface

+ Aggregate func() LogicalPlanBuilder

+ Build func() (hybridqp.QueryNode, error)

+ CountDistinct func() LogicalPlanBuilder

+ CreateAggregate func(hybridqp.QueryNode) (hybridqp.QueryNode, error)

+ CreateLimit func(hybridqp.QueryNode) (hybridqp.QueryNode, error)

+ CreateMeasurementPlan func(hybridqp.QueryNode) (hybridqp.QueryNode, error)

+ CreateNodePlan func(hybridqp.QueryNode, []hybridqp.Trait) (hybridqp.QueryNode, error)

+ CreateSeriesPlan func() (hybridqp.QueryNode, error)

+ CreateShardPlan func(hybridqp.QueryNode) (hybridqp.QueryNode, error)

+ Dedupe func() LogicalPlanBuilder

+ Exchange func(eType ExchangeType, eTraits []hybridqp.Trait) LogicalPlanBuilder

+ Fill func() LogicalPlanBuilder

+ Filter func() LogicalPlanBuilder

+ FilterBlank func() LogicalPlanBuilder

+ GroupBy func() LogicalPlanBuilder

+ HttpSender func() LogicalPlanBuilder

+ IndexScan func() LogicalPlanBuilder

+ Interval func() LogicalPlanBuilder

+ Limit func(parameters LimitTransformParameters) LogicalPlanBuilder

+ Merge func() LogicalPlanBuilder

+ OrderBy func() LogicalPlanBuilder

+ Project func() LogicalPlanBuilder

+ Push func(hybridqp.QueryNode) LogicalPlanBuilder

+ Reader func() LogicalPlanBuilder

+ SlidingWindow func() LogicalPlanBuilder

+ SortAppend func() LogicalPlanBuilder

+ SortMerge func() LogicalPlanBuilder

+ SubQuery func() LogicalPlanBuilder

+ TagSubset func() LogicalPlanBuilder

+ type LogicalPlanBuilderImpl struct

+ func NewLogicalPlanBuilderImpl(schema hybridqp.Catalog) *LogicalPlanBuilderImpl

+ func (b *LogicalPlanBuilderImpl) Aggregate() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) Build() (hybridqp.QueryNode, error)

+ func (b *LogicalPlanBuilderImpl) CountDistinct() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) CreateAggregate(input hybridqp.QueryNode) (hybridqp.QueryNode, error)

+ func (b *LogicalPlanBuilderImpl) CreateInterval(input hybridqp.QueryNode) (hybridqp.QueryNode, error)

+ func (b *LogicalPlanBuilderImpl) CreateLimit(input hybridqp.QueryNode) (hybridqp.QueryNode, error)

+ func (b *LogicalPlanBuilderImpl) CreateMeasurementPlan(seriesPlan hybridqp.QueryNode) (hybridqp.QueryNode, error)

+ func (b *LogicalPlanBuilderImpl) CreateNodePlan(shardPlan hybridqp.QueryNode, eTraits []hybridqp.Trait) (hybridqp.QueryNode, error)

+ func (b *LogicalPlanBuilderImpl) CreateProject(input hybridqp.QueryNode) (hybridqp.QueryNode, error)

+ func (b *LogicalPlanBuilderImpl) CreateScanPlan(mstPlan hybridqp.QueryNode) (hybridqp.QueryNode, error)

+ func (b *LogicalPlanBuilderImpl) CreateSeriesPlan() (hybridqp.QueryNode, error)

+ func (b *LogicalPlanBuilderImpl) CreateShardPlan(scanPlan hybridqp.QueryNode) (hybridqp.QueryNode, error)

+ func (b *LogicalPlanBuilderImpl) CreateSlideWindow(input hybridqp.QueryNode) (hybridqp.QueryNode, error)

+ func (b *LogicalPlanBuilderImpl) Dedupe() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) Exchange(eType ExchangeType, eTraits []hybridqp.Trait) LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) Fill() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) Filter() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) FilterBlank() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) GroupBy() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) HttpSender() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) HttpSenderHint() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) IndexScan() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) Interval() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) Limit(para LimitTransformParameters) LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) Merge() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) OrderBy() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) Project() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) Push(node hybridqp.QueryNode) LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) Reader() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) Rewrite() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) Series() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) SlidingWindow() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) SortAppend() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) SortMerge() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) SubQuery() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) TagSetAggregate() LogicalPlanBuilder

+ func (b *LogicalPlanBuilderImpl) TagSubset() LogicalPlanBuilder

+ type LogicalPlanRewriter interface

+ type LogicalPlanRewriterImpl struct

+ type LogicalPlanVisitor interface

+ Visit func(hybridqp.QueryNode) LogicalPlanVisitor

+ type LogicalPlanWriter interface

+ Explain func(LogicalPlan)

+ Item func(string, interface{})

+ String func() string

+ type LogicalPlanWriterImpl struct

+ Builder *strings.Builder

+ Spacer *Spacer

+ Values *list.List

+ func NewLogicalPlanWriterImpl(builder *strings.Builder) *LogicalPlanWriterImpl

+ func (w *LogicalPlanWriterImpl) Explain(node LogicalPlan)

+ func (w *LogicalPlanWriterImpl) ExplainChildren(children []hybridqp.QueryNode)

+ func (w *LogicalPlanWriterImpl) Item(term string, value interface{})

+ func (w *LogicalPlanWriterImpl) String() string

+ type LogicalProject struct

+ func NewLogicalProject(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalProject

+ func (p *LogicalProject) Children() []hybridqp.QueryNode

+ func (p *LogicalProject) Clone() hybridqp.QueryNode

+ func (p *LogicalProject) DeriveOperations()

+ func (p *LogicalProject) Digest() string

+ func (p *LogicalProject) Dummy() bool

+ func (p *LogicalProject) Explain(writer LogicalPlanWriter)

+ func (p *LogicalProject) MarshalBinary() ([]byte, error)

+ func (p *LogicalProject) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalProject) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalProject) RowDataType() hybridqp.RowDataType

+ func (p *LogicalProject) RowExprOptions() []hybridqp.ExprOptions

+ func (p *LogicalProject) Schema() hybridqp.Catalog

+ func (p *LogicalProject) SetInputs(inputs []hybridqp.QueryNode)

+ func (p *LogicalProject) String() string

+ func (p *LogicalProject) Type() string

+ func (p *LogicalProject) UnmarshalBinary(pb *internal.QueryNode) error

+ type LogicalReader struct

+ func NewLogicalReader(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalReader

+ func (p *LogicalReader) Children() []hybridqp.QueryNode

+ func (p *LogicalReader) Clone() hybridqp.QueryNode

+ func (p *LogicalReader) Cursors() []interface{}

+ func (p *LogicalReader) DeriveOperations()

+ func (p *LogicalReader) Digest() string

+ func (p *LogicalReader) Dummy() bool

+ func (p *LogicalReader) Explain(writer LogicalPlanWriter)

+ func (p *LogicalReader) ExplainIterms(writer LogicalPlanWriter)

+ func (p *LogicalReader) HasPreAgg() bool

+ func (p *LogicalReader) MarshalBinary() ([]byte, error)

+ func (p *LogicalReader) MstName() string

+ func (p *LogicalReader) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalReader) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalReader) RowDataType() hybridqp.RowDataType

+ func (p *LogicalReader) RowExprOptions() []hybridqp.ExprOptions

+ func (p *LogicalReader) Schema() hybridqp.Catalog

+ func (p *LogicalReader) SetCursor(cursor []interface{})

+ func (p *LogicalReader) SetInputs(inputs []hybridqp.QueryNode)

+ func (p *LogicalReader) String() string

+ func (p *LogicalReader) Type() string

+ func (p *LogicalReader) UnmarshalBinary(pb *internal.QueryNode) error

+ type LogicalSeries struct

+ func NewLogicalSeries(schema hybridqp.Catalog) *LogicalSeries

+ func (p *LogicalSeries) Children() []hybridqp.QueryNode

+ func (p *LogicalSeries) Clone() hybridqp.QueryNode

+ func (p *LogicalSeries) DeriveOperations()

+ func (p *LogicalSeries) Digest() string

+ func (p *LogicalSeries) Dummy() bool

+ func (p *LogicalSeries) Explain(writer LogicalPlanWriter)

+ func (p *LogicalSeries) ExplainIterms(writer LogicalPlanWriter)

+ func (p *LogicalSeries) MarshalBinary() ([]byte, error)

+ func (p *LogicalSeries) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalSeries) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalSeries) RowDataType() hybridqp.RowDataType

+ func (p *LogicalSeries) RowExprOptions() []hybridqp.ExprOptions

+ func (p *LogicalSeries) Schema() hybridqp.Catalog

+ func (p *LogicalSeries) SetInputs(inputs []hybridqp.QueryNode)

+ func (p *LogicalSeries) String() string

+ func (p *LogicalSeries) Type() string

+ func (p *LogicalSeries) UnmarshalBinary(pb *internal.QueryNode) error

+ type LogicalSlidingWindow struct

+ func NewLogicalSlidingWindow(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalSlidingWindow

+ func (p *LogicalSlidingWindow) Children() []hybridqp.QueryNode

+ func (p *LogicalSlidingWindow) Clone() hybridqp.QueryNode

+ func (p *LogicalSlidingWindow) CountToSum()

+ func (p *LogicalSlidingWindow) DeriveOperations()

+ func (p *LogicalSlidingWindow) Digest() string

+ func (p *LogicalSlidingWindow) Dummy() bool

+ func (p *LogicalSlidingWindow) Explain(writer LogicalPlanWriter)

+ func (p *LogicalSlidingWindow) ForwardCallArgs()

+ func (p *LogicalSlidingWindow) MarshalBinary() ([]byte, error)

+ func (p *LogicalSlidingWindow) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalSlidingWindow) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalSlidingWindow) RowDataType() hybridqp.RowDataType

+ func (p *LogicalSlidingWindow) RowExprOptions() []hybridqp.ExprOptions

+ func (p *LogicalSlidingWindow) Schema() hybridqp.Catalog

+ func (p *LogicalSlidingWindow) SetInputs(inputs []hybridqp.QueryNode)

+ func (p *LogicalSlidingWindow) String() string

+ func (p *LogicalSlidingWindow) Type() string

+ func (p *LogicalSlidingWindow) UnmarshalBinary(pb *internal.QueryNode) error

+ type LogicalSortAppend struct

+ func NewLogicalSortAppend(inputs []hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalSortAppend

+ func (p *LogicalSortAppend) Children() []hybridqp.QueryNode

+ func (p *LogicalSortAppend) Clone() hybridqp.QueryNode

+ func (p *LogicalSortAppend) DeriveOperations()

+ func (p *LogicalSortAppend) Digest() string

+ func (p *LogicalSortAppend) Dummy() bool

+ func (p *LogicalSortAppend) Explain(writer LogicalPlanWriter)

+ func (p *LogicalSortAppend) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalSortAppend) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalSortAppend) RowDataType() hybridqp.RowDataType

+ func (p *LogicalSortAppend) RowExprOptions() []hybridqp.ExprOptions

+ func (p *LogicalSortAppend) Schema() hybridqp.Catalog

+ func (p *LogicalSortAppend) String() string

+ func (p *LogicalSortAppend) Type() string

+ type LogicalSortMerge struct

+ func NewLogicalSortMerge(inputs []hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalSortMerge

+ func (p *LogicalSortMerge) Children() []hybridqp.QueryNode

+ func (p *LogicalSortMerge) Clone() hybridqp.QueryNode

+ func (p *LogicalSortMerge) DeriveOperations()

+ func (p *LogicalSortMerge) Digest() string

+ func (p *LogicalSortMerge) Dummy() bool

+ func (p *LogicalSortMerge) Explain(writer LogicalPlanWriter)

+ func (p *LogicalSortMerge) MarshalBinary() ([]byte, error)

+ func (p *LogicalSortMerge) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalSortMerge) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalSortMerge) RowDataType() hybridqp.RowDataType

+ func (p *LogicalSortMerge) RowExprOptions() []hybridqp.ExprOptions

+ func (p *LogicalSortMerge) Schema() hybridqp.Catalog

+ func (p *LogicalSortMerge) SetInputs(inputs []hybridqp.QueryNode)

+ func (p *LogicalSortMerge) String() string

+ func (p *LogicalSortMerge) Type() string

+ func (p *LogicalSortMerge) UnmarshalBinary(pb *internal.QueryNode) error

+ type LogicalSubQuery struct

+ func NewLogicalSubQuery(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalSubQuery

+ func (p *LogicalSubQuery) Children() []hybridqp.QueryNode

+ func (p *LogicalSubQuery) Clone() hybridqp.QueryNode

+ func (p *LogicalSubQuery) DeriveOperations()

+ func (p *LogicalSubQuery) Digest() string

+ func (p *LogicalSubQuery) Dummy() bool

+ func (p *LogicalSubQuery) Explain(writer LogicalPlanWriter)

+ func (p *LogicalSubQuery) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalSubQuery) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalSubQuery) RowDataType() hybridqp.RowDataType

+ func (p *LogicalSubQuery) RowExprOptions() []hybridqp.ExprOptions

+ func (p *LogicalSubQuery) Schema() hybridqp.Catalog

+ func (p *LogicalSubQuery) String() string

+ func (p *LogicalSubQuery) Type() string

+ type LogicalTagSubset struct

+ func NewLogicalTagSubset(input hybridqp.QueryNode, schema hybridqp.Catalog) *LogicalTagSubset

+ func (p *LogicalTagSubset) Children() []hybridqp.QueryNode

+ func (p *LogicalTagSubset) Clone() hybridqp.QueryNode

+ func (p *LogicalTagSubset) Digest() string

+ func (p *LogicalTagSubset) Dummy() bool

+ func (p *LogicalTagSubset) Explain(writer LogicalPlanWriter)

+ func (p *LogicalTagSubset) MarshalBinary() ([]byte, error)

+ func (p *LogicalTagSubset) ReplaceChild(ordinal int, child hybridqp.QueryNode)

+ func (p *LogicalTagSubset) ReplaceChildren(children []hybridqp.QueryNode)

+ func (p *LogicalTagSubset) RowDataType() hybridqp.RowDataType

+ func (p *LogicalTagSubset) RowExprOptions() []hybridqp.ExprOptions

+ func (p *LogicalTagSubset) Schema() hybridqp.Catalog

+ func (p *LogicalTagSubset) SetInputs(inputs []hybridqp.QueryNode)

+ func (p *LogicalTagSubset) String() string

+ func (p *LogicalTagSubset) Type() string

+ func (p *LogicalTagSubset) UnmarshalBinary(pb *internal.QueryNode) error

+ type MaterializeTransform struct

+ ColumnMap []int

+ ResetTime bool

+ func NewMaterializeTransform(inRowDataType hybridqp.RowDataType, outRowDataType hybridqp.RowDataType, ...) *MaterializeTransform

+ func (trans *MaterializeTransform) Close()

+ func (trans *MaterializeTransform) ColumnMapInit()

+ func (trans *MaterializeTransform) Explain() []ValuePair

+ func (trans *MaterializeTransform) GetInputNumber(_ Port) int

+ func (trans *MaterializeTransform) GetInputs() Ports

+ func (trans *MaterializeTransform) GetOutputNumber(_ Port) int

+ func (trans *MaterializeTransform) GetOutputs() Ports

+ func (trans *MaterializeTransform) Name() string

+ func (trans *MaterializeTransform) Work(ctx context.Context) error

+ type MaterializeTransformCreator struct

+ func (c *MaterializeTransformCreator) Create(plan LogicalPlan, opt query.ProcessorOptions) (Processor, error)

+ type MemStore struct

+ func NewMemStore() *MemStore

+ func (ms *MemStore) Segments() map[uint64]*Segment

+ func (ms *MemStore) WriteSegment(seg *Segment) error

+ type MemStoreReader struct

+ func NewMemStoreReader(memstore *MemStore, dims []string) *MemStoreReader

+ func (r *MemStoreReader) HasMore() bool

+ func (r *MemStoreReader) Next() []*Segment

+ type MergeTransform struct

+ BreakPoint *BreakPoint

+ CoProcessor CoProcessor

+ HeapItems *HeapItems

+ Inputs ChunkPorts

+ NewChunk Chunk

+ NextChunk []chan Semaphore

+ Outputs ChunkPorts

+ WaitMerge chan Semaphore

+ func NewMergeTransform(inRowDataTypes []hybridqp.RowDataType, outRowDataTypes []hybridqp.RowDataType, ...) *MergeTransform

+ func (trans *MergeTransform) AddIntervalIndex(chunk Chunk, i int, opt query.ProcessorOptions) bool

+ func (trans *MergeTransform) AddTagAndIndexes(tag ChunkTags, i int)

+ func (trans *MergeTransform) AppendMergeTimeAndColumns(i int)

+ func (trans *MergeTransform) AppendToHeap(in int, c Chunk)

+ func (trans *MergeTransform) Close()

+ func (trans *MergeTransform) Explain() []ValuePair

+ func (trans *MergeTransform) GetBreakPoint()

+ func (trans *MergeTransform) GetInputNumber(port Port) int

+ func (trans *MergeTransform) GetInputs() Ports

+ func (trans *MergeTransform) GetOutputNumber(port Port) int

+ func (trans *MergeTransform) GetOutputs() Ports

+ func (trans *MergeTransform) Merge(ctx context.Context, errs *Errs, errSignals *ErrorSignals)

+ func (trans *MergeTransform) Name() string

+ func (trans *MergeTransform) SendChunk()

+ func (trans *MergeTransform) UpdateWithSingleChunk()

+ func (trans *MergeTransform) Work(ctx context.Context) error

+ type MergeTransformCreator struct

+ func (c *MergeTransformCreator) Create(plan LogicalPlan, _ query.ProcessorOptions) (Processor, error)

+ type MocReaderTransform struct

+ Builder *ChunkBuilder

+ Count int

+ DataMap DataMaps

+ MstRt hybridqp.RowDataType

+ NewChunk []Chunk

+ Ops []hybridqp.ExprOptions

+ Opt query.ProcessorOptions

+ Output *ChunkPort

+ func NewMocReaderTransform(mstRt hybridqp.RowDataType, outRt hybridqp.RowDataType, ...) *MocReaderTransform

+ func (trans *MocReaderTransform) Close()

+ func (trans *MocReaderTransform) Explain() []ValuePair

+ func (trans *MocReaderTransform) GetInputNumber(port Port) int

+ func (trans *MocReaderTransform) GetInputs() Ports

+ func (trans *MocReaderTransform) GetOutputNumber(port Port) int

+ func (trans *MocReaderTransform) GetOutputs() Ports

+ func (trans *MocReaderTransform) InitChunk(dataMap DataMapStruct)

+ func (trans *MocReaderTransform) Name() string

+ func (trans *MocReaderTransform) Work(ctx context.Context) error

+ type MocReaderTransformCreator struct

+ func (c *MocReaderTransformCreator) Create(plan LogicalPlan, opt query.ProcessorOptions) (Processor, error)

+ type MockScanner struct

+ func NewMockScanner(rowDataType hybridqp.RowDataType, innerPlan hybridqp.QueryNode, path string, ...) *MockScanner

+ func (mock *MockScanner) Close()

+ func (mock *MockScanner) Explain() []ValuePair

+ func (mock *MockScanner) GetInputNumber(port Port) int

+ func (mock *MockScanner) GetInputs() Ports

+ func (mock *MockScanner) GetOutputNumber(port Port) int

+ func (mock *MockScanner) GetOutputs() Ports

+ func (mock *MockScanner) IsSink() bool

+ func (mock *MockScanner) Name() string

+ func (mock *MockScanner) Release() error

+ func (mock *MockScanner) Work(ctx context.Context) error

+ type MockScannerCreator struct

+ func (mock *MockScannerCreator) Create(plan LogicalPlan, opt qry.ProcessorOptions) (Processor, error)

+ type MockSender struct

+ func NewMockSender(rowDataType hybridqp.RowDataType, schema *QuerySchema) *MockSender

+ func (mock *MockSender) Close()

+ func (mock *MockSender) Explain() []ValuePair

+ func (mock *MockSender) GetInputNumber(port Port) int

+ func (mock *MockSender) GetInputs() Ports

+ func (mock *MockSender) GetOutputNumber(port Port) int

+ func (mock *MockSender) GetOutputs() Ports

+ func (mock *MockSender) IsSink() bool

+ func (mock *MockSender) Name() string

+ func (mock *MockSender) Release() error

+ func (mock *MockSender) Work(ctx context.Context) error

+ type MockSenderCreator struct

+ func (mock *MockSenderCreator) Create(plan LogicalPlan, opt qry.ProcessorOptions) (Processor, error)

+ type MockSeries struct

+ func NewMockSeries(rowDataType hybridqp.RowDataType, segment *Segment, ops []hybridqp.ExprOptions, ...) *MockSeries

+ func (mock *MockSeries) Close()

+ func (mock *MockSeries) Explain() []ValuePair

+ func (mock *MockSeries) GetInputNumber(port Port) int

+ func (mock *MockSeries) GetInputs() Ports

+ func (mock *MockSeries) GetOutputNumber(port Port) int

+ func (mock *MockSeries) GetOutputs() Ports

+ func (mock *MockSeries) IsSink() bool

+ func (mock *MockSeries) Name() string

+ func (mock *MockSeries) Release() error

+ func (mock *MockSeries) Work(ctx context.Context) error

+ type MockSeriesCreator struct

+ func (mock *MockSeriesCreator) Create(plan LogicalPlan, opt qry.ProcessorOptions) (Processor, error)

+ type MockShardGroup struct

+ func NewMockShardGroup() *MockShardGroup

+ func (mock *MockShardGroup) AddShard(table *Table)

+ func (mock *MockShardGroup) Close() error

+ func (mock *MockShardGroup) CreateLogicalPlan(ctx context.Context, sources influxql.Sources, schema hybridqp.Catalog) (hybridqp.QueryNode, error)

+ func (mock *MockShardGroup) FieldDimensions(m *influxql.Measurement) (map[string]influxql.DataType, map[string]struct{}, *influxql.Schema, error)

+ func (mock *MockShardGroup) GetSources(sources influxql.Sources) influxql.Sources

+ func (mock *MockShardGroup) LogicalPlanCost(source *influxql.Measurement, opt qry.ProcessorOptions) (hybridqp.LogicalPlanCost, error)

+ func (mock *MockShardGroup) MapType(m *influxql.Measurement, field string) influxql.DataType

+ func (mock *MockShardGroup) MapTypeBatch(m *influxql.Measurement, fields map[string]influxql.DataType, ...) error

+ type MockShardMapper struct

+ func NewMockShardMapper(catalog *Catalog) *MockShardMapper

+ func (mock *MockShardMapper) Close() error

+ func (mock *MockShardMapper) GetSeriesKey() []byte

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

+ type NilSink struct

+ Input *ChunkPort

+ func NewNilSink(rowDataType hybridqp.RowDataType) *NilSink

+ func (sink *NilSink) Close()

+ func (sink *NilSink) Explain() []ValuePair

+ func (sink *NilSink) GetInputNumber(_ Port) int

+ func (sink *NilSink) GetInputs() Ports

+ func (sink *NilSink) GetOutputNumber(_ Port) int

+ func (sink *NilSink) GetOutputs() Ports

+ func (sink *NilSink) Name() string

+ func (sink *NilSink) Work(ctx context.Context) error

+ type NilTransform struct

+ Inputs ChunkPorts

+ Outputs ChunkPorts

+ func NewNilTransform(inRowDataTypes []hybridqp.RowDataType, outRowDataTypes []hybridqp.RowDataType) *NilTransform

+ func (trans *NilTransform) Close()

+ func (trans *NilTransform) Explain() []ValuePair

+ func (trans *NilTransform) GetInputNumber(port Port) int

+ func (trans *NilTransform) GetInputs() Ports

+ func (trans *NilTransform) GetOutputNumber(port Port) int

+ func (trans *NilTransform) GetOutputs() Ports

+ func (trans *NilTransform) Name() string

+ func (trans *NilTransform) Work(ctx context.Context) error

+ type OptRule interface

+ Catagory func() OptRuleCatagory

+ Description func() string

+ Equals func(OptRule) bool

+ GetOperand func() OptRuleOperand

+ Initialize func(rule OptRule, operand OptRuleOperand, description string)

+ Matches func(call *OptRuleCall) bool

+ OnMatch func(call *OptRuleCall)

+ ToString func() string

+ type OptRuleBase struct

+ func (r *OptRuleBase) Description() string

+ func (r *OptRuleBase) Equals(rhs *OptRuleBase) bool

+ func (r *OptRuleBase) GetOperand() OptRuleOperand

+ func (r *OptRuleBase) Initialize(rule OptRule, operand OptRuleOperand, description string)

+ func (r *OptRuleBase) Matches(_ *OptRuleCall) bool

+ type OptRuleCall struct

+ func NewOptRuleCall(planner HeuPlanner, operand OptRuleOperand, nodes []hybridqp.QueryNode, ...) *OptRuleCall

+ func (c *OptRuleCall) GetResult() []hybridqp.QueryNode

+ func (c *OptRuleCall) Node(ordinal int) hybridqp.QueryNode

+ func (c *OptRuleCall) Rule() OptRule

+ func (c *OptRuleCall) TransformTo(to hybridqp.QueryNode) []hybridqp.QueryNode

+ type OptRuleCatagory int

+ const RULE_PUSHDOWN_AGG

+ const RULE_PUSHDOWN_LIMIT

+ const RULE_SPREAD_AGG

+ const RULE_SUBQUERY

+ const RULE_TEST

+ type OptRuleOperand interface

+ Children func() []OptRuleOperand

+ Equals func(rhs OptRuleOperand) bool

+ Matches func(node hybridqp.QueryNode) bool

+ Parent func() OptRuleOperand

+ Policy func() OptRuleOperandChildPolicy

+ Rule func() OptRule

+ SetOrdinalInParent func(int)

+ SetOrdinalInRule func(int)

+ SetParent func(parent OptRuleOperand)

+ SetRule func(rule OptRule)

+ type OptRuleOperandBase struct

+ func NewOptRuleOperandBase(planType string, policy OptRuleOperandChildPolicy, children []OptRuleOperand) *OptRuleOperandBase

+ func (ob *OptRuleOperandBase) Children() []OptRuleOperand

+ func (ob *OptRuleOperandBase) Equals(rhs OptRuleOperand) bool

+ func (ob *OptRuleOperandBase) Matches(node hybridqp.QueryNode) bool

+ func (ob *OptRuleOperandBase) Parent() OptRuleOperand

+ func (ob *OptRuleOperandBase) Policy() OptRuleOperandChildPolicy

+ func (ob *OptRuleOperandBase) Rule() OptRule

+ func (ob *OptRuleOperandBase) SetOrdinalInParent(ordinal int)

+ func (ob *OptRuleOperandBase) SetOrdinalInRule(ordinal int)

+ func (ob *OptRuleOperandBase) SetParent(parent OptRuleOperand)

+ func (ob *OptRuleOperandBase) SetRule(rule OptRule)

+ type OptRuleOperandBuilder interface

+ AnyInput func(planType string)

+ Inputs func(planType string, inputs ...OptRuleOperand)

+ NoInput func(planType string)

+ OneInput func(planType string, input OptRuleOperand)

+ Operand func() OptRuleOperand

+ Operands func() []OptRuleOperand

+ UnorderedInputs func(planType string, inputs ...OptRuleOperand)

+ WildCardInput func(planType string)

+ type OptRuleOperandBuilderBase struct

+ func NewOptRuleOperandBuilderBase() *OptRuleOperandBuilderBase

+ func (builder *OptRuleOperandBuilderBase) AfterInput(planType string)

+ func (builder *OptRuleOperandBuilderBase) AnyInput(planType string)

+ func (builder *OptRuleOperandBuilderBase) Inputs(planType string, inputs ...OptRuleOperand)

+ func (builder *OptRuleOperandBuilderBase) NoInput(planType string)

+ func (builder *OptRuleOperandBuilderBase) OneInput(planType string, input OptRuleOperand)

+ func (builder *OptRuleOperandBuilderBase) Operand() OptRuleOperand

+ func (builder *OptRuleOperandBuilderBase) Operands() []OptRuleOperand

+ func (builder *OptRuleOperandBuilderBase) UnorderedInputs(planType string, inputs ...OptRuleOperand)

+ func (builder *OptRuleOperandBuilderBase) WildCardInput(planType string, input OptRuleOperand)

+ type OptRuleOperandChildPolicy int

+ const AFTER

+ const ANY

+ const LEAF

+ const SOME

+ const UNORDERED

+ const WILDCARD

+ type OptRuleOperands []OptRuleOperand

+ func (operands OptRuleOperands) Equals(rhs OptRuleOperands) bool

+ type OrderByTransform struct

+ CoProcessor CoProcessor

+ ResultChunkPool *CircularChunkPool

+ func NewOrderByTransform(inRowDataType hybridqp.RowDataType, outRowDataType hybridqp.RowDataType, ...) *OrderByTransform

+ func (trans *OrderByTransform) Close()

+ func (trans *OrderByTransform) Explain() []ValuePair

+ func (trans *OrderByTransform) GetInputNumber(_ Port) int

+ func (trans *OrderByTransform) GetInputs() Ports

+ func (trans *OrderByTransform) GetOutputNumber(_ Port) int

+ func (trans *OrderByTransform) GetOutputs() Ports

+ func (trans *OrderByTransform) GetTagAndIndexes(chunk Chunk)

+ func (trans *OrderByTransform) GetTagsResetTagIndexes(chunk Chunk)

+ func (trans *OrderByTransform) IntervalIndexReGen()

+ func (trans *OrderByTransform) Name() string

+ func (trans *OrderByTransform) OrderTime()

+ func (trans *OrderByTransform) RebuildChunk()

+ func (trans *OrderByTransform) Release() error

+ func (trans *OrderByTransform) SendChunk()

+ func (trans *OrderByTransform) TagAndTagIndexHandler()

+ func (trans *OrderByTransform) Work(ctx context.Context) error

+ type OrderByTransformCreator struct

+ func (c *OrderByTransformCreator) Create(plan LogicalPlan, opt query.ProcessorOptions) (Processor, error)

+ type PipelineExecutor struct

+ RunTimeStats *statistics.StatisticTimer

+ WaitTimeStats *statistics.StatisticTimer

+ func NewPipelineExecutor(processors Processors) *PipelineExecutor

+ func NewPipelineExecutorFromDag(dag *TransformDag, root *TransformVertex) *PipelineExecutor

+ func (exec *PipelineExecutor) Abort()

+ func (exec *PipelineExecutor) Aborted() bool

+ func (exec *PipelineExecutor) Crash()

+ func (exec *PipelineExecutor) Crashed() bool

+ func (exec *PipelineExecutor) Execute(ctx context.Context) error

+ func (exec *PipelineExecutor) ExecuteExecutor(ctx context.Context) error

+ func (exec *PipelineExecutor) Release()

+ func (exec *PipelineExecutor) Visit(vertex *TransformVertex) TransformVertexVisitor

+ type PipelineExecutorInfo struct

+ CPUOccupation float64

+ MemoryOccupation int64

+ ProcessorNum int64

+ type PipelineExecutorManager struct

+ func NewPipelineExecutorManager() *PipelineExecutorManager

+ func (p *PipelineExecutorManager) ManageMemResource(exec *PipelineExecutor) error

+ func (p *PipelineExecutorManager) ReleaseMem(exec *PipelineExecutor)

+ func (p *PipelineExecutorManager) Reset()

+ func (p *PipelineExecutorManager) SetManagerParas(TotalRes int64, timeout time.Duration)

+ func (p *PipelineExecutorManager) UpdateAccumulator(exec *PipelineExecutor)

+ type PlanFrame struct

+ func NewPlanFrame(plan hybridqp.QueryNode) *PlanFrame

+ type Port interface

+ Close func()

+ Connect func(to Port)

+ ConnectionId func() uintptr

+ Equal func(to Port) bool

+ Redirect func(to Port)

+ Release func()

+ type Ports []Port

+ func (ports Ports) Close()

+ func (ports Ports) Release()

+ type PreAggregateCallMapping struct

+ func GetPreAggregateCallMapping() *PreAggregateCallMapping

+ func NewPreAggregateCallMapping() *PreAggregateCallMapping

+ func (mapping *PreAggregateCallMapping) Contains(name string) bool

+ type PrepareStmtBuilderCreator struct

+ func (p *PrepareStmtBuilderCreator) Create(stmt *influxql.SelectStatement, opt hybridqp.Options, shards interface{ ... }, ...) query.PreparedStatement

+ type Processor interface

+ Analyze func(span *tracing.Span)

+ Close func()

+ Explain func() []ValuePair

+ FinishSpan func()

+ GetInputNumber func(port Port) int

+ GetInputs func() Ports

+ GetOutputNumber func(port Port) int

+ GetOutputs func() Ports

+ IsSink func() bool

+ Name func() string

+ Release func() error

+ StartSpan func(name string, withPP bool) *tracing.Span

+ Work func(ctx context.Context) error

+ type Processors []Processor

+ func (ps *Processors) Pop() Processor

+ func (ps *Processors) Push(p Processor)

+ func (ps Processors) Close()

+ func (ps Processors) Empty() bool

+ func (ps Processors) Peek() Processor

+ func (ps Processors) Size() int

+ type QueryNodeCodec struct

+ func (c *QueryNodeCodec) Marshal(plan LogicalPlan, nodes ...hybridqp.QueryNode) ([]byte, error)

+ func (c *QueryNodeCodec) Unmarshal(plan *LogicalPlanBase, child hybridqp.QueryNode, pb *internal.QueryNode, ...) error

+ func (c *QueryNodeCodec) UnmarshalBinary(buf []byte) (hybridqp.QueryNode, error)

+ type QueryNodeStack []hybridqp.QueryNode

+ func NewQueryNodeStack(capacity int) *QueryNodeStack

+ func (s *QueryNodeStack) Empty() bool

+ func (s *QueryNodeStack) Peek() hybridqp.QueryNode

+ func (s *QueryNodeStack) Pop() hybridqp.QueryNode

+ func (s *QueryNodeStack) Push(node hybridqp.QueryNode)

+ func (s *QueryNodeStack) Size() int

+ type QuerySchema struct

+ func NewQuerySchema(fields influxql.Fields, columnNames []string, opt hybridqp.Options) *QuerySchema

+ func NewQuerySchemaWithSources(fields influxql.Fields, sources influxql.Sources, columnNames []string, ...) *QuerySchema

+ func (qs *QuerySchema) AddMath(key string, math *influxql.Call)

+ func (qs *QuerySchema) AddSlidingWindow(key string, str *influxql.Call)

+ func (qs *QuerySchema) AddString(key string, str *influxql.Call)

+ func (qs *QuerySchema) AddTable(m *influxql.Measurement, refs []influxql.VarRef)

+ func (qs *QuerySchema) Binarys() map[string]*influxql.BinaryExpr

+ func (qs *QuerySchema) Calls() map[string]*influxql.Call

+ func (qs *QuerySchema) CanAggPushDown() bool

+ func (qs *QuerySchema) CanCallsPushdown() bool

+ func (qs *QuerySchema) CanLimitCut() bool

+ func (qs *QuerySchema) CloneField(f *influxql.Field) *influxql.Field

+ func (qs *QuerySchema) ContainSeriesIgnoreCall() bool

+ func (qs *QuerySchema) CountDistinct() *influxql.Call

+ func (qs *QuerySchema) CountField() map[int]bool

+ func (qs *QuerySchema) DerivedOrigCall(call *influxql.Call) influxql.VarRef

+ func (qs *QuerySchema) DerivedRef(ref *influxql.VarRef) influxql.VarRef

+ func (qs *QuerySchema) Fields() influxql.Fields

+ func (qs *QuerySchema) FieldsMap() map[string]*influxql.Field

+ func (qs *QuerySchema) FieldsRef() influxql.VarRefs

+ func (qs *QuerySchema) GetColumnNames() []string

+ func (qs *QuerySchema) GetOptions() hybridqp.Options

+ func (qs *QuerySchema) GetQueryFields() influxql.Fields

+ func (qs *QuerySchema) HasBlankRowCall() bool

+ func (qs *QuerySchema) HasCall() bool

+ func (qs *QuerySchema) HasFieldCondition() bool

+ func (qs *QuerySchema) HasGroupBy() bool

+ func (qs *QuerySchema) HasInSeriesAgg() bool

+ func (qs *QuerySchema) HasInterval() bool

+ func (qs *QuerySchema) HasLimit() bool

+ func (qs *QuerySchema) HasMath() bool

+ func (qs *QuerySchema) HasMeanCall() bool

+ func (qs *QuerySchema) HasNonPreCall() bool

+ func (qs *QuerySchema) HasNotInSeriesAgg() bool

+ func (qs *QuerySchema) HasSlidingWindowCall() bool

+ func (qs *QuerySchema) HasStreamCall() bool

+ func (qs *QuerySchema) HasString() bool

+ func (qs *QuerySchema) HasSubQuery() bool

+ func (qs *QuerySchema) IsMultiMeasurements() bool

+ func (qs *QuerySchema) IsRefInQueryFields(ref *influxql.VarRef) bool

+ func (qs *QuerySchema) IsRefInSymbolFields(ref *influxql.VarRef) bool

+ func (qs *QuerySchema) IsTimeZero() bool

+ func (qs *QuerySchema) LimitAndOffset() (int, int)

+ func (qs *QuerySchema) LimitType() hybridqp.LimitType

+ func (qs *QuerySchema) MakeRefs() []influxql.VarRef

+ func (qs *QuerySchema) Mapping() map[influxql.Expr]influxql.VarRef

+ func (qs *QuerySchema) MatchPreAgg() bool

+ func (qs *QuerySchema) OnlyOneCallRef() *influxql.VarRef

+ func (qs *QuerySchema) Options() hybridqp.Options

+ func (qs *QuerySchema) OrigCalls() map[string]*influxql.Call

+ func (qs *QuerySchema) Refs() map[string]*influxql.VarRef

+ func (qs *QuerySchema) SetOpt(opt hybridqp.Options)

+ func (qs *QuerySchema) SlidingWindow() map[string]*influxql.Call

+ func (qs *QuerySchema) Sources() influxql.Sources

+ func (qs *QuerySchema) Symbols() map[string]influxql.VarRef

+ func (qs *QuerySchema) Table(name string) *QueryTable

+ func (qs *QuerySchema) Visit(n influxql.Node) influxql.Visitor

+ type QuerySchemaCreator struct

+ func (c *QuerySchemaCreator) Create(fields influxql.Fields, columnNames []string, opt hybridqp.Options) hybridqp.Catalog

+ type QueryTable struct

+ func NewQueryTable(m *influxql.Measurement, refs []influxql.VarRef) *QueryTable

+ func (b *QueryTable) Name() string

+ func (b *QueryTable) RowDataType() hybridqp.RowDataType

+ type RPCClient struct

+ func NewRPCClient(ctx context.Context, query *RemoteQuery) *RPCClient

+ func (c *RPCClient) Abort()

+ func (c *RPCClient) AddHandler(msgType byte, handle Handler)

+ func (c *RPCClient) FinishAnalyze()

+ func (c *RPCClient) GetCodec() transport.Codec

+ func (c *RPCClient) Handle(data interface{}) error

+ func (c *RPCClient) Run() error

+ func (c *RPCClient) StartAnalyze(span *tracing.Span)

+ type RPCReaderTransform struct

+ Chunk Chunk

+ Output *ChunkPort

+ Table *QueryTable

+ func NewRPCReaderTransform(outRowDataType hybridqp.RowDataType, opt query.ProcessorOptions, ...) *RPCReaderTransform

+ func (t *RPCReaderTransform) Abort()

+ func (t *RPCReaderTransform) Close()

+ func (t *RPCReaderTransform) Distribute(node hybridqp.QueryNode)

+ func (t *RPCReaderTransform) Explain() []ValuePair

+ func (t *RPCReaderTransform) GetInputNumber(_ Port) int

+ func (t *RPCReaderTransform) GetInputs() Ports

+ func (t *RPCReaderTransform) GetOutputNumber(_ Port) int

+ func (t *RPCReaderTransform) GetOutputs() Ports

+ func (t *RPCReaderTransform) IsSink() bool

+ func (t *RPCReaderTransform) Name() string

+ func (t *RPCReaderTransform) Release() error

+ func (t *RPCReaderTransform) Work(ctx context.Context) error

+ type RPCSenderTransform struct

+ Input *ChunkPort

+ func NewRPCSenderTransform(rt hybridqp.RowDataType, w spdy.Responser) *RPCSenderTransform

+ func (t *RPCSenderTransform) Close()

+ func (t *RPCSenderTransform) Explain() []ValuePair

+ func (t *RPCSenderTransform) GetInputNumber(_ Port) int

+ func (t *RPCSenderTransform) GetInputs() Ports

+ func (t *RPCSenderTransform) GetOutputNumber(_ Port) int

+ func (t *RPCSenderTransform) GetOutputs() Ports

+ func (t *RPCSenderTransform) Name() string

+ func (t *RPCSenderTransform) Work(ctx context.Context) error

+ type ReaderUpdateInSubQueryRule struct

+ func NewReaderUpdateInSubQueryRule(description string) *ReaderUpdateInSubQueryRule

+ func (r *ReaderUpdateInSubQueryRule) Catagory() OptRuleCatagory

+ func (r *ReaderUpdateInSubQueryRule) Equals(rhs OptRule) bool

+ func (r *ReaderUpdateInSubQueryRule) OnMatch(call *OptRuleCall)

+ func (r *ReaderUpdateInSubQueryRule) ToString() string

+ type ReflectionTable []int

+ type ReflectionTables []ReflectionTable

+ type RemoteQuery struct

+ Analyze bool

+ Database string

+ Node []byte

+ NodeID uint64

+ Opt query.ProcessorOptions

+ PtID uint32

+ ShardIDs []uint64

+ func (c *RemoteQuery) Instance() transport.Codec

+ func (c *RemoteQuery) Marshal(buf []byte) ([]byte, error)

+ func (c *RemoteQuery) Size() int

+ func (c *RemoteQuery) Unmarshal(buf []byte) error

+ type Routine interface

+ WorkOnChunk func(Chunk, Chunk, *IteratorParams)

+ func NewAbsentRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) (Routine, error)

+ func NewBottomRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) (Routine, error)

+ func NewCountRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) (Routine, error)

+ func NewCumulativeSumRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) (Routine, error)

+ func NewDerivativeRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) (Routine, error)

+ func NewDifferenceRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) (Routine, error)

+ func NewDistinctRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions) (Routine, error)

+ func NewElapsedRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) (Routine, error)

+ func NewFirstRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) (Routine, error)

+ func NewIntegralRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) (Routine, error)

+ func NewLastRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) (Routine, error)

+ func NewMaxRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) (Routine, error)

+ func NewMedianRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) (Routine, error)

+ func NewMinRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) (Routine, error)

+ func NewModeRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) (Routine, error)

+ func NewMovingAverageRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) (Routine, error)

+ func NewPercentileRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) (Routine, error)

+ func NewRateRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) (Routine, error)

+ func NewSampleRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) (Routine, error)

+ func NewSlidingWindowCountRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) Routine

+ func NewSlidingWindowMaxRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) Routine

+ func NewSlidingWindowMinRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) Routine

+ func NewSlidingWindowSumRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) Routine

+ func NewStddevRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) (Routine, error)

+ func NewSumRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) (Routine, error)

+ func NewTopRoutineImpl(inRowDataType, outRowDataType hybridqp.RowDataType, opt hybridqp.ExprOptions, ...) (Routine, error)

+ type RoutineImpl struct

+ func NewRoutineImpl(iterator Iterator, inOrdinal int, outOrdinal int) *RoutineImpl

+ func (r *RoutineImpl) WorkOnChunk(in Chunk, out Chunk, params *IteratorParams)

+ type Row struct

+ type RowChunk struct

+ ColumnName []string

+ Name string

+ Series []*Row

+ Tags []ChunkTags

+ func (r *RowChunk) RowsGen(c Chunk) []*Row

+ func (r *RowChunk) RowsInit(c Chunk)

+ type Rows struct

+ Series Series

+ Time []int64

+ Values [][]interface{}

+ type RuleInstruction struct

+ func NewRuleInstruction(ruleCatatory OptRuleCatagory) *RuleInstruction

+ func (g *RuleInstruction) Execute(planner HeuPlanner)

+ func (g *RuleInstruction) Initialize(clearCache bool)

+ func (g *RuleInstruction) RuleCatagory() OptRuleCatagory

+ type RuleSet map[OptRule]struct

+ func (rs RuleSet) Add(rule OptRule)

+ func (rs RuleSet) AddAll(ruleSet RuleSet)

+ type SQL_TEST_IDENTIFIER int

+ var MOCK_SCANNER_STORAGE SQL_TEST_IDENTIFIER = 0x03

+ var MOCK_SENDER_HANDLER SQL_TEST_IDENTIFIER = 0x02

+ var MOCK_TESTING_DESC SQL_TEST_IDENTIFIER = 0x01

+ type Segment struct

+ func NewSegment(pts *influx.PointTags, data Chunk) *Segment

+ func (seg *Segment) Data() Chunk

+ func (seg *Segment) GroupValue(keys ...string) string

+ func (seg *Segment) PointTags() *influx.PointTags

+ type Semaphore int

+ type Series struct

+ Name string

+ Tags ChunkTags

+ type SetSchemaVisitor struct

+ func (v *SetSchemaVisitor) Visit(node hybridqp.QueryNode) hybridqp.QueryNodeVisitor

+ type SinkFromFunction struct

+ Function func(chunk Chunk) error

+ Input *ChunkPort

+ func NewSinkFromFunction(rowDataType hybridqp.RowDataType, function func(chunk Chunk) error) *SinkFromFunction

+ func (sink *SinkFromFunction) Close()

+ func (sink *SinkFromFunction) Explain() []ValuePair

+ func (sink *SinkFromFunction) GetInputNumber(_ Port) int

+ func (sink *SinkFromFunction) GetInputs() Ports

+ func (sink *SinkFromFunction) GetOutputNumber(_ Port) int

+ func (sink *SinkFromFunction) GetOutputs() Ports

+ func (sink *SinkFromFunction) Name() string

+ func (sink *SinkFromFunction) Work(ctx context.Context) error

+ type SlideWindowSpreadRule struct

+ func NewSlideWindowSpreadRule(description string) *SlideWindowSpreadRule

+ func (r *SlideWindowSpreadRule) Catagory() OptRuleCatagory

+ func (r *SlideWindowSpreadRule) Equals(rhs OptRule) bool

+ func (r *SlideWindowSpreadRule) OnMatch(call *OptRuleCall)

+ func (r *SlideWindowSpreadRule) ToString() string

+ type SlidingWindowTransform struct

+ Inputs ChunkPorts

+ Outputs ChunkPorts

+ func NewSlidingWindowTransform(inRowDataType, outRowDataType []hybridqp.RowDataType, ...) *SlidingWindowTransform

+ func (trans *SlidingWindowTransform) Close()

+ func (trans *SlidingWindowTransform) Explain() []ValuePair

+ func (trans *SlidingWindowTransform) GetInputNumber(port Port) int

+ func (trans *SlidingWindowTransform) GetInputs() Ports

+ func (trans *SlidingWindowTransform) GetOutputNumber(port Port) int

+ func (trans *SlidingWindowTransform) GetOutputs() Ports

+ func (trans *SlidingWindowTransform) Name() string

+ func (trans *SlidingWindowTransform) Work(ctx context.Context) error

+ type SlidingWindowTransformCreator struct

+ func (c *SlidingWindowTransformCreator) Create(plan LogicalPlan, opt query.ProcessorOptions) (Processor, error)

+ type SortAppendTransform struct

+ BreakPoint *SortedBreakPoint

+ CoProcessor CoProcessor

+ HeapItems *AppendHeapItems

+ Inputs ChunkPorts

+ NewChunk Chunk

+ NextChunk []chan Semaphore

+ Outputs ChunkPorts

+ WaitMerge chan Semaphore

+ func NewSortAppendTransform(inRowDataType []hybridqp.RowDataType, outRowDataType []hybridqp.RowDataType, ...) *SortAppendTransform

+ func (trans *SortAppendTransform) AddIntervalIndex(chunk Chunk, i int, opt query.ProcessorOptions) bool

+ func (trans *SortAppendTransform) AddTagAndIndexes(tag ChunkTags, i int)

+ func (trans *SortAppendTransform) AppendMergeTimeAndColumns(i int)

+ func (trans *SortAppendTransform) AppendToHeap(in int, c Chunk)

+ func (trans *SortAppendTransform) Close()

+ func (trans *SortAppendTransform) Explain() []ValuePair

+ func (trans *SortAppendTransform) GetInputNumber(port Port) int

+ func (trans *SortAppendTransform) GetInputs() Ports

+ func (trans *SortAppendTransform) GetOutputNumber(port Port) int

+ func (trans *SortAppendTransform) GetOutputs() Ports

+ func (trans *SortAppendTransform) GetSortedBreakPoint()

+ func (trans *SortAppendTransform) Merge(ctx context.Context, errs *Errs, errSignals *ErrorSignals)

+ func (trans *SortAppendTransform) Name() string

+ func (trans *SortAppendTransform) SendChunk()

+ func (trans *SortAppendTransform) UpdateWithSingleChunk()

+ func (trans *SortAppendTransform) Work(ctx context.Context) error

+ type SortAppendTransformCreator struct

+ func (c *SortAppendTransformCreator) Create(plan LogicalPlan, _ query.ProcessorOptions) (Processor, error)

+ type SortMergeTransformCreator struct

+ func (c *SortMergeTransformCreator) Create(plan LogicalPlan, _ query.ProcessorOptions) (Processor, error)

+ type SortedBreakPoint struct

+ AuxCompareHelpers SortedMergeAuxHelpers

+ Tag ChunkTags

+ Time int64

+ ValuePosition int

+ type SortedHeapItems struct

+ AuxCompareHelpers SortedMergeAuxHelpers

+ Items []*Item

+ func (h *SortedHeapItems) GetSortedBreakPoint() *SortedBreakPoint

+ func (h *SortedHeapItems) Len() int

+ func (h *SortedHeapItems) Less(i, j int) bool

+ func (h *SortedHeapItems) Pop() interface{}

+ func (h *SortedHeapItems) Push(x interface{})

+ func (h *SortedHeapItems) Swap(i, j int)

+ type SortedMergeAuxHelper struct

+ type SortedMergeAuxHelpers []*SortedMergeAuxHelper

+ func AuxHelper(opt query.ProcessorOptions, rt hybridqp.RowDataType, ...) SortedMergeAuxHelpers

+ func (s SortedMergeAuxHelpers) Len() int

+ func (s SortedMergeAuxHelpers) Less(i, j int) bool

+ func (s SortedMergeAuxHelpers) Swap(i, j int)

+ type SortedMergeTransform struct

+ BreakPoint *SortedBreakPoint

+ CoProcessor CoProcessor

+ HeapItems *SortedHeapItems

+ Inputs ChunkPorts

+ NewChunk Chunk

+ NextChunk []chan Semaphore

+ Outputs ChunkPorts

+ WaitMerge chan Semaphore

+ func NewSortedMergeTransform(inRowDataType []hybridqp.RowDataType, outRowDataType []hybridqp.RowDataType, ...) *SortedMergeTransform

+ func (trans *SortedMergeTransform) AddIntervalIndex(chunk Chunk, i int, opt query.ProcessorOptions) bool

+ func (trans *SortedMergeTransform) AddTagAndIndexes(tag ChunkTags, i int)

+ func (trans *SortedMergeTransform) AppendMergeTimeAndColumns(i int)

+ func (trans *SortedMergeTransform) AppendToHeap(in int, c Chunk)

+ func (trans *SortedMergeTransform) Close()

+ func (trans *SortedMergeTransform) Explain() []ValuePair

+ func (trans *SortedMergeTransform) GetInputNumber(port Port) int

+ func (trans *SortedMergeTransform) GetInputs() Ports

+ func (trans *SortedMergeTransform) GetOutputNumber(port Port) int

+ func (trans *SortedMergeTransform) GetOutputs() Ports

+ func (trans *SortedMergeTransform) GetSortedBreakPoint()

+ func (trans *SortedMergeTransform) Merge(ctx context.Context, errs *Errs, errSignals *ErrorSignals)

+ func (trans *SortedMergeTransform) Name() string

+ func (trans *SortedMergeTransform) SendChunk()

+ func (trans *SortedMergeTransform) UpdateWithSingleChunk()

+ func (trans *SortedMergeTransform) Work(ctx context.Context) error

+ type SourceFromSingleChunk struct

+ Chunk Chunk

+ Output *ChunkPort

+ func NewSourceFromSingleChunk(rowDataType hybridqp.RowDataType, chunk Chunk) *SourceFromSingleChunk

+ func (source *SourceFromSingleChunk) Close()

+ func (source *SourceFromSingleChunk) Explain() []ValuePair

+ func (source *SourceFromSingleChunk) GetInputNumber(_ Port) int

+ func (source *SourceFromSingleChunk) GetInputs() Ports

+ func (source *SourceFromSingleChunk) GetOutputNumber(_ Port) int

+ func (source *SourceFromSingleChunk) GetOutputs() Ports

+ func (source *SourceFromSingleChunk) Name() string

+ func (source *SourceFromSingleChunk) Work(ctx context.Context) error

+ type Spacer struct

+ Space int

+ func NewSpacer() *Spacer

+ func (s *Spacer) Add(num int)

+ func (s *Spacer) String() string

+ func (s *Spacer) Sub(num int)

+ type StdoutChunkWriter struct

+ func NewStdoutChunkWriter() *StdoutChunkWriter

+ func (w *StdoutChunkWriter) Close()

+ func (w *StdoutChunkWriter) Write(chunk Chunk)

+ type Storage struct

+ func NewStorage(catalog *Catalog) *Storage

+ func (s *Storage) MemStore(path string) (*MemStore, error)

+ func (s *Storage) Write(path string, pts *influx.PointTags, data Chunk) error

+ type StoreExchangeTraits struct

+ func NewStoreExchangeTraits(w spdy.Responser, mapShardsToReaders map[uint64][][]interface{}) *StoreExchangeTraits

+ func (t *StoreExchangeTraits) HasReader() bool

+ func (t *StoreExchangeTraits) HasShard() bool

+ func (t *StoreExchangeTraits) NextReader() []interface{}

+ func (t *StoreExchangeTraits) NextShard() uint64

+ func (t *StoreExchangeTraits) PeekReader() []interface{}

+ func (t *StoreExchangeTraits) PeekShard() uint64

+ func (t *StoreExchangeTraits) Readers(shard uint64) [][]interface{}

+ func (t *StoreExchangeTraits) Reset()

+ type StreamAggregateTransform struct

+ Inputs ChunkPorts

+ Outputs ChunkPorts

+ func NewStreamAggregateTransform(inRowDataType, outRowDataType []hybridqp.RowDataType, ...) (*StreamAggregateTransform, error)

+ func (trans *StreamAggregateTransform) Close()

+ func (trans *StreamAggregateTransform) Explain() []ValuePair

+ func (trans *StreamAggregateTransform) GetInputNumber(port Port) int

+ func (trans *StreamAggregateTransform) GetInputs() Ports

+ func (trans *StreamAggregateTransform) GetOutputNumber(port Port) int

+ func (trans *StreamAggregateTransform) GetOutputs() Ports

+ func (trans *StreamAggregateTransform) Name() string

+ func (trans *StreamAggregateTransform) Work(ctx context.Context) error

+ type StreamAggregateTransformCreator struct

+ func (c *StreamAggregateTransformCreator) Create(plan LogicalPlan, opt query.ProcessorOptions) (Processor, error)

+ type StringAlignIterator struct

+ func NewStringAlignIterator() *StringAlignIterator

+ func (f *StringAlignIterator) Next(endpoint *IteratorEndpoint, _ *IteratorParams)

+ type StringAppendIterator struct

+ func NewStringAppendIterator() *StringAppendIterator

+ func (f *StringAppendIterator) Next(endpoint *IteratorEndpoint, params *IteratorParams)

+ type StringColIntegerIterator struct

+ func NewStringColIntegerIterator(fn StringColIntegerReduce, fv StringColIntegerMerge, isSingleCall bool, ...) *StringColIntegerIterator

+ func (r *StringColIntegerIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type StringColIntegerMerge func(prevPoint, currPoint *IntegerPoint)

+ type StringColIntegerReduce func(c Chunk, ordinal, start, end int) (index int, value int64, isNil bool)

+ type StringColIntegerWindowReduce func(c Chunk, ordinal, start, end int) (index int, value int64, isNil bool)

+ type StringColReduceSliceReduce func(stringItem *StringSliceItem) (index int, time int64, value float64, isNil bool)

+ type StringColStringDistinctIterator struct

+ func NewStringColStringDistinctIterator(inOrdinal, outOrdinal int) *StringColStringDistinctIterator

+ func (r *StringColStringDistinctIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type StringColStringIterator struct

+ func NewStringColStringIterator(fn StringColStringReduce, fv StringColStringMerge, isSingleCall bool, ...) *StringColStringIterator

+ func (r *StringColStringIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type StringColStringMerge func(prevPoint, currPoint *StringPoint)

+ type StringColStringReduce func(c Chunk, ordinal, start, end int) (index int, value string, isNil bool)

+ type StringColStringSampleIterator struct

+ func NewStringColStringSampleIterator(sampleNum int, isSingleCall bool, inOrdinal, outOrdinal int, ...) *StringColStringSampleIterator

+ func (r *StringColStringSampleIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type StringColStringSliceIterator struct

+ func NewStringColStringSliceIterator(fn StringColReduceSliceReduce, isSingleCall bool, inOrdinal, outOrdinal int, ...) *StringColStringSliceIterator

+ func (r *StringColStringSliceIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type StringDistinctItem struct

+ func NewStringDistinctItem() *StringDistinctItem

+ func (f *StringDistinctItem) Len() int

+ func (f *StringDistinctItem) Less(i, j int) bool

+ func (f *StringDistinctItem) Nil() bool

+ func (f *StringDistinctItem) Reset()

+ func (f *StringDistinctItem) Swap(i, j int)

+ type StringIntervalIterator struct

+ func NewStringIntervalIterator() *StringIntervalIterator

+ func (f *StringIntervalIterator) Next(endpoint *IteratorEndpoint, _ *IteratorParams)

+ type StringLimitIterator struct

+ func NewStringLimitIterator() *StringLimitIterator

+ func (f *StringLimitIterator) Next(endpoint *IteratorEndpoint, params *IteratorParams)

+ type StringLinearFillProcessor struct

+ func NewStringLinearFillProcessor(inOrdinal, outOrdinal int) *StringLinearFillProcessor

+ type StringMergeIterator struct

+ func NewStringMergeIterator() *StringMergeIterator

+ func (f *StringMergeIterator) Next(endpoint *IteratorEndpoint, params *IteratorParams)

+ type StringNullFillProcessor struct

+ func NewStringNullFillProcessor(inOrdinal, outOrdinal int) *StringNullFillProcessor

+ type StringNumberFillProcessor struct

+ func NewStringNumberFillProcessor(inOrdinal, outOrdinal int) *StringNumberFillProcessor

+ type StringPoint struct

+ func (p *StringPoint) Assign(c *StringPoint)

+ func (p *StringPoint) Reset()

+ func (p *StringPoint) Set(index int, time int64, value string)

+ type StringPointItem struct

+ func NewStringPointItem(time int64, value string) *StringPointItem

+ type StringPreviousFillProcessor struct

+ func NewStringPreviousFillProcessor(inOrdinal, outOrdinal int) *StringPreviousFillProcessor

+ type StringSampleItem struct

+ func NewStringSampleItem(items []StringPointItem) *StringSampleItem

+ func (f *StringSampleItem) Len() int

+ func (f *StringSampleItem) Less(i, j int) bool

+ func (f *StringSampleItem) Reset()

+ func (f *StringSampleItem) Swap(i, j int)

+ type StringSliceItem struct

+ func NewStringSliceItem() *StringSliceItem

+ func (f *StringSliceItem) AppendItem(c Chunk, ordinal, start, end int)

+ func (f *StringSliceItem) Len() int

+ func (f *StringSliceItem) Less(i, j int) bool

+ func (f *StringSliceItem) Reset()

+ func (f *StringSliceItem) Swap(i, j int)

+ type StringSlidingWindowIntegerIterator struct

+ func NewStringSlidingWindowIntegerIterator(fwr StringColIntegerWindowReduce, fpm IntegerPointMerge, ...) *StringSlidingWindowIntegerIterator

+ func (r *StringSlidingWindowIntegerIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type StringTimeColStringIterator struct

+ func NewStringTimeColStringIterator(fn StringTimeColStringReduce, fv StringTimeColStringMerge, ...) *StringTimeColStringIterator

+ func (r *StringTimeColStringIterator) Next(ie *IteratorEndpoint, p *IteratorParams)

+ type StringTimeColStringMerge func(prevPoint, currPoint *StringPoint)

+ type StringTimeColStringReduce func(c Chunk, ordinal, start, end int) (index int, value string, isNil bool)

+ type StringValuer struct

+ func (StringValuer) SetValuer(_ influxql.Valuer, _ int)

+ func (StringValuer) Value(_ string) (interface{}, bool)

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

+ type SubQueryBuilder struct

+ func (b *SubQueryBuilder) Build(ctx context.Context, opt query.ProcessorOptions) (hybridqp.QueryNode, error)

+ type SubQueryTransform struct

+ func NewSubQueryTransform(inRowDataType hybridqp.RowDataType, outRowDataType hybridqp.RowDataType, ...) *SubQueryTransform

+ func (trans *SubQueryTransform) Close()

+ func (trans *SubQueryTransform) Explain() []ValuePair

+ func (trans *SubQueryTransform) GetInputNumber(_ Port) int

+ func (trans *SubQueryTransform) GetInputs() Ports

+ func (trans *SubQueryTransform) GetOutputNumber(_ Port) int

+ func (trans *SubQueryTransform) GetOutputs() Ports

+ func (trans *SubQueryTransform) Name() string

+ func (trans *SubQueryTransform) Release() error

+ func (trans *SubQueryTransform) Work(ctx context.Context) error

+ type SubQueryTransformCreator struct

+ func (c *SubQueryTransformCreator) Create(plan LogicalPlan, opt query.ProcessorOptions) (Processor, error)

+ type TSDBSystem struct

+ func NewTSDBSystem() *TSDBSystem

+ func (s *TSDBSystem) DDL(handler func(*Catalog) error) error

+ func (s *TSDBSystem) DML(handler func(*Storage) error) error

+ func (s *TSDBSystem) ExecSQL(sql string, validator func([]Chunk)) error

+ type Table struct

+ func NewTable(name string) *Table

+ func (t *Table) AddDataType(col string, typ influxql.DataType)

+ func (t *Table) AddDataTypes(typs map[string]influxql.DataType)

+ func (t *Table) DataType(col string) influxql.DataType

+ func (t *Table) DbPath() string

+ func (t *Table) Name() string

+ func (t *Table) Path() string

+ func (t *Table) SetDbPath(dbPath string)

+ type TableScanFromSingleChunk struct

+ Builder *ChunkBuilder

+ Chunk Chunk

+ Output *ChunkPort

+ Table *QueryTable

+ func NewTableScanFromSingleChunk(rowDataType hybridqp.RowDataType, table *QueryTable, _ query.ProcessorOptions) *TableScanFromSingleChunk

+ func (scan *TableScanFromSingleChunk) Close()

+ func (scan *TableScanFromSingleChunk) Explain() []ValuePair

+ func (scan *TableScanFromSingleChunk) GetInputNumber(_ Port) int

+ func (scan *TableScanFromSingleChunk) GetInputs() Ports

+ func (scan *TableScanFromSingleChunk) GetOutputNumber(_ Port) int

+ func (scan *TableScanFromSingleChunk) GetOutputs() Ports

+ func (scan *TableScanFromSingleChunk) Name() string

+ func (scan *TableScanFromSingleChunk) Work(ctx context.Context) error

+ type TransItem interface

+ AppendItem func(Chunk, int, int, int, bool)

+ GetBaseTransData func() BaseTransData

+ Len func() int

+ PrevNil func() bool

+ Reset func()

+ ResetPrev func()

+ type TransformCreator interface

+ Create func(LogicalPlan, query.ProcessorOptions) (Processor, error)

+ type TransformCreatorFactory struct

+ func GetTransformFactoryInstance() *TransformCreatorFactory

+ func NewTransformCreatorFactory() *TransformCreatorFactory

+ func (r *TransformCreatorFactory) Add(name string, creator TransformCreator)

+ func (r *TransformCreatorFactory) Find(name string) (TransformCreator, bool)

+ type TransformDag struct

+ func NewTransformDag() *TransformDag

+ func (dag *TransformDag) AddEdge(from *TransformVertex, to *TransformVertex) bool

+ func (dag *TransformDag) AddVertex(vertex *TransformVertex) bool

+ func (dag *TransformDag) Contains(vertex *TransformVertex) bool

+ func (dag *TransformDag) DepthFirstWalkVertex(visitor TransformVertexVisitor, vertex *TransformVertex)

+ func (dag *TransformDag) WalkVertex(vertex *TransformVertex, fn func(to, from *TransformVertex))

+ type TransformEdge struct

+ func NewTransformEdge(from *TransformVertex, to *TransformVertex) *TransformEdge

+ type TransformVertex struct

+ func NewTransformVertex(node hybridqp.QueryNode, transform Processor) *TransformVertex

+ type TransformVertexInfo struct

+ func NewTransformVertexInfo() *TransformVertexInfo

+ func (info *TransformVertexInfo) AddBackwardEdge(edge *TransformEdge)

+ func (info *TransformVertexInfo) AddDirectEdge(edge *TransformEdge)

+ type TransformVertexVisitor interface

+ Visit func(*TransformVertex) TransformVertexVisitor

+ type UnRefDbPt struct

+ Db string

+ Pt uint32

+ type ValuePair struct

+ First string

+ Second interface{}

+ func NewValuePair(first string, second interface{}) *ValuePair

+ type Vertex struct

+ BackEdges Edges

+ DirectEdges Edges

+ Id VertexId

+ Processor Processor

+ func NewVertex(id VertexId, processor Processor) *Vertex

+ func (vertex *Vertex) Degree() int

+ func (vertex *Vertex) Explain(w VertexWriter)

+ func (vertex *Vertex) InDegree() int

+ func (vertex *Vertex) OutDegree() int

+ type VertexId int

+ type VertexWriter interface

+ Explain func(*Vertex)

+ Item func(string, interface{})

+ String func() string

+ type VertexWriterImpl struct

+ Builder *strings.Builder

+ DAG *DAG

+ Spacer *Spacer

+ Values *list.List

+ func NewVertexWriterImpl(dag *DAG, builder *strings.Builder) *VertexWriterImpl

+ func (w *VertexWriterImpl) Explain(vertex *Vertex)

+ func (w *VertexWriterImpl) ExplainEdges(edges Edges)

+ func (w *VertexWriterImpl) Item(term string, value interface{})

+ func (w *VertexWriterImpl) String() string

+ type Vertexs []*Vertex

+ type WalkFn func(vertex *Vertex, m map[VertexId]int) error

+ type WorkHelper interface

+ Work func(ctx context.Context) error

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