plan: calc `access path` when doing `deriveStats`. #6346

winoros · 2018-04-23T11:37:01Z

collect thing as a struct.
reduce redundant calculation.
don't rely on statsInfo.

winoros · 2018-04-23T11:40:07Z

simple benchmark result
previous:

BenchmarkOptimize/select_count(*)_from_t_group_by_e-8         	   30000	     47771 ns/op	   38058 B/op	     500 allocs/op
BenchmarkOptimize/select_count(*)_from_t_where_e_<=_10_group_by_e-8         	   20000	    106329 ns/op	   51307 B/op	     730 allocs/op
BenchmarkOptimize/select_count(*)_from_t_where_e_<=_50-8                    	   20000	     73301 ns/op	   36746 B/op	     561 allocs/op
BenchmarkOptimize/select_count(*)_from_t_where_c_>_'1'_group_by_b-8         	   10000	    104546 ns/op	   55571 B/op	     811 allocs/op
BenchmarkOptimize/select_count(*)_from_t_where_e_=_1_group_by_b-8           	   10000	    103423 ns/op	   59859 B/op	     871 allocs/op
BenchmarkOptimize/select_count(*)_from_t_where_e_>_1_group_by_b-8           	   10000	    117617 ns/op	   62900 B/op	     888 allocs/op
BenchmarkOptimize/select_count(e)_from_t_where_t.b_<=_20-8                  	   10000	    101968 ns/op	   60443 B/op	     848 allocs/op
BenchmarkOptimize/select_count(e)_from_t_where_t.b_<=_30-8                  	   10000	    112738 ns/op	   60443 B/op	     848 allocs/op
BenchmarkOptimize/select_count(e)_from_t_where_t.b_<=_40-8                  	   10000	    102269 ns/op	   60443 B/op	     848 allocs/op
BenchmarkOptimize/select_count(e)_from_t_where_t.b_<=_50-8                  	   10000	    103319 ns/op	   60443 B/op	     848 allocs/op
BenchmarkOptimize/select_*_from_t_where_t.b_<=_40-8                         	   30000	     47411 ns/op	   27488 B/op	     359 allocs/op
BenchmarkOptimize/select_*_from_t_where_t.b_<=_50-8                         	   30000	     49996 ns/op	   27488 B/op	     359 allocs/op
BenchmarkOptimize/select_*_from_t_where_1_and_t.b_<=_50-8                   	   30000	     46535 ns/op	   27696 B/op	     364 allocs/op
BenchmarkOptimize/select_*_from_t_where_t.b_<=_100_order_by_t.a_limit_1-8   	   10000	    191054 ns/op	  119193 B/op	    1527 allocs/op
BenchmarkOptimize/select_*_from_t_where_t.b_<=_1_order_by_t.a_limit_10-8    	   10000	    181012 ns/op	  119192 B/op	    1527 allocs/op
BenchmarkOptimize/select_*_from_t_use_index(b)_where_b_=_1_order_by_a-8     	   30000	     39580 ns/op	   24854 B/op	     350 allocs/op
BenchmarkOptimize/select_*_from_t_where_d_<_cast('1991-09-05'_as_datetime)-8         	   30000	     42636 ns/op	   21480 B/op	     296 allocs/op
plan: calc `index path` when doing `deriveStats`.
BenchmarkOptimize/select_*_from_t_where_ts_<_'1991-09-05'-8                          	   30000	     44727 ns/op	   21384 B/op	     294 allocs/op

Now:

BenchmarkOptimize/select_count(*)_from_t_group_by_e-8         	   30000	     46541 ns/op	   39234 B/op	     495 allocs/op
BenchmarkOptimize/select_count(*)_from_t_where_e_<=_10_group_by_e-8         	   20000	     68654 ns/op	   47858 B/op	     645 allocs/op
BenchmarkOptimize/select_count(*)_from_t_where_e_<=_50-8                    	   30000	     55205 ns/op	   33458 B/op	     492 allocs/op
BenchmarkOptimize/select_count(*)_from_t_where_c_>_'1'_group_by_b-8         	   20000	     83212 ns/op	   54291 B/op	     744 allocs/op
BenchmarkOptimize/select_count(*)_from_t_where_e_=_1_group_by_b-8           	   20000	     80127 ns/op	   57179 B/op	     750 allocs/op
BenchmarkOptimize/select_count(*)_from_t_where_e_>_1_group_by_b-8           	   20000	     90272 ns/op	   58171 B/op	     755 allocs/op
BenchmarkOptimize/select_count(e)_from_t_where_t.b_<=_20-8                  	   20000	     80168 ns/op	   52451 B/op	     693 allocs/op
BenchmarkOptimize/select_count(e)_from_t_where_t.b_<=_30-8                  	   20000	     77870 ns/op	   52451 B/op	     693 allocs/op
BenchmarkOptimize/select_count(e)_from_t_where_t.b_<=_40-8                  	   20000	     79757 ns/op	   52451 B/op	     693 allocs/op
BenchmarkOptimize/select_count(e)_from_t_where_t.b_<=_50-8                  	   20000	     80678 ns/op	   52450 B/op	     693 allocs/op
BenchmarkOptimize/select_*_from_t_where_t.b_<=_40-8                         	   30000	     52173 ns/op	   30704 B/op	     447 allocs/op
BenchmarkOptimize/select_*_from_t_where_t.b_<=_50-8                         	   30000	     54103 ns/op	   30704 B/op	     447 allocs/op
BenchmarkOptimize/select_*_from_t_where_1_and_t.b_<=_50-8                   	   30000	     53793 ns/op	   30912 B/op	     452 allocs/op
BenchmarkOptimize/select_*_from_t_where_t.b_<=_100_order_by_t.a_limit_1-8   	   10000	    111318 ns/op	   98032 B/op	    1033 allocs/op
BenchmarkOptimize/select_*_from_t_where_t.b_<=_1_order_by_t.a_limit_10-8    	   10000	    115871 ns/op	   98032 B/op	    1033 allocs/op
BenchmarkOptimize/select_*_from_t_use_index(b)_where_b_=_1_order_by_a-8     	   30000	     38680 ns/op	   25318 B/op	     338 allocs/op
BenchmarkOptimize/select_*_from_t_where_d_<_cast('1991-09-05'_as_datetime)-8         	   30000	     52790 ns/op	   25760 B/op	     410 allocs/op
BenchmarkOptimize/select_*_from_t_where_ts_<_'1991-09-05'-8                          	   30000	     58391 ns/op	   25664 B/op	     408 allocs/op

If the sql have props to push down, it will reduce a lot of time.
But if there's no prop, it will cost more because all index calculation is done.
We can use a lazy calcultion to optimize this.

winoros · 2018-04-23T12:33:01Z

sysbench
select: 2% improve.
oltp: not changed too much.

winoros · 2018-04-23T12:33:17Z

PTAL @zz-jason @coocood @XuHuaiyu

winoros · 2018-04-23T12:43:36Z

/run-all-tests

coocood · 2018-04-23T13:25:32Z

plan/logical_plans.go

-type availableIndices struct {
-	indices          []*model.IndexInfo
-	includeTableScan bool
+type indexPath struct {


Please add comments for this type.

coocood · 2018-04-23T13:27:32Z

plan/logical_plans.go

-	// availableIndices is used for storing result of availableIndices function.
-	availableIndices *availableIndices
+	// possibleIndexPaths stores all the possible index path for physical plan, including table scan.
+	// Please make true table scan is always the first element.


make sure

coocood · 2018-04-23T13:29:05Z

plan/logical_plans.go

+	eqCondCount      int
+	indexFilters     []expression.Expression
+	tableFilters     []expression.Expression
+	filterUnmatched  bool


coocood · 2018-04-23T13:39:59Z

plan/logical_plans.go

+	index            *model.IndexInfo
+	ranges           []*ranger.NewRange
+	countAfterAccess float64
+	countAfterIndex  float64


Add comments about the two count.

coocood · 2018-04-23T13:47:44Z

plan/stats.go

+		path.countAfterAccess = float64(ds.statisticTable.Count)
+		path.countAfterIndex = float64(ds.statisticTable.Count)
+		var err error
+		if path.isRowID {


Can we extract a function for table path and another function for index path?

coocood · 2018-04-23T13:57:25Z

types/datum.go

@@ -122,6 +122,11 @@ func (d *Datum) IsNull() bool {
 	return d.k == KindNull
 }

+// IsMaxValue checks if datum is max value.
+func (d *Datum) IsMaxValue() bool {


shenli · 2018-04-23T17:33:40Z

/run-all-tests

coocood · 2018-04-24T11:13:32Z

plan/logical_plans.go

-	// possibleIndexPaths stores all the possible index path for physical plan, including table scan.
-	// Please make true table scan is always the first element.
-	possibleIndexPaths []*indexPath
+	// possibleAccessPaths stores all the possible index path for physical plan, including table scan.


all the possible access paths

coocood · 2018-04-24T11:18:17Z

plan/logical_plans.go

+	forced bool
+}
+
+func (ds *DataSource) prepareTablePath(path *accessPath) error {


Since it's called by deriveStats, How about renaming it to deriveTablePathStats?

coocood · 2018-04-24T11:18:26Z

plan/logical_plans.go

+	return nil
+}
+
+func (ds *DataSource) prepareIndexPath(path *accessPath) error {


zz-jason · 2018-04-23T15:58:06Z

plan/physical_plan_builder.go

@@ -308,25 +310,10 @@ func (ds *DataSource) convertToIndexScan(prop *requiredProp, idx *model.IndexInf
 		is.Hist = &statsTbl.Indices[idx.ID].Histogram
 	}
 	rowCount := float64(statsTbl.Count)


can be removed

zz-jason · 2018-04-24T11:23:25Z

plan/stats.go

 	// PushDownNot here can convert query 'not (a != 1)' to 'a = 1'.
 	for i, expr := range ds.pushedDownConds {
 		ds.pushedDownConds[i] = expression.PushDownNot(nil, expr, false)
 	}
 	ds.statsAfterSelect = ds.getStatsByFilter(ds.pushedDownConds)
-	return ds.statsAfterSelect
+	for _, path := range ds.possibleAccessPaths {
+		var err error


we can remove this line and use err := in line 135 and 141

zz-jason · 2018-04-24T11:24:50Z

plan/physical_plan_builder.go

-				t = idxTask
+			if tblTask.cost() < t.cost() {
+				t = tblTask
+			}


how about adding a continue in this code block ?

alivxxx · 2018-04-24T11:50:07Z

plan/logical_plans.go

+	} else {
+		path.ranges = ranger.FullIntNewRange(false)
+	}
+	path.countAfterAccess = float64(ds.statisticTable.Count)


Duplicated with line 333?

alivxxx · 2018-04-24T11:54:40Z

plan/logical_plans.go

+	} else {
+		path.indexFilters, path.tableFilters = splitIndexFilterConditions(ds.pushedDownConds, path.index.Columns, ds.tableInfo)
+	}
+	path.countAfterIndex = path.countAfterAccess


Duplicated with line 364?

removed one.

XuHuaiyu · 2018-04-24T12:18:22Z

plan/gen_physical_plans.go

-	includeTableScan := x.availableIndices.includeTableScan
-	if includeTableScan && len(innerJoinKeys) == 1 {
+	indexPaths := x.possibleAccessPaths
+	if len(x.possibleAccessPaths) > 0 && x.possibleAccessPaths[0].isRowID {


why not use len(indexPaths) > 0 ...

XuHuaiyu · 2018-04-25T05:54:56Z

plan/logical_plans.go

+	sc := ds.ctx.GetSessionVars().StmtCtx
+	path.countAfterAccess = float64(ds.statisticTable.Count)
+	var pkCol *expression.Column
+	if pkCol != nil {


when will pkCol != nil?

XuHuaiyu · 2018-04-25T05:56:15Z

plan/logical_plans.go

+	}
+	path.countAfterAccess = float64(ds.statisticTable.Count)
+	if len(ds.pushedDownConds) > 0 {
+		if pkCol != nil {


XuHuaiyu · 2018-04-25T06:25:35Z

plan/logical_plans.go

+	if len(ds.pushedDownConds) > 0 {
+		if pkCol != nil {
+			path.accessConds, path.tableFilters = ranger.DetachCondsForTableRange(ds.ctx, ds.pushedDownConds, pkCol)
+			path.ranges, err = ranger.BuildTableRange(path.accessConds, sc, pkCol.RetType)


We may put sc as the first parameter.

XuHuaiyu · 2018-04-25T06:41:27Z

plan/logical_plans.go

-type availableIndices struct {
-	indices          []*model.IndexInfo
-	includeTableScan bool
+func (ds *DataSource) prepareTablePath(path *accessPath) error {


Will this be more concise?

func (ds *DataSource) prepareTablePath(path *accessPath) error { var err error var pkCol *expression.Column sc := ds.ctx.GetSessionVars().StmtCtx path.countAfterAccess = float64(ds.statisticTable.Count) path.ranges = ranger.FullIntNewRange(false) path.tableFilters = ds.pushedDownConds if pkCol == nil { return nil } path.ranges = ranger.FullIntNewRange(mysql.HasUnsignedFlag(pkCol.RetType.Flag)) if len(ds.pushedDownConds) == 0 { return nil } path.accessConds, path.tableFilters = ranger.DetachCondsForTableRange(ds.ctx, ds.pushedDownConds, pkCol) path.ranges, err = ranger.BuildTableRange(path.accessConds, sc, pkCol.RetType) if err != nil { return errors.Trace(err) } path.countAfterAccess, err = ds.statisticTable.GetRowCountByIntColumnRanges(sc, pkCol.ID, path.ranges) return errors.Trace(err) }

winoros · 2018-04-25T11:48:06Z

PTAL @coocood @zz-jason @XuHuaiyu @lamxTyler

winoros · 2018-04-25T11:57:28Z

/run-all-tests

alivxxx · 2018-04-26T03:02:21Z

plan/gen_physical_plans.go

-	includeTableScan := x.availableIndices.includeTableScan
-	if includeTableScan && len(innerJoinKeys) == 1 {
+	accessPaths := x.possibleAccessPaths
+	if len(accessPaths) > 0 && x.possibleAccessPaths[0].isRowID {


Don't we need to check the length of innerJoinKeys?

iamxy · 2018-04-26T11:34:40Z

/run-all-tests

zz-jason · 2018-04-27T05:23:17Z

plan/stats.go

 	// PushDownNot here can convert query 'not (a != 1)' to 'a = 1'.
 	for i, expr := range ds.pushedDownConds {
 		ds.pushedDownConds[i] = expression.PushDownNot(nil, expr, false)
 	}
 	ds.statsAfterSelect = ds.getStatsByFilter(ds.pushedDownConds)
-	return ds.statsAfterSelect
+	for _, path := range ds.possibleAccessPaths {


how about:

if !ds. possibleAccessPaths[0].isRowID { panic("table path should always be the first access path" } err := ds.deriveTablePathStats(path) ... for _, path := range ds.possibleAccessPaths[1:] { err := ds.deriveIndexPathStats(path) ... }

No, the first element can be index path.

zz-jason · 2018-04-27T05:26:44Z

plan/property_cols_prune.go

-		cols, _ := expression.IndexInfo2Cols(ds.schema.Columns, idx)
-		if len(cols) > 0 {
-			result = append(result, cols)
+	for _, path := range ds.possibleAccessPaths {


how about:

if !ds.possibleAccessPaths[0].isRowID { panic("table path should always be the first access path") } col := ds.getPKIsHandleCol() ... for _, path := range ds.possibleAccessPaths[1:] { cols, _ := expression.IndexInfo2Cols(ds.schema.Columns, path.index) ... }

zz-jason · 2018-04-27T05:37:46Z

plan/gen_physical_plans.go

-			innerPlan := x.forceToTableScan(pkCol)
-			return p.constructIndexJoin(prop, innerJoinKeys, outerJoinKeys, outerIdx, innerPlan, nil, nil)
+	accessPaths := x.possibleAccessPaths
+	if len(accessPaths) > 0 && x.possibleAccessPaths[0].isRowID {


we can just:

if len(accessPaths) > 0 { ... }

zz-jason · 2018-04-27T05:45:04Z

plan/physical_plan_builder.go

-			if !ds.relevantIndices[i] && len(prop.cols) == 0 {
-				continue
+
+	for _, path := range ds.possibleAccessPaths {


how about:

if !ds.possibleAccessPaths[0].isRowID { panic("xxx") } tblTask, err := ds.convertToTableScan(prop, ds.possibleAccessPaths[0]) ... for _, path := range ds.possibleAccessPaths[1:] { if !(len(path.accessConds) > 0 || len(prop.cols) > 0 || path.forced) { continue } ... }

zz-jason · 2018-04-27T06:07:14Z

plan/physical_plan_builder.go

-			is.filterCondition = ds.pushedDownConds
-		}
-	}
+	is.AccessCondition, is.Ranges, is.filterCondition, eqCount = path.accessConds, path.ranges, path.indexFilters, path.eqCondCount


this line is too long, can we split it to multi-lines ?

XuHuaiyu · 2018-04-26T09:45:34Z

plan/logical_plans.go

-	if pkCol != nil {
-		path.ranges = ranger.FullIntRange(mysql.HasUnsignedFlag(pkCol.RetType.Flag))
-	} else {
+	if pkCol == nil {


We'better add some test cases to cover pkCol == nil and pkCol !=nil.

XuHuaiyu · 2018-04-26T09:46:01Z

plan/logical_plans.go

+		return errors.Trace(err)
+	}
+	path.countAfterAccess, err = ds.statisticTable.GetRowCountByIntColumnRanges(sc, pkCol.ID, path.ranges)
+	if err != nil {


no need to check,
return errors.Trace(err) is ok.

XuHuaiyu · 2018-04-27T06:21:50Z

plan/gen_physical_plans.go

-			innerPlan := x.forceToTableScan(pkCol)
-			return p.constructIndexJoin(prop, innerJoinKeys, outerJoinKeys, outerIdx, innerPlan, nil, nil)
+	accessPaths := x.possibleAccessPaths
+	if len(accessPaths) > 0 && x.possibleAccessPaths[0].isRowID {


s/ x.possibleAccessPaths[0]/ accessPaths[0]

XuHuaiyu · 2018-04-27T06:47:28Z

plan/logical_plans.go

+	indexFilters    []expression.Expression
+	tableFilters    []expression.Expression
+	// isRowID indicates this path stores the information for table scan.
+	isRowID bool


why not just name it as isTablePath?

XuHuaiyu · 2018-04-27T08:38:47Z

plan/planbuilder.go

-func getAvailableIndices(indexHints []*ast.IndexHint, tableInfo *model.TableInfo) (*availableIndices, error) {
-	publicIndices := make([]*model.IndexInfo, 0, len(tableInfo.Indices))
-	for _, index := range tableInfo.Indices {
+func matchPathByIndexName(paths []*accessPath, idxName model.CIStr) *accessPath {


I think matchXxx may return a bool value,
s/match/get

XuHuaiyu · 2018-04-27T08:53:19Z

plan/planbuilder.go

 	// If we have got "FORCE" or "USE" index hint but got no available index,
 	// we have to use table scan.
-	return &availableIndices{available, len(available) == 0}, nil
+	if len(available) == 0 {
+		available = append(available, &accessPath{isRowID: true})


We can just use publicPath[0] here without building a new accessPath ?

XuHuaiyu · 2018-04-27T08:56:47Z

plan/planbuilder.go

 				continue
 			}
 			// Currently we don't distinguish between "FORCE" and "USE" because
 			// our cost estimation is not reliable.
 			hasUseOrForce = true
-			available = append(available, idx)
+			path.forced = true
+			available = append(available, path)
 		}
 	}

 	if !hasScanHint {


if !hasScanHint || !hasUseOrForce { available = publicPaths } available = removeIgnorePaths(available, ignored) if len(available) == 0 { .... } return avaibale, nil

XuHuaiyu · 2018-04-27T09:01:02Z

plan/logical_plans.go

+	tableFilters    []expression.Expression
+	// isRowID indicates this path stores the information for table scan.
+	isRowID bool
+	// forced means this index is generated by `use/force index()`.


s/ this index/ this path

XuHuaiyu · 2018-04-27T09:01:42Z

plan/logical_plans.go

+	eqCondCount     int
+	indexFilters    []expression.Expression
+	tableFilters    []expression.Expression
+	// isRowID indicates this path stores the information for table scan.


s/ this path stores the information for table scan/ whether this path is a table path

XuHuaiyu · 2018-04-28T02:08:12Z

plan/logical_plans.go

-	// availableIndices is used for storing result of availableIndices function.
-	availableIndices *availableIndices
+	// possibleAccessPaths stores all the possible access path for physical plan, including table scan.
+	// Please make sure table path is always the first element.


Please add a comment that:
Note: The first element is `not` always the table path.

XuHuaiyu · 2018-04-28T02:18:44Z

plan/physical_plan_builder.go

-			idxTask, err := ds.convertToIndexScan(prop, idx)
+			continue
+		}
+		if len(path.accessConds) > 0 || len(prop.cols) > 0 || path.forced {


Please add a comment on this check.

path.forced is checked only here,
we do not really need this attribute,
since if an indexPath is involved, path.forced must be true.

But, path.accessConds and prop.cols may be nil.
Such as select * from t use index(idx); We need to choose idx, but there' no access cond and prop.

XuHuaiyu · 2018-04-28T03:04:41Z

plan/stats.go

-		return p.stats
+		var err error
+		p.stats, err = p.children[0].deriveStats()
+		if err != nil {


return p.stats, errors.Trace(err)

XuHuaiyu · 2018-04-28T03:07:33Z

@winoros Please address the above comments.

coocood · 2018-04-28T05:18:20Z

plan/logical_plans.go

-	// availableIndices is used for storing result of availableIndices function.
-	availableIndices *availableIndices
+	// possibleAccessPaths stores all the possible access path for physical plan, including table scan.
+	// Please make sure table path is always the first element if we have table path.


If we check isTablePath in each path, then why do we need to make sure the table path is the first?

For index join, if there's pk and match the condition, we will directly choose it.
Use a loop to find the tablePath first.
So i removed this constraint.

XuHuaiyu · 2018-04-28T05:25:20Z

plan/logical_plans.go

+			pkCol = expression.ColInfo2Col(ds.schema.Columns, pkColInfo)
+		}
+	}
+	if pkCol == nil {


We'better add some test cases to cover pkCol == nil and pkCol !=nil.

the status of pkCol is covered executor's unit test

But why all test cases can be passed when line 336~340 was missed before,
we may need some test for checking this case.

let me check it first.

XuHuaiyu · 2018-04-28T05:48:31Z

plan/gen_physical_plans.go

-			innerPlan := x.forceToTableScan(pkCol)
-			return p.constructIndexJoin(prop, innerJoinKeys, outerJoinKeys, outerIdx, innerPlan, nil, nil)
+	accessPaths := x.possibleAccessPaths
+	if len(accessPaths) > 0 && accessPaths[0].isTablePath {


when will len(accessPaths) == 0?

coocood · 2018-04-28T06:15:48Z

plan/gen_physical_plans.go

+	for i, path := range accessPaths {
+		if path.isTablePath {
+			tblPath = path
+			accessPaths = append(accessPaths[:i], accessPaths[i+1:]...)


This operation modifies possibleAccessPaths.

We just iterate possibleAccessPaths and ignore table path at line 278.

zz-jason · 2018-04-28T06:13:37Z

plan/physical_plan_builder.go

+		// We will use index to generate physical plan if:
+		// this path's access cond is not nil or
+		// we have prop to match or
+		// this index is force to choose.


zz-jason · 2018-04-28T06:27:01Z

plan/property_cols_prune.go

+			col := ds.getPKIsHandleCol()
+			if col != nil {
+				result = append(result, []*expression.Column{col})
+			}


add a continue here so we do not need the following else

zz-jason

LGTM

coocood

LGTM

…ap#6346)

… (#6953)

plan: calc index path when doing deriveStats.

391e389

coocood reviewed Apr 23, 2018

View reviewed changes

Merge branch 'master' into move-index-calc-front

2039b18

address comments.

50fd959

winoros changed the title ~~plan: calc index path when doing deriveStats.~~ plan: calc access path when doing deriveStats. Apr 24, 2018

coocood reviewed Apr 24, 2018

View reviewed changes

zz-jason reviewed Apr 24, 2018

View reviewed changes

alivxxx reviewed Apr 24, 2018

View reviewed changes

XuHuaiyu reviewed Apr 25, 2018

View reviewed changes

winoros added 2 commits April 25, 2018 15:28

address comment.

ba77bdf

Merge branch 'master' into move-index-calc-front

d1a7691

XuHuaiyu reviewed Apr 25, 2018

View reviewed changes

address comments.

8192bfa

alivxxx reviewed Apr 26, 2018

View reviewed changes

address comment.

5d3620f

winoros force-pushed the move-index-calc-front branch from 4313fec to 5d3620f Compare April 26, 2018 05:15

XuHuaiyu added the all-tests-passed label Apr 27, 2018

zz-jason reviewed Apr 27, 2018

View reviewed changes

XuHuaiyu reviewed Apr 27, 2018

View reviewed changes

XuHuaiyu reviewed Apr 28, 2018

View reviewed changes

address comments.

d170ac3

coocood reviewed Apr 28, 2018

View reviewed changes

XuHuaiyu reviewed Apr 28, 2018

View reviewed changes

address comment.

e528c54

coocood reviewed Apr 28, 2018

View reviewed changes

zz-jason reviewed Apr 28, 2018

View reviewed changes

address comments.

8d5775b

zz-jason reviewed Apr 28, 2018

View reviewed changes

coocood reviewed Apr 28, 2018

View reviewed changes

coocood approved these changes Apr 28, 2018

View reviewed changes

coocood added the status/LGT2 Indicates that a PR has LGTM 2. label Apr 28, 2018

Merge branch 'master' into move-index-calc-front

e6bc81b

zz-jason merged commit 50426a9 into pingcap:master Apr 28, 2018

winoros deleted the move-index-calc-front branch May 15, 2018 07:55

winoros added a commit to winoros/tidb that referenced this pull request Jul 2, 2018

plan: calculate table access paths in DataSource.deriveStats (pingc…

baa4f9e

…ap#6346)

winoros mentioned this pull request Jul 2, 2018

plan: calculate table access paths in DataSource.deriveStats (#6346) #6953

Merged

shenli pushed a commit that referenced this pull request Jul 2, 2018

plan: calculate table access paths in DataSource.deriveStats (#6346)…

b056caa

… (#6953)

plan: calc access path when doing deriveStats. #6346

plan: calc access path when doing deriveStats. #6346

Conversation

winoros commented Apr 23, 2018 • edited Loading

winoros commented Apr 23, 2018

winoros commented Apr 23, 2018

winoros commented Apr 23, 2018

winoros commented Apr 23, 2018

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

shenli commented Apr 23, 2018

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

winoros commented Apr 25, 2018

winoros commented Apr 25, 2018

Choose a reason for hiding this comment

iamxy commented Apr 26, 2018

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

XuHuaiyu commented Apr 28, 2018

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

coocood Apr 28, 2018 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

zz-jason left a comment

Choose a reason for hiding this comment

coocood left a comment

Choose a reason for hiding this comment

plan: calc `access path` when doing `deriveStats`. #6346

plan: calc `access path` when doing `deriveStats`. #6346

winoros commented Apr 23, 2018 •

edited

Loading

coocood Apr 28, 2018 •

edited

Loading