github.com/m3db/m3@v1.5.1-0.20231129193456-75a402aa583b/src/query/functions/fetch.go (about) 1 // Copyright (c) 2018 Uber Technologies, Inc. 2 // 3 // Permission is hereby granted, free of charge, to any person obtaining a copy 4 // of this software and associated documentation files (the "Software"), to deal 5 // in the Software without restriction, including without limitation the rights 6 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 7 // copies of the Software, and to permit persons to whom the Software is 8 // furnished to do so, subject to the following conditions: 9 // 10 // The above copyright notice and this permission notice shall be included in 11 // all copies or substantial portions of the Software. 12 // 13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 14 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 15 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 16 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 17 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 18 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 19 // THE SOFTWARE. 20 21 package functions 22 23 import ( 24 "fmt" 25 "time" 26 27 "github.com/m3db/m3/src/query/block" 28 "github.com/m3db/m3/src/query/executor/transform" 29 "github.com/m3db/m3/src/query/models" 30 "github.com/m3db/m3/src/query/parser" 31 "github.com/m3db/m3/src/query/storage" 32 "github.com/m3db/m3/src/query/util/logging" 33 "github.com/m3db/m3/src/x/instrument" 34 "github.com/m3db/m3/src/x/opentracing" 35 36 "go.uber.org/zap" 37 ) 38 39 // FetchType gets the series from storage 40 const FetchType = "fetch" 41 42 // FetchOp stores required properties for fetch 43 // TODO: Make FetchOp private 44 type FetchOp struct { 45 Name string 46 Range time.Duration 47 Offset time.Duration 48 Matchers models.Matchers 49 } 50 51 // FetchNode is a fetch execution node. 52 // TODO: Make FetchNode private 53 type FetchNode struct { 54 debug bool 55 blockType models.FetchedBlockType 56 op FetchOp 57 controller *transform.Controller 58 storage storage.Storage 59 timespec transform.TimeSpec 60 fetchOpts *storage.FetchOptions 61 instrumentOpts instrument.Options 62 } 63 64 // OpType for the operator. 65 func (o FetchOp) OpType() string { 66 return FetchType 67 } 68 69 // Bounds returns the bounds for this operation. 70 func (o FetchOp) Bounds() transform.BoundSpec { 71 return transform.BoundSpec{ 72 Range: o.Range, 73 Offset: o.Offset, 74 } 75 } 76 77 // String is the string representation for this operation. 78 func (o FetchOp) String() string { 79 return fmt.Sprintf("type: %s. name: %s, range: %v, offset: %v, matchers: %v", 80 o.OpType(), o.Name, o.Range, o.Offset, o.Matchers) 81 } 82 83 // Node creates the fetch execution node for this operation. 84 func (o FetchOp) Node( 85 controller *transform.Controller, 86 storage storage.Storage, 87 options transform.Options, 88 ) parser.Source { 89 return &FetchNode{ 90 op: o, 91 controller: controller, 92 storage: storage, 93 fetchOpts: options.FetchOptions(), 94 timespec: options.TimeSpec(), 95 debug: options.Debug(), 96 blockType: options.BlockType(), 97 instrumentOpts: options.InstrumentOptions(), 98 } 99 } 100 101 func (n *FetchNode) fetch(queryCtx *models.QueryContext) (block.Result, error) { 102 ctx := queryCtx.Ctx 103 sp, ctx := opentracing.StartSpanFromContext(ctx, "fetch") 104 defer sp.Finish() 105 106 timeSpec := n.timespec 107 // No need to adjust start and ends since physical plan 108 // already considers the offset, range 109 startTime := timeSpec.Start 110 endTime := timeSpec.End 111 112 opts, err := n.fetchOpts.QueryFetchOptions(queryCtx, n.blockType) 113 if err != nil { 114 return block.Result{}, err 115 } 116 117 offset := n.op.Offset 118 return n.storage.FetchBlocks(ctx, &storage.FetchQuery{ 119 Start: startTime.Add(-1 * offset).ToTime(), 120 End: endTime.Add(-1 * offset).ToTime(), 121 TagMatchers: n.op.Matchers, 122 Interval: timeSpec.Step, 123 }, opts) 124 } 125 126 // Execute runs the fetch node operation 127 func (n *FetchNode) Execute(queryCtx *models.QueryContext) error { 128 ctx := queryCtx.Ctx 129 blockResult, err := n.fetch(queryCtx) 130 if err != nil { 131 return err 132 } 133 134 for _, block := range blockResult.Blocks { 135 if n.debug { 136 // Ignore any errors 137 iter, _ := block.StepIter() 138 if iter != nil { 139 logging.WithContext(ctx, n.instrumentOpts). 140 Info("fetch node", zap.Any("meta", block.Meta())) 141 } 142 } 143 144 if err := n.controller.Process(queryCtx, block); err != nil { 145 block.Close() 146 // Fail on first error 147 return err 148 } 149 150 // TODO: Revisit how and when we close blocks. At the each function step 151 // defers Close(), which means that we have half blocks hanging around for 152 // a long time. Ideally we should be able to transform blocks in place. 153 // 154 // NB: Until block closing is implemented correctly, this handles closing 155 // encoded iterators when there are additional processing steps, as these 156 // steps will not properly close the block. If there are no additional steps 157 // beyond the fetch, the read handler will close blocks. 158 if n.controller.HasMultipleOperations() { 159 block.Close() 160 } 161 } 162 163 return nil 164 }