plan: add cache for statistics table

executor/executor_simple.go

@@ -381,6 +381,7 @@ func (e *SimpleExec) buildStatisticsAndSaveToKV(tn *ast.TableName, count int64,
 	if err != nil {
 		return errors.Trace(err)
 	}
+	statistics.SetStatisticsTableCache(tn.TableInfo.ID, t)
 	tpb, err := t.ToPB()
 	if err != nil {
 		return errors.Trace(err)

plan/logical_plan_builder.go

@@ -20,6 +20,7 @@ import (
 	"github.com/ngaut/log"
 	"github.com/pingcap/tidb/ast"
 	"github.com/pingcap/tidb/expression"
+	"github.com/pingcap/tidb/meta"
 	"github.com/pingcap/tidb/model"
 	"github.com/pingcap/tidb/mysql"
 	"github.com/pingcap/tidb/plan/statistics"
@@ -908,8 +909,39 @@ func (b *planBuilder) buildTableDual() LogicalPlan {
 }
 
 func (b *planBuilder) getTableStats(table *model.TableInfo) *statistics.Table {
-	// TODO: Currently we always return a pseudo table for good performance. We will use a cache in future.
-	return statistics.PseudoTable(table)
+	tbl := statistics.GetStatisticsTableCache(table)
+	if tbl != nil {
+		return tbl
+	}
+	txn := b.ctx.Txn()
+	if txn == nil {
+		return statistics.PseudoTable(table)
+	}
+	m := meta.NewMeta(txn)
+	tpb, err := m.GetTableStats(table.ID)
+	if err != nil {
+		return statistics.PseudoTable(table)
+	}
+	// This table has no statistics table, we give it a pseudo one and save in cache.
+	if tpb == nil {
+		tbl = statistics.PseudoTable(table)
+		tbl.TS = int64(txn.StartTS())
+		statistics.SetStatisticsTableCache(table.ID, tbl)
+		return tbl
+	}
+	tbl, err = statistics.TableFromPB(table, tpb)
+	// Error is not nil may mean that there are some ddl changes on this table, so the origin
+	// statistics can not be used any more, we give it a pseudo one and save in cache.
+	if err != nil {
+		log.Errorf("Error occured when convert pb table for %s", table.Name.O)
+		tbl = statistics.PseudoTable(table)
+		tbl.TS = int64(txn.StartTS())
+		statistics.SetStatisticsTableCache(table.ID, tbl)
+		return statistics.PseudoTable(table)
+	}
+	tbl.TS = int64(txn.StartTS())
+	statistics.SetStatisticsTableCache(table.ID, tbl)
+	return tbl
 }
 
 func (b *planBuilder) buildDataSource(tn *ast.TableName) LogicalPlan {

plan/statistics/statistics.go

@@ -330,6 +330,7 @@ func NewTable(sc *variable.StatementContext, ti *model.TableInfo, ts, count, num
 
 // TableFromPB creates a table statistics from protobuffer.
 func TableFromPB(ti *model.TableInfo, tpb *TablePB) (*Table, error) {
+	// TODO: The following error may mean that there is a ddl change on this table. Currently, The caller simply drop the statistics table. Maybe we can have better solution.
 	if tpb.GetId() != ti.ID {
 		return nil, errors.Errorf("table id not match, expected %d, got %d", ti.ID, tpb.GetId())
 	}

plan/statistics/statistics_cache.go

@@ -0,0 +1,60 @@
+// Copyright 2017 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package statistics
+
+import (
+	"sync"
+	"time"
+
+	"github.com/pingcap/tidb/model"
+	"github.com/pingcap/tidb/store/tikv/oracle"
+)
+
+type tableCache struct {
+	m     sync.RWMutex
+	cache map[int64]*Table
+}
+
+var tblCache = tableCache{cache: map[int64]*Table{}}
+
+// expireDuration is 1 hour.
+var expireDuration int64 = 60 * 60 * 1000
+
+func tableCacheExpired(tbl *Table) bool {
+	duration := oracle.GetPhysical(time.Now()) - oracle.ExtractPhysical(uint64(tbl.TS))
+	if duration >= expireDuration {
+		return true
+	}
+	return false
+}
+
+// GetStatisticsTableCache retrieves the statistics table from cache.
+func GetStatisticsTableCache(tblInfo *model.TableInfo) *Table {
+	tblCache.m.RLock()
+	statTbl, ok := tblCache.cache[tblInfo.ID]
+	tblCache.m.RUnlock()
+	// Here we check the TableInfo because there may be some ddl changes in the duration period.
+	// Also, we rely on the fact that TableInfo will not be same if and only if there are ddl changes.
+	if !ok || tblInfo != statTbl.info || tableCacheExpired(statTbl) {
+		return nil
+	}
+	return statTbl
+}
+
+// SetStatisticsTableCache sets the statistics table cache.
+func SetStatisticsTableCache(id int64, tbl *Table) {
+	tblCache.m.Lock()
+	tblCache.cache[id] = tbl
+	tblCache.m.Unlock()
+}