From bcc48585140338ce08771e3d78f1214e547b4392 Mon Sep 17 00:00:00 2001 From: Feng Liyuan Date: Wed, 16 Oct 2019 21:22:49 +0800 Subject: [PATCH] executor: revert mostly changes in #11678 (#12481) --- executor/aggfuncs/builder.go | 2 +- executor/aggfuncs/func_cume_dist.go | 20 +-- executor/aggfuncs/func_lead_lag.go | 188 +++++-------------------- executor/aggfuncs/func_percent_rank.go | 22 ++- executor/aggfuncs/func_rank.go | 63 +++------ executor/aggfuncs/func_value.go | 54 ++++--- executor/aggfuncs/window_func_test.go | 18 --- types/mydecimal.go | 15 -- types/mydecimal_test.go | 28 ---- 9 files changed, 106 insertions(+), 304 deletions(-) diff --git a/executor/aggfuncs/builder.go b/executor/aggfuncs/builder.go index f89b549e1b214..02e1570b4263d 100644 --- a/executor/aggfuncs/builder.go +++ b/executor/aggfuncs/builder.go @@ -424,7 +424,7 @@ func buildLeadLag(aggFuncDesc *aggregation.AggFuncDesc, ordinal int) baseLeadLag args: aggFuncDesc.Args, ordinal: ordinal, } - return baseLeadLag{baseAggFunc: base, offset: offset, defaultExpr: defaultExpr, retTp: aggFuncDesc.RetTp} + return baseLeadLag{baseAggFunc: base, offset: offset, defaultExpr: defaultExpr, valueEvaluator: buildValueEvaluator(aggFuncDesc.RetTp)} } func buildLead(aggFuncDesc *aggregation.AggFuncDesc, ordinal int) AggFunc { diff --git a/executor/aggfuncs/func_cume_dist.go b/executor/aggfuncs/func_cume_dist.go index 9637f11cdc76e..f486c16908812 100644 --- a/executor/aggfuncs/func_cume_dist.go +++ b/executor/aggfuncs/func_cume_dist.go @@ -24,8 +24,9 @@ type cumeDist struct { } type partialResult4CumeDist struct { - partialResult4Rank - cum int64 + curIdx int + lastRank int + rows []chunk.Row } func (r *cumeDist) AllocPartialResult() PartialResult { @@ -34,23 +35,24 @@ func (r *cumeDist) AllocPartialResult() PartialResult { func (r *cumeDist) ResetPartialResult(pr PartialResult) { p := (*partialResult4CumeDist)(pr) - p.partialResult4Rank.reset() - p.cum = 0 + p.curIdx = 0 + p.lastRank = 0 + p.rows = p.rows[:0] } func (r *cumeDist) UpdatePartialResult(sctx sessionctx.Context, rowsInGroup []chunk.Row, pr PartialResult) error { p := (*partialResult4CumeDist)(pr) - p.partialResult4Rank.updatePartialResult(rowsInGroup, false, r.compareRows) + p.rows = append(p.rows, rowsInGroup...) return nil } func (r *cumeDist) AppendFinalResult2Chunk(sctx sessionctx.Context, pr PartialResult, chk *chunk.Chunk) error { p := (*partialResult4CumeDist)(pr) - numRows := int64(len(p.results)) - for p.cum < numRows && p.results[p.cum] == p.results[p.curIdx] { - p.cum++ + numRows := len(p.rows) + for p.lastRank < numRows && r.compareRows(p.rows[p.curIdx], p.rows[p.lastRank]) == 0 { + p.lastRank++ } p.curIdx++ - chk.AppendFloat64(r.ordinal, float64(p.cum)/float64(numRows)) + chk.AppendFloat64(r.ordinal, float64(p.lastRank)/float64(numRows)) return nil } diff --git a/executor/aggfuncs/func_lead_lag.go b/executor/aggfuncs/func_lead_lag.go index 35150de8871fe..ba53e9eb47809 100644 --- a/executor/aggfuncs/func_lead_lag.go +++ b/executor/aggfuncs/func_lead_lag.go @@ -14,200 +14,76 @@ package aggfuncs import ( - "github.com/cznic/mathutil" "github.com/pingcap/tidb/expression" "github.com/pingcap/tidb/sessionctx" - "github.com/pingcap/tidb/types" "github.com/pingcap/tidb/util/chunk" ) type baseLeadLag struct { baseAggFunc + valueEvaluator // TODO: move it to partial result when parallel execution is supported. defaultExpr expression.Expression offset uint64 - retTp *types.FieldType } -type circleBuf struct { - buf []valueExtractor - head, tail int - size int +type partialResult4LeadLag struct { + rows []chunk.Row + curIdx uint64 } -func (cb *circleBuf) reset() { - cb.buf = cb.buf[:0] - cb.head, cb.tail = 0, 0 +func (v *baseLeadLag) AllocPartialResult() PartialResult { + return PartialResult(&partialResult4LeadLag{}) } -func (cb *circleBuf) append(e valueExtractor) { - if len(cb.buf) < cb.size { - cb.buf = append(cb.buf, e) - cb.tail++ - } else { - if cb.tail >= cb.size { - cb.tail = 0 - } - cb.buf[cb.tail] = e - cb.tail++ - } -} - -func (cb *circleBuf) get() (e valueExtractor) { - if len(cb.buf) < cb.size { - e = cb.buf[cb.head] - cb.head++ - } else { - if cb.tail >= cb.size { - cb.tail = 0 - } - e = cb.buf[cb.tail] - cb.tail++ - } - return e +func (v *baseLeadLag) ResetPartialResult(pr PartialResult) { + p := (*partialResult4LeadLag)(pr) + p.rows = p.rows[:0] + p.curIdx = 0 } -type partialResult4Lead struct { - seenRows uint64 - curIdx int - extractors []valueExtractor - defaultExtractors circleBuf - defaultConstExtractor valueExtractor +func (v *baseLeadLag) UpdatePartialResult(sctx sessionctx.Context, rowsInGroup []chunk.Row, pr PartialResult) error { + p := (*partialResult4LeadLag)(pr) + p.rows = append(p.rows, rowsInGroup...) + return nil } -const maxDefaultExtractorBufferSize = 1000 - type lead struct { baseLeadLag } -func (v *lead) AllocPartialResult() PartialResult { - return PartialResult(&partialResult4Lead{ - defaultExtractors: circleBuf{ - // Do not use v.offset directly since v.offset is defined by user - // and may larger than a table size. - buf: make([]valueExtractor, 0, mathutil.MinUint64(v.offset, maxDefaultExtractorBufferSize)), - size: int(v.offset), - }, - }) -} - -func (v *lead) ResetPartialResult(pr PartialResult) { - p := (*partialResult4Lead)(pr) - p.seenRows = 0 - p.curIdx = 0 - p.extractors = p.extractors[:0] - p.defaultExtractors.reset() - p.defaultConstExtractor = nil -} - -func (v *lead) UpdatePartialResult(sctx sessionctx.Context, rowsInGroup []chunk.Row, pr PartialResult) (err error) { - p := (*partialResult4Lead)(pr) - for _, row := range rowsInGroup { - p.seenRows++ - if p.seenRows > v.offset { - e := buildValueExtractor(v.retTp) - err = e.extractRow(sctx, v.args[0], row) - if err != nil { - return err - } - p.extractors = append(p.extractors, e) - } - if v.offset > 0 { - if !v.defaultExpr.ConstItem() { - // We must cache the results of last v.offset lines. - e := buildValueExtractor(v.retTp) - err = e.extractRow(sctx, v.defaultExpr, row) - if err != nil { - return err - } - p.defaultExtractors.append(e) - } else if p.defaultConstExtractor == nil { - e := buildValueExtractor(v.retTp) - err = e.extractRow(sctx, v.defaultExpr, chunk.Row{}) - if err != nil { - return err - } - p.defaultConstExtractor = e - } - } - } - return nil -} - func (v *lead) AppendFinalResult2Chunk(sctx sessionctx.Context, pr PartialResult, chk *chunk.Chunk) error { - p := (*partialResult4Lead)(pr) - var e valueExtractor - if p.curIdx < len(p.extractors) { - e = p.extractors[p.curIdx] + p := (*partialResult4LeadLag)(pr) + var err error + if p.curIdx+v.offset < uint64(len(p.rows)) { + err = v.evaluateRow(sctx, v.args[0], p.rows[p.curIdx+v.offset]) } else { - if !v.defaultExpr.ConstItem() { - e = p.defaultExtractors.get() - } else { - e = p.defaultConstExtractor - } + err = v.evaluateRow(sctx, v.defaultExpr, p.rows[p.curIdx]) } - e.appendResult(chk, v.ordinal) + if err != nil { + return err + } + v.appendResult(chk, v.ordinal) p.curIdx++ return nil } -type partialResult4Lag struct { - seenRows uint64 - curIdx uint64 - extractors []valueExtractor - defaultExtractors []valueExtractor -} - type lag struct { baseLeadLag } -func (v *lag) AllocPartialResult() PartialResult { - return PartialResult(&partialResult4Lag{ - defaultExtractors: make([]valueExtractor, 0, mathutil.MinUint64(v.offset, maxDefaultExtractorBufferSize)), - }) -} - -func (v *lag) ResetPartialResult(pr PartialResult) { - p := (*partialResult4Lag)(pr) - p.seenRows = 0 - p.curIdx = 0 - p.extractors = p.extractors[:0] - p.defaultExtractors = p.defaultExtractors[:0] -} - -func (v *lag) UpdatePartialResult(sctx sessionctx.Context, rowsInGroup []chunk.Row, pr PartialResult) (err error) { - p := (*partialResult4Lag)(pr) - for _, row := range rowsInGroup { - p.seenRows++ - if p.seenRows <= v.offset { - e := buildValueExtractor(v.retTp) - err = e.extractRow(sctx, v.defaultExpr, row) - if err != nil { - return err - } - p.defaultExtractors = append(p.defaultExtractors, e) - } - e := buildValueExtractor(v.retTp) - err = e.extractRow(sctx, v.args[0], row) - if err != nil { - return err - } - p.extractors = append(p.extractors, e) - } - return nil -} - func (v *lag) AppendFinalResult2Chunk(sctx sessionctx.Context, pr PartialResult, chk *chunk.Chunk) error { - p := (*partialResult4Lag)(pr) - var e valueExtractor - if p.curIdx < v.offset { - e = p.defaultExtractors[p.curIdx] + p := (*partialResult4LeadLag)(pr) + var err error + if p.curIdx >= v.offset { + err = v.evaluateRow(sctx, v.args[0], p.rows[p.curIdx-v.offset]) } else { - e = p.extractors[p.curIdx-v.offset] + err = v.evaluateRow(sctx, v.defaultExpr, p.rows[p.curIdx]) + } + if err != nil { + return err } - e.appendResult(chk, v.ordinal) + v.appendResult(chk, v.ordinal) p.curIdx++ return nil } diff --git a/executor/aggfuncs/func_percent_rank.go b/executor/aggfuncs/func_percent_rank.go index 86be2a4a0579a..0ea863a048bb6 100644 --- a/executor/aggfuncs/func_percent_rank.go +++ b/executor/aggfuncs/func_percent_rank.go @@ -31,23 +31,31 @@ func (pr *percentRank) AllocPartialResult() PartialResult { func (pr *percentRank) ResetPartialResult(partial PartialResult) { p := (*partialResult4Rank)(partial) - p.reset() + p.curIdx = 0 + p.lastRank = 0 + p.rows = p.rows[:0] } func (pr *percentRank) UpdatePartialResult(sctx sessionctx.Context, rowsInGroup []chunk.Row, partial PartialResult) error { p := (*partialResult4Rank)(partial) - p.updatePartialResult(rowsInGroup, false, pr.compareRows) + p.rows = append(p.rows, rowsInGroup...) return nil } func (pr *percentRank) AppendFinalResult2Chunk(sctx sessionctx.Context, partial PartialResult, chk *chunk.Chunk) error { p := (*partialResult4Rank)(partial) - numRows := len(p.results) - if numRows == 1 { + numRows := int64(len(p.rows)) + p.curIdx++ + if p.curIdx == 1 { + p.lastRank = 1 chk.AppendFloat64(pr.ordinal, 0) - } else { - chk.AppendFloat64(pr.ordinal, float64(p.results[p.curIdx]-1)/float64(numRows-1)) + return nil } - p.curIdx++ + if pr.compareRows(p.rows[p.curIdx-2], p.rows[p.curIdx-1]) == 0 { + chk.AppendFloat64(pr.ordinal, float64(p.lastRank-1)/float64(numRows-1)) + return nil + } + p.lastRank = p.curIdx + chk.AppendFloat64(pr.ordinal, float64(p.lastRank-1)/float64(numRows-1)) return nil } diff --git a/executor/aggfuncs/func_rank.go b/executor/aggfuncs/func_rank.go index a70bdaf14a0eb..02267cd2146a6 100644 --- a/executor/aggfuncs/func_rank.go +++ b/executor/aggfuncs/func_rank.go @@ -27,45 +27,8 @@ type rank struct { type partialResult4Rank struct { curIdx int64 - seenRows int64 - results []int64 - lastRow chunk.Row -} - -func (p *partialResult4Rank) reset() { - p.curIdx = 0 - p.seenRows = 0 - p.results = p.results[:0] -} - -func (p *partialResult4Rank) updatePartialResult( - rowsInGroup []chunk.Row, - isDense bool, - compareRows func(prev, curr chunk.Row) int, -) { - if len(rowsInGroup) == 0 { - return - } - lastRow := p.lastRow - for _, row := range rowsInGroup { - p.seenRows++ - if p.seenRows == 1 { - p.results = append(p.results, 1) - lastRow = row - continue - } - var rank int64 - if compareRows(lastRow, row) == 0 { - rank = p.results[len(p.results)-1] - } else if isDense { - rank = p.results[len(p.results)-1] + 1 - } else { - rank = p.seenRows - } - p.results = append(p.results, rank) - lastRow = row - } - p.lastRow = rowsInGroup[len(rowsInGroup)-1].CopyConstruct() + lastRank int64 + rows []chunk.Row } func (r *rank) AllocPartialResult() PartialResult { @@ -74,19 +37,35 @@ func (r *rank) AllocPartialResult() PartialResult { func (r *rank) ResetPartialResult(pr PartialResult) { p := (*partialResult4Rank)(pr) - p.reset() + p.curIdx = 0 + p.lastRank = 0 + p.rows = p.rows[:0] } func (r *rank) UpdatePartialResult(sctx sessionctx.Context, rowsInGroup []chunk.Row, pr PartialResult) error { p := (*partialResult4Rank)(pr) - p.updatePartialResult(rowsInGroup, r.isDense, r.compareRows) + p.rows = append(p.rows, rowsInGroup...) return nil } func (r *rank) AppendFinalResult2Chunk(sctx sessionctx.Context, pr PartialResult, chk *chunk.Chunk) error { p := (*partialResult4Rank)(pr) - chk.AppendInt64(r.ordinal, p.results[p.curIdx]) p.curIdx++ + if p.curIdx == 1 { + p.lastRank = 1 + chk.AppendInt64(r.ordinal, p.lastRank) + return nil + } + if r.compareRows(p.rows[p.curIdx-2], p.rows[p.curIdx-1]) == 0 { + chk.AppendInt64(r.ordinal, p.lastRank) + return nil + } + if r.isDense { + p.lastRank++ + } else { + p.lastRank = p.curIdx + } + chk.AppendInt64(r.ordinal, p.lastRank) return nil } diff --git a/executor/aggfuncs/func_value.go b/executor/aggfuncs/func_value.go index 9e8f63a1c2ab8..88c8f76e8615a 100644 --- a/executor/aggfuncs/func_value.go +++ b/executor/aggfuncs/func_value.go @@ -20,14 +20,13 @@ import ( "github.com/pingcap/tidb/types" "github.com/pingcap/tidb/types/json" "github.com/pingcap/tidb/util/chunk" - "github.com/pingcap/tidb/util/stringutil" ) -// valueExtractor is used to extract values for `first_value`, `last_value`, `nth_value`, +// valueEvaluator is used to evaluate values for `first_value`, `last_value`, `nth_value`, // `lead` and `lag`. -type valueExtractor interface { - // extractRow extracts the expression using row and stores the result inside. - extractRow(ctx sessionctx.Context, expr expression.Expression, row chunk.Row) error +type valueEvaluator interface { + // evaluateRow evaluates the expression using row and stores the result inside. + evaluateRow(ctx sessionctx.Context, expr expression.Expression, row chunk.Row) error // appendResult appends the result to chunk. appendResult(chk *chunk.Chunk, colIdx int) } @@ -37,7 +36,7 @@ type value4Int struct { isNull bool } -func (v *value4Int) extractRow(ctx sessionctx.Context, expr expression.Expression, row chunk.Row) error { +func (v *value4Int) evaluateRow(ctx sessionctx.Context, expr expression.Expression, row chunk.Row) error { var err error v.val, v.isNull, err = expr.EvalInt(ctx, row) return err @@ -56,7 +55,7 @@ type value4Float32 struct { isNull bool } -func (v *value4Float32) extractRow(ctx sessionctx.Context, expr expression.Expression, row chunk.Row) error { +func (v *value4Float32) evaluateRow(ctx sessionctx.Context, expr expression.Expression, row chunk.Row) error { var err error var val float64 val, v.isNull, err = expr.EvalReal(ctx, row) @@ -77,10 +76,9 @@ type value4Decimal struct { isNull bool } -func (v *value4Decimal) extractRow(ctx sessionctx.Context, expr expression.Expression, row chunk.Row) error { +func (v *value4Decimal) evaluateRow(ctx sessionctx.Context, expr expression.Expression, row chunk.Row) error { var err error v.val, v.isNull, err = expr.EvalDecimal(ctx, row) - v.val = v.val.Copy() return err } @@ -97,7 +95,7 @@ type value4Float64 struct { isNull bool } -func (v *value4Float64) extractRow(ctx sessionctx.Context, expr expression.Expression, row chunk.Row) error { +func (v *value4Float64) evaluateRow(ctx sessionctx.Context, expr expression.Expression, row chunk.Row) error { var err error v.val, v.isNull, err = expr.EvalReal(ctx, row) return err @@ -116,12 +114,12 @@ type value4String struct { isNull bool } -func (v *value4String) extractRow(ctx sessionctx.Context, expr expression.Expression, row chunk.Row) error { +func (v *value4String) evaluateRow(ctx sessionctx.Context, expr expression.Expression, row chunk.Row) error { var err error v.val, v.isNull, err = expr.EvalString(ctx, row) - v.val = stringutil.Copy(v.val) return err } + func (v *value4String) appendResult(chk *chunk.Chunk, colIdx int) { if v.isNull { chk.AppendNull(colIdx) @@ -135,7 +133,7 @@ type value4Time struct { isNull bool } -func (v *value4Time) extractRow(ctx sessionctx.Context, expr expression.Expression, row chunk.Row) error { +func (v *value4Time) evaluateRow(ctx sessionctx.Context, expr expression.Expression, row chunk.Row) error { var err error v.val, v.isNull, err = expr.EvalTime(ctx, row) return err @@ -154,7 +152,7 @@ type value4Duration struct { isNull bool } -func (v *value4Duration) extractRow(ctx sessionctx.Context, expr expression.Expression, row chunk.Row) error { +func (v *value4Duration) evaluateRow(ctx sessionctx.Context, expr expression.Expression, row chunk.Row) error { var err error v.val, v.isNull, err = expr.EvalDuration(ctx, row) return err @@ -173,7 +171,7 @@ type value4JSON struct { isNull bool } -func (v *value4JSON) extractRow(ctx sessionctx.Context, expr expression.Expression, row chunk.Row) error { +func (v *value4JSON) evaluateRow(ctx sessionctx.Context, expr expression.Expression, row chunk.Row) error { var err error v.val, v.isNull, err = expr.EvalJSON(ctx, row) v.val = v.val.Copy() // deep copy to avoid content change. @@ -188,7 +186,7 @@ func (v *value4JSON) appendResult(chk *chunk.Chunk, colIdx int) { } } -func buildValueExtractor(tp *types.FieldType) valueExtractor { +func buildValueEvaluator(tp *types.FieldType) valueEvaluator { evalType := tp.EvalType() if tp.Tp == mysql.TypeBit { evalType = types.ETString @@ -225,11 +223,11 @@ type firstValue struct { type partialResult4FirstValue struct { gotFirstValue bool - extractor valueExtractor + evaluator valueEvaluator } func (v *firstValue) AllocPartialResult() PartialResult { - return PartialResult(&partialResult4FirstValue{extractor: buildValueExtractor(v.tp)}) + return PartialResult(&partialResult4FirstValue{evaluator: buildValueEvaluator(v.tp)}) } func (v *firstValue) ResetPartialResult(pr PartialResult) { @@ -244,7 +242,7 @@ func (v *firstValue) UpdatePartialResult(sctx sessionctx.Context, rowsInGroup [] } if len(rowsInGroup) > 0 { p.gotFirstValue = true - err := p.extractor.extractRow(sctx, v.args[0], rowsInGroup[0]) + err := p.evaluator.evaluateRow(sctx, v.args[0], rowsInGroup[0]) if err != nil { return err } @@ -257,7 +255,7 @@ func (v *firstValue) AppendFinalResult2Chunk(sctx sessionctx.Context, pr Partial if !p.gotFirstValue { chk.AppendNull(v.ordinal) } else { - p.extractor.appendResult(chk, v.ordinal) + p.evaluator.appendResult(chk, v.ordinal) } return nil } @@ -270,11 +268,11 @@ type lastValue struct { type partialResult4LastValue struct { gotLastValue bool - extractor valueExtractor + evaluator valueEvaluator } func (v *lastValue) AllocPartialResult() PartialResult { - return PartialResult(&partialResult4LastValue{extractor: buildValueExtractor(v.tp)}) + return PartialResult(&partialResult4LastValue{evaluator: buildValueEvaluator(v.tp)}) } func (v *lastValue) ResetPartialResult(pr PartialResult) { @@ -286,7 +284,7 @@ func (v *lastValue) UpdatePartialResult(sctx sessionctx.Context, rowsInGroup []c p := (*partialResult4LastValue)(pr) if len(rowsInGroup) > 0 { p.gotLastValue = true - err := p.extractor.extractRow(sctx, v.args[0], rowsInGroup[len(rowsInGroup)-1]) + err := p.evaluator.evaluateRow(sctx, v.args[0], rowsInGroup[len(rowsInGroup)-1]) if err != nil { return err } @@ -299,7 +297,7 @@ func (v *lastValue) AppendFinalResult2Chunk(sctx sessionctx.Context, pr PartialR if !p.gotLastValue { chk.AppendNull(v.ordinal) } else { - p.extractor.appendResult(chk, v.ordinal) + p.evaluator.appendResult(chk, v.ordinal) } return nil } @@ -313,11 +311,11 @@ type nthValue struct { type partialResult4NthValue struct { seenRows uint64 - extractor valueExtractor + evaluator valueEvaluator } func (v *nthValue) AllocPartialResult() PartialResult { - return PartialResult(&partialResult4NthValue{extractor: buildValueExtractor(v.tp)}) + return PartialResult(&partialResult4NthValue{evaluator: buildValueEvaluator(v.tp)}) } func (v *nthValue) ResetPartialResult(pr PartialResult) { @@ -332,7 +330,7 @@ func (v *nthValue) UpdatePartialResult(sctx sessionctx.Context, rowsInGroup []ch p := (*partialResult4NthValue)(pr) numRows := uint64(len(rowsInGroup)) if v.nth > p.seenRows && v.nth-p.seenRows <= numRows { - err := p.extractor.extractRow(sctx, v.args[0], rowsInGroup[v.nth-p.seenRows-1]) + err := p.evaluator.evaluateRow(sctx, v.args[0], rowsInGroup[v.nth-p.seenRows-1]) if err != nil { return err } @@ -346,7 +344,7 @@ func (v *nthValue) AppendFinalResult2Chunk(sctx sessionctx.Context, pr PartialRe if v.nth == 0 || p.seenRows < v.nth { chk.AppendNull(v.ordinal) } else { - p.extractor.appendResult(chk, v.ordinal) + p.evaluator.appendResult(chk, v.ordinal) } return nil } diff --git a/executor/aggfuncs/window_func_test.go b/executor/aggfuncs/window_func_test.go index ae150668c3983..f6d879596e264 100644 --- a/executor/aggfuncs/window_func_test.go +++ b/executor/aggfuncs/window_func_test.go @@ -14,7 +14,6 @@ package aggfuncs_test import ( - "math/rand" "time" . "github.com/pingcap/check" @@ -38,12 +37,6 @@ type windowTest struct { } func (s *testSuite) testWindowFunc(c *C, p windowTest) { - s._testWindowFunc(c, p, false) - s._testWindowFunc(c, p, true) -} - -func (s *testSuite) _testWindowFunc(c *C, p windowTest, pollute bool) { - srcChk := chunk.NewChunkWithCapacity([]*types.FieldType{p.dataType}, p.numRows) dataGen := getDataGenFunc(p.dataType) for i := 0; i < p.numRows; i++ { @@ -62,17 +55,6 @@ func (s *testSuite) _testWindowFunc(c *C, p windowTest, pollute bool) { err = finalFunc.UpdatePartialResult(s.ctx, []chunk.Row{row}, finalPr) c.Assert(err, IsNil) } - // Reset or pollute srcChk on purpose to make sure any AggFunc does - // not hold any memory referenced by srcChk after UpdatePartialResult. - // See issue #11614 and #11626 - srcChk.Reset() - if pollute { - rand.Seed(time.Now().Unix()) - for i := 0; i < p.numRows; i++ { - dt := dataGen(rand.Int()) - srcChk.AppendDatum(0, &dt) - } - } c.Assert(p.numRows, Equals, len(p.results)) for i := 0; i < p.numRows; i++ { diff --git a/types/mydecimal.go b/types/mydecimal.go index 5bc3a977354b8..70a5c651bacc8 100644 --- a/types/mydecimal.go +++ b/types/mydecimal.go @@ -250,21 +250,6 @@ func (d *MyDecimal) GetDigitsFrac() int8 { return d.digitsFrac } -// Copy copies a new *MyDecimal from itself. -func (d *MyDecimal) Copy() *MyDecimal { - if d == nil { - return nil - } - dst := &MyDecimal{ - digitsInt: d.digitsInt, - digitsFrac: d.digitsFrac, - resultFrac: d.resultFrac, - negative: d.negative, - } - copy(dst.wordBuf[:], d.wordBuf[:]) - return dst -} - // String returns the decimal string representation rounded to resultFrac. func (d *MyDecimal) String() string { tmp := *d diff --git a/types/mydecimal_test.go b/types/mydecimal_test.go index bfc633be541ac..60604b1817f5e 100644 --- a/types/mydecimal_test.go +++ b/types/mydecimal_test.go @@ -14,7 +14,6 @@ package types import ( - "reflect" "strings" "testing" @@ -541,33 +540,6 @@ func (s *testMyDecimalSuite) TestToString(c *C) { } } -func (s *testMyDecimalSuite) TestCopy(c *C) { - type tcase struct { - input string - } - tests := []tcase{ - {".0"}, - {".123"}, - {"123.123"}, - {"123."}, - {"123"}, - {"123.1230"}, - {"-123.1230"}, - {"00123.123"}, - } - for _, ca := range tests { - var dec MyDecimal - err := dec.FromString([]byte(ca.input)) - c.Assert(err, IsNil) - - dec2 := dec.Copy() - c.Assert(reflect.DeepEqual(dec, *dec2), IsTrue) - } - - var dec *MyDecimal - c.Assert(dec.Copy(), IsNil) -} - func (s *testMyDecimalSuite) TestToBinFromBin(c *C) { type tcase struct { input string