query

package
v2.6.1 Latest Latest
Warning

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

Go to latest
Published: Dec 29, 2022 License: MIT Imports: 32 Imported by: 1

Documentation

Index

Constants

View Source
const (
	NoContentDialectType     = "no-content"
	NoContentWErrDialectType = "no-content-with-error"
)
View Source
const (
	PreferHeaderKey                = "Prefer"
	PreferNoContentHeaderValue     = "return-no-content"
	PreferNoContentWErrHeaderValue = "return-no-content-with-error"
)
View Source
const ZeroTime = int64(math.MinInt64)

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

Variables

View Source
var (
	// ErrQueryInterrupted is an error returned when the query is interrupted.
	ErrQueryInterrupted = errors.New("query interrupted")
)
View Source
var OpenAuthorizer = openAuthorizer{}

OpenAuthorizer can be shared by all goroutines.

Functions

func AddDialectMappings

func AddDialectMappings(mappings flux.DialectMappings) error

AddDialectMappings adds the mappings for the no-content dialects.

func ContextWithRequest

func ContextWithRequest(ctx context.Context, req *Request) context.Context

ContextWithRequest returns a new context with a reference to the request.

func EvalAST

EvalAST will evaluate and run an AST.

This will return an error if the FluxLanguageService is nil.

func Parse

func Parse(lang fluxlang.FluxLanguageService, source string) (*ast.Package, error)

Parse will take flux source code and produce a package. If there are errors when parsing, the first error is returned. An ast.Package may be returned when a parsing error occurs, but it may be null if parsing didn't even occur.

This will return an error if the FluxLanguageService is nil.

func SetReturnNoContent

func SetReturnNoContent(header http.Header, withError bool)

SetReturnNoContent sets the header for a Request to return no content.

Types

type AsyncQueryService

type AsyncQueryService interface {
	// Query submits a query for execution returning immediately.
	// Done must be called on any returned Query objects.
	Query(ctx context.Context, req *Request) (flux.Query, error)
}

AsyncQueryService represents a service for performing queries where the results are delivered asynchronously.

type Authorizer

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

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

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

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

Authorizer determines if certain operations are authorized.

type BooleanIterator

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

BooleanIterator represents a stream of boolean points.

type BooleanPoint

type BooleanPoint struct {
	Name string
	Tags Tags

	Time  int64
	Value bool
	Aux   []interface{}

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

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

type BucketLookup

type BucketLookup struct {
	BucketService influxdb.BucketService
}

BucketLookup converts Flux bucket lookups into influxdb.BucketService calls.

func FromBucketService

func FromBucketService(srv influxdb.BucketService) *BucketLookup

FromBucketService wraps an influxdb.BucketService in the BucketLookup interface.

func (*BucketLookup) FindAllBuckets

func (b *BucketLookup) FindAllBuckets(ctx context.Context, orgID platform.ID) ([]*influxdb.Bucket, int)

func (*BucketLookup) Lookup

func (b *BucketLookup) Lookup(ctx context.Context, orgID platform.ID, name string) (platform.ID, bool)

Lookup returns the bucket id and its existence given an org id and bucket name.

func (*BucketLookup) LookupName

func (b *BucketLookup) LookupName(ctx context.Context, orgID platform.ID, id platform.ID) string

LookupName returns an bucket name given its organization ID and its bucket ID.

type FloatIterator

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

FloatIterator represents a stream of float points.

type FloatPoint

type FloatPoint struct {
	Name string
	Tags Tags

	Time  int64
	Value float64
	Aux   []interface{}

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

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

type GroupMode

type GroupMode int
const (
	// GroupModeNone merges all series into a single group.
	GroupModeNone GroupMode = iota
	// GroupModeBy produces a table for each unique value of the specified GroupKeys.
	GroupModeBy
)

func ToGroupMode

func ToGroupMode(fluxMode flux.GroupMode) GroupMode

ToGroupMode accepts the group mode from Flux and produces the appropriate storage group mode.

type IntegerIterator

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

IntegerIterator represents a stream of integer points.

type IntegerPoint

type IntegerPoint struct {
	Name string
	Tags Tags

	Time  int64
	Value int64
	Aux   []interface{}

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

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

type Interval

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

Interval represents a repeating interval for a query.

type Iterator

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

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

type IteratorCost

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

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

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

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

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

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

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

func (IteratorCost) Combine

func (c IteratorCost) Combine(other IteratorCost) IteratorCost

Combine combines the results of two IteratorCost structures into one.

type IteratorOptions

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

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

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

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

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

	// Condition to filter by.
	Condition influxql.Expr

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

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

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

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

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

	// Removes duplicate rows from raw queries.
	Dedupe bool

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

	// Limits on the creation of iterators.
	MaxSeriesN int

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

	// Authorizer can limit access to data
	Authorizer Authorizer
}

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

func (IteratorOptions) SeekTime

func (opt IteratorOptions) SeekTime() int64

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

func (IteratorOptions) StopTime

func (opt IteratorOptions) StopTime() int64

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

type IteratorStats

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

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

type Log

type Log struct {
	// Time is the time the query was completed
	Time time.Time
	// OrganizationID is the ID of the organization that requested the query
	OrganizationID platform2.ID
	// TraceID is the ID of the trace related to this query
	TraceID string
	// Sampled specifies whether the trace for TraceID was chosen for permanent storage
	// by the sampling mechanism of the tracer
	Sampled bool
	// Error is any error encountered by the query
	Error error

	// ProxyRequest is the query request
	ProxyRequest *ProxyRequest
	// ResponseSize is the size in bytes of the query response
	ResponseSize int64
	// Statistics is a set of statistics about the query execution
	Statistics flux.Statistics
}

Log captures a query and any relevant metadata for the query execution.

func (*Log) Redact

func (q *Log) Redact()

Redact removes any sensitive information before logging

type Logger

type Logger interface {
	Log(Log) error
}

Logger persists metadata about executed queries.

type LoggingProxyQueryService

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

LoggingProxyQueryService wraps a ProxyQueryService and logs the queries.

func NewLoggingProxyQueryService

func NewLoggingProxyQueryService(log *zap.Logger, queryLogger Logger, proxyQueryService ProxyQueryService, opts ...LoggingProxyQueryServiceOption) *LoggingProxyQueryService

func (*LoggingProxyQueryService) Check

func (*LoggingProxyQueryService) Query

func (s *LoggingProxyQueryService) Query(ctx context.Context, w io.Writer, req *ProxyRequest) (stats flux.Statistics, err error)

Query executes and logs the query.

func (*LoggingProxyQueryService) SetNowFunctionForTesting

func (s *LoggingProxyQueryService) SetNowFunctionForTesting(nowFunction func() time.Time)

type LoggingProxyQueryServiceOption

type LoggingProxyQueryServiceOption func(lpqs *LoggingProxyQueryService)

LoggingProxyQueryServiceOption provides a way to modify the behavior of LoggingProxyQueryService.

func ConditionalLogging

func ConditionalLogging(cond func(context.Context) bool) LoggingProxyQueryServiceOption

ConditionalLogging returns a LoggingProxyQueryServiceOption that only logs if the passed in function returns true. Thus logging can be controlled by a request-scoped attribute, e.g., a feature flag.

func RequireMetadataKey

func RequireMetadataKey(metadataKey string) LoggingProxyQueryServiceOption

type MathValuer

type MathValuer struct{}

func (MathValuer) Call

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

func (MathValuer) Value

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

type NoContentDialect

type NoContentDialect struct{}

NoContentDialect is a dialect that provides an Encoder that discards query results. When invoking `dialect.Encoder().Encode(writer, results)`, `results` get consumed, while the `writer` is left intact. It is an HTTPDialect that sets the response status code to 204 NoContent.

func NewNoContentDialect

func NewNoContentDialect() *NoContentDialect

func (*NoContentDialect) DialectType

func (d *NoContentDialect) DialectType() flux.DialectType

func (*NoContentDialect) Encoder

func (*NoContentDialect) SetHeaders

func (d *NoContentDialect) SetHeaders(w http.ResponseWriter)

type NoContentEncoder

type NoContentEncoder struct{}

func (*NoContentEncoder) Encode

func (e *NoContentEncoder) Encode(w io.Writer, results flux.ResultIterator) (int64, error)

type NoContentWithErrorDialect

type NoContentWithErrorDialect struct {
	csv.ResultEncoderConfig
}

NoContentWithErrorDialect is a dialect that provides an Encoder that discards query results, but it encodes runtime errors from the Flux query in CSV format. To discover if there was any runtime error in the query, one should check the response size. If it is equal to zero, then no error was present. Otherwise one can decode the response body to get the error. For example: ``` _, err = csv.NewResultDecoder(csv.ResultDecoderConfig{}).Decode(bytes.NewReader(res))

if err != nil {
  // we got some runtime error
}

```

func NewNoContentWithErrorDialect

func NewNoContentWithErrorDialect() *NoContentWithErrorDialect

func (*NoContentWithErrorDialect) DialectType

func (d *NoContentWithErrorDialect) DialectType() flux.DialectType

func (*NoContentWithErrorDialect) Encoder

func (*NoContentWithErrorDialect) SetHeaders

type NoContentWithErrorEncoder

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

func (*NoContentWithErrorEncoder) Encode

type OrganizationLookup

type OrganizationLookup struct {
	OrganizationService influxdb.OrganizationService
}

OrganizationLookup converts organization name lookups into influxdb.OrganizationService calls.

func FromOrganizationService

func FromOrganizationService(srv influxdb.OrganizationService) *OrganizationLookup

FromOrganizationService wraps a influxdb.OrganizationService in the OrganizationLookup interface.

func (*OrganizationLookup) Lookup

func (o *OrganizationLookup) Lookup(ctx context.Context, name string) (platform.ID, bool)

Lookup returns the organization ID and its existence given an organization name.

func (*OrganizationLookup) LookupName

func (o *OrganizationLookup) LookupName(ctx context.Context, id platform.ID) string

LookupName returns an organization name given its ID.

type ProxyQueryService

type ProxyQueryService interface {
	check.Checker

	// Query performs the requested query and encodes the results into w.
	// The number of bytes written to w is returned __independent__ of any error.
	Query(ctx context.Context, w io.Writer, req *ProxyRequest) (flux.Statistics, error)
}

ProxyQueryService performs queries and encodes the result into a writer. The results are opaque to a ProxyQueryService.

type ProxyQueryServiceAsyncBridge

type ProxyQueryServiceAsyncBridge struct {
	AsyncQueryService AsyncQueryService
}

ProxyQueryServiceAsyncBridge implements ProxyQueryService while consuming an AsyncQueryService

func (ProxyQueryServiceAsyncBridge) Check

Check returns the status of this query service. Since this bridge consumes an AsyncQueryService, which is not available over the network, this check always passes.

func (ProxyQueryServiceAsyncBridge) Query

type ProxyRequest

type ProxyRequest struct {
	// Request is the basic query request
	Request Request `json:"request"`

	// Dialect is the result encoder
	Dialect flux.Dialect `json:"dialect"`
	// contains filtered or unexported fields
}

ProxyRequest specifies a query request and the dialect for the results.

func (ProxyRequest) MarshalJSON

func (r ProxyRequest) MarshalJSON() ([]byte, error)

func (*ProxyRequest) UnmarshalJSON

func (r *ProxyRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON populates the request from the JSON data. WithCompilerMappings and WithDialectMappings must have been called or an error will occur.

func (*ProxyRequest) WithCompilerMappings

func (r *ProxyRequest) WithCompilerMappings(mappings flux.CompilerMappings)

WithCompilerMappings sets the compiler type mappings on the request.

func (*ProxyRequest) WithDialectMappings

func (r *ProxyRequest) WithDialectMappings(mappings flux.DialectMappings)

WithDialectMappings sets the dialect type mappings on the request.

type QueryService

type QueryService interface {
	check.Checker

	// Query submits a query for execution returning a results iterator.
	// Cancel must be called on any returned results to free resources.
	Query(ctx context.Context, req *Request) (flux.ResultIterator, error)
}

QueryService represents a type capable of performing queries.

type QueryServiceBridge

type QueryServiceBridge struct {
	AsyncQueryService AsyncQueryService
}

QueryServiceBridge implements the QueryService interface while consuming the AsyncQueryService interface.

func (QueryServiceBridge) Check

Check returns the status of this query service. Since this bridge consumes an AsyncQueryService, which is not available over the network, this check always passes.

func (QueryServiceBridge) Query

type QueryServiceProxyBridge

type QueryServiceProxyBridge struct {
	ProxyQueryService ProxyQueryService
}

QueryServiceProxyBridge implements QueryService while consuming a ProxyQueryService interface.

func (QueryServiceProxyBridge) Check

func (QueryServiceProxyBridge) Query

type REPLQuerier

type REPLQuerier struct {
	// Authorization is the authorization to provide for all requests
	Authorization *platform.Authorization
	// OrganizationID is the ID to provide for all requests
	OrganizationID platform2.ID
	QueryService   QueryService
}

REPLQuerier implements the repl.Querier interface while consuming a QueryService

func (*REPLQuerier) Query

func (q *REPLQuerier) Query(ctx context.Context, deps flux.Dependencies, compiler flux.Compiler) (flux.ResultIterator, error)

Query will pack a query to be sent to a remote server for execution. deps may be safely ignored since they will be correctly initialized on the server side.

type ReadFilterSpec

type ReadFilterSpec struct {
	OrganizationID platform.ID
	BucketID       platform.ID

	Bounds    execute.Bounds
	Predicate *datatypes.Predicate
}

type ReadGroupSpec

type ReadGroupSpec struct {
	ReadFilterSpec

	GroupMode GroupMode
	GroupKeys []string

	AggregateMethod string
}

func (*ReadGroupSpec) Name

func (spec *ReadGroupSpec) Name() string

type ReadSeriesCardinalitySpec added in v2.0.9

type ReadSeriesCardinalitySpec struct {
	ReadFilterSpec
}

type ReadTagKeysSpec

type ReadTagKeysSpec struct {
	ReadFilterSpec
}

type ReadTagValuesSpec

type ReadTagValuesSpec struct {
	ReadFilterSpec
	TagKey string
}

type ReadWindowAggregateSpec

type ReadWindowAggregateSpec struct {
	ReadFilterSpec
	WindowEvery int64
	Offset      int64
	Aggregates  []plan.ProcedureKind
	CreateEmpty bool
	TimeColumn  string
	Window      execute.Window

	// ForceAggregate forces all aggregates to be treated as aggregates.
	// This forces selectors, which normally don't return values for empty
	// windows, to return a null value.
	ForceAggregate bool
}

ReadWindowAggregateSpec defines the options for WindowAggregate.

Window and the WindowEvery/Offset should be mutually exclusive. If you set either the WindowEvery or Offset with nanosecond values, then the Window will be ignored.

func (*ReadWindowAggregateSpec) Name

func (spec *ReadWindowAggregateSpec) Name() string

type Request

type Request struct {
	// Scope
	Authorization  *platform.Authorization `json:"authorization,omitempty"`
	OrganizationID platform2.ID            `json:"organization_id"`

	// Compiler converts the query to a specification to run against the data.
	Compiler flux.Compiler `json:"compiler"`

	// Source represents the ultimate source of the request.
	Source string `json:"source"`
	// contains filtered or unexported fields
}

Request represents the query to run. Options to mutate the header associated to this Request can be specified via `WithOption` or associated methods. One should always `Request.ApplyOptions()` before encoding and sending the request.

func RequestFromContext

func RequestFromContext(ctx context.Context) *Request

RequestFromContext retrieves a *Request from a context. If not request exists on the context nil is returned.

func (*Request) ApplyOptions

func (r *Request) ApplyOptions(header http.Header) error

ApplyOptions applies every option added to this Request to the given header.

func (Request) MarshalJSON

func (r Request) MarshalJSON() ([]byte, error)

func (*Request) UnmarshalJSON

func (r *Request) UnmarshalJSON(data []byte) error

UnmarshalJSON populates the request from the JSON data. WithCompilerMappings must have been called or an error will occur.

func (*Request) WithCompilerMappings

func (r *Request) WithCompilerMappings(mappings flux.CompilerMappings)

WithCompilerMappings sets the query type mappings on the request.

func (*Request) WithOption

func (r *Request) WithOption(option RequestHeaderOption)

WithOption adds a RequestHeaderOption to this Request.

func (*Request) WithReturnNoContent

func (r *Request) WithReturnNoContent(withError bool)

WithReturnNoContent makes this Request return no content.

type RequestHeaderOption

type RequestHeaderOption = func(header http.Header) error

RequestHeaderOption is a function that mutates the header associated to a Request.

type SecretLookup

type SecretLookup struct {
	SecretService influxdb.SecretService
}

SecretLookup wraps the influxdb.SecretService to perform lookups based on the organization in the context.

func FromSecretService

func FromSecretService(srv influxdb.SecretService) *SecretLookup

FromSecretService wraps a influxdb.OrganizationService in the OrganizationLookup interface.

func (*SecretLookup) LoadSecret

func (s *SecretLookup) LoadSecret(ctx context.Context, key string) (string, error)

LoadSecret loads the secret associated with the key in the current organization context.

type StorageReader

type StorageReader interface {
	ReadFilter(ctx context.Context, spec ReadFilterSpec, alloc memory.Allocator) (TableIterator, error)
	ReadGroup(ctx context.Context, spec ReadGroupSpec, alloc memory.Allocator) (TableIterator, error)
	ReadWindowAggregate(ctx context.Context, spec ReadWindowAggregateSpec, alloc memory.Allocator) (TableIterator, error)

	ReadTagKeys(ctx context.Context, spec ReadTagKeysSpec, alloc memory.Allocator) (TableIterator, error)
	ReadTagValues(ctx context.Context, spec ReadTagValuesSpec, alloc memory.Allocator) (TableIterator, error)

	ReadSeriesCardinality(ctx context.Context, spec ReadSeriesCardinalitySpec, alloc memory.Allocator) (TableIterator, error)
	SupportReadSeriesCardinality(ctx context.Context) bool

	Close()
}

StorageReader is an interface for reading tables from the storage subsystem.

type StringIterator

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

StringIterator represents a stream of string points.

type StringPoint

type StringPoint struct {
	Name string
	Tags Tags

	Time  int64
	Value string
	Aux   []interface{}

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

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

type TableIterator

type TableIterator interface {
	flux.TableIterator
	Statistics() cursors.CursorStats
}

TableIterator is a table iterator that also keeps track of cursor statistics from the storage engine.

type TagSet

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

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

func (*TagSet) AddFilter

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

AddFilter adds a series-level filter to the Tagset.

func (*TagSet) Len

func (t *TagSet) Len() int

func (*TagSet) Less

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

func (*TagSet) Reverse

func (t *TagSet) Reverse()

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

func (*TagSet) Swap

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

type Tags

type Tags struct{}

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

type UnsignedIterator

type UnsignedIterator interface {
	Iterator
	Next() (*UnsignedPoint, error)
}

UnsignedIterator represents a stream of unsigned points.

type UnsignedPoint

type UnsignedPoint struct {
	Name string
	Tags Tags

	Time  int64
	Value uint64
	Aux   []interface{}

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

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

Directories

Path Synopsis
Package control keeps track of resources and manages queries.
Package control keeps track of resources and manages queries.
Package language exposes the flux parser as an interface.
Package language exposes the flux parser as an interface.

Jump to

Keyboard shortcuts

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