infoschema: Migrate the infoschema's retrieving data logic for 'schemata' to executor

executor/builder.go

@@ -1267,7 +1267,7 @@ func (b *executorBuilder) getStartTS() (uint64, error) {
 func (b *executorBuilder) buildMemTable(v *plannercore.PhysicalMemTable) Executor {
 	switch v.DBName.L {
 	case util.MetricSchemaName.L:
-		return &ClusterReaderExec{
+		return &MemTableReaderExec{
 			baseExecutor: newBaseExecutor(b.ctx, v.Schema(), v.ExplainID()),
 			retriever: &MetricRetriever{
 				table:     v.Table,
@@ -1277,66 +1277,74 @@ func (b *executorBuilder) buildMemTable(v *plannercore.PhysicalMemTable) Executo
 	case util.InformationSchemaName.L:
 		switch v.Table.Name.L {
 		case strings.ToLower(infoschema.TableClusterConfig):
-			return &ClusterReaderExec{
+			return &MemTableReaderExec{
 				baseExecutor: newBaseExecutor(b.ctx, v.Schema(), v.ExplainID()),
 				retriever: &clusterConfigRetriever{
 					extractor: v.Extractor.(*plannercore.ClusterTableExtractor),
 				},
 			}
 		case strings.ToLower(infoschema.TableClusterLoad):
-			return &ClusterReaderExec{
+			return &MemTableReaderExec{
 				baseExecutor: newBaseExecutor(b.ctx, v.Schema(), v.ExplainID()),
 				retriever: &clusterServerInfoRetriever{
 					extractor:      v.Extractor.(*plannercore.ClusterTableExtractor),
 					serverInfoType: diagnosticspb.ServerInfoType_LoadInfo,
 				},
 			}
 		case strings.ToLower(infoschema.TableClusterHardware):
-			return &ClusterReaderExec{
+			return &MemTableReaderExec{
 				baseExecutor: newBaseExecutor(b.ctx, v.Schema(), v.ExplainID()),
 				retriever: &clusterServerInfoRetriever{
 					extractor:      v.Extractor.(*plannercore.ClusterTableExtractor),
 					serverInfoType: diagnosticspb.ServerInfoType_HardwareInfo,
 				},
 			}
 		case strings.ToLower(infoschema.TableClusterSystemInfo):
-			return &ClusterReaderExec{
+			return &MemTableReaderExec{
 				baseExecutor: newBaseExecutor(b.ctx, v.Schema(), v.ExplainID()),
 				retriever: &clusterServerInfoRetriever{
 					extractor:      v.Extractor.(*plannercore.ClusterTableExtractor),
 					serverInfoType: diagnosticspb.ServerInfoType_SystemInfo,
 				},
 			}
 		case strings.ToLower(infoschema.TableClusterLog):
-			return &ClusterReaderExec{
+			return &MemTableReaderExec{
 				baseExecutor: newBaseExecutor(b.ctx, v.Schema(), v.ExplainID()),
 				retriever: &clusterLogRetriever{
 					extractor: v.Extractor.(*plannercore.ClusterLogTableExtractor),
 				},
 			}
 		case strings.ToLower(infoschema.TableInspectionResult):
-			return &ClusterReaderExec{
+			return &MemTableReaderExec{
 				baseExecutor: newBaseExecutor(b.ctx, v.Schema(), v.ExplainID()),
 				retriever: &inspectionRetriever{
 					extractor: v.Extractor.(*plannercore.InspectionResultTableExtractor),
 				},
 			}
 		case strings.ToLower(infoschema.TableMetricSummary):
-			return &ClusterReaderExec{
+			return &MemTableReaderExec{
 				baseExecutor: newBaseExecutor(b.ctx, v.Schema(), v.ExplainID()),
 				retriever: &MetricSummaryRetriever{
 					table:     v.Table,
 					extractor: v.Extractor.(*plannercore.MetricTableExtractor),
 				},
 			}
 		case strings.ToLower(infoschema.TableMetricSummaryByLabel):
-			return &ClusterReaderExec{
+			return &MemTableReaderExec{
 				baseExecutor: newBaseExecutor(b.ctx, v.Schema(), v.ExplainID()),
 				retriever: &MetricSummaryByLabelRetriever{
 					table:     v.Table,
 					extractor: v.Extractor.(*plannercore.MetricTableExtractor),
 				},
 			}
+		case strings.ToLower(infoschema.TableSchemata), strings.ToLower(infoschema.TableViews):
+			return &MemTableReaderExec{
+				baseExecutor: newBaseExecutor(b.ctx, v.Schema(), v.ExplainID()),
+				retriever: &memtableRetriever{
+					table:   v.Table,
+					columns: v.Columns,
+				},
+			}
 		}
 	}
 	tb, _ := b.is.TableByID(v.Table.ID)

executor/cluster_reader.go

@@ -53,19 +53,19 @@ type dummyCloser struct{}
 
 func (dummyCloser) close() error { return nil }
 
-type clusterRetriever interface {
+type memTableRetriever interface {
 	retrieve(ctx context.Context, sctx sessionctx.Context) ([][]types.Datum, error)
 	close() error
 }
 
-// ClusterReaderExec executes cluster information retrieving from the cluster components
-type ClusterReaderExec struct {
+// MemTableReaderExec executes memTable information retrieving from the MemTable components
+type MemTableReaderExec struct {
 	baseExecutor
-	retriever clusterRetriever
+	retriever memTableRetriever
 }
 
 // Next implements the Executor Next interface.
-func (e *ClusterReaderExec) Next(ctx context.Context, req *chunk.Chunk) error {
+func (e *MemTableReaderExec) Next(ctx context.Context, req *chunk.Chunk) error {
 	rows, err := e.retriever.retrieve(ctx, e.ctx)
 	if err != nil {
 		return err
@@ -86,7 +86,7 @@ func (e *ClusterReaderExec) Next(ctx context.Context, req *chunk.Chunk) error {
 }
 
 // Close implements the Executor Close interface.
-func (e *ClusterReaderExec) Close() error {
+func (e *MemTableReaderExec) Close() error {
 	return e.retriever.close()
 }
 
@@ -96,7 +96,7 @@ type clusterConfigRetriever struct {
 	extractor *plannercore.ClusterTableExtractor
 }
 
-// retrieve implements the clusterRetriever interface
+// retrieve implements the memTableRetriever interface
 func (e *clusterConfigRetriever) retrieve(_ context.Context, sctx sessionctx.Context) ([][]types.Datum, error) {
 	if e.extractor.SkipRequest || e.retrieved {
 		return nil, nil
@@ -224,7 +224,7 @@ type clusterServerInfoRetriever struct {
 	retrieved      bool
 }
 
-// retrieve implements the clusterRetriever interface
+// retrieve implements the memTableRetriever interface
 func (e *clusterServerInfoRetriever) retrieve(ctx context.Context, sctx sessionctx.Context) ([][]types.Datum, error) {
 	if e.extractor.SkipRequest || e.retrieved {
 		return nil, nil

executor/infoschema_reader.go

@@ -0,0 +1,155 @@
+// Copyright 2020 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 executor
+
+import (
+	"context"
+	"sort"
+
+	"github.com/pingcap/parser/model"
+	"github.com/pingcap/parser/mysql"
+	"github.com/pingcap/tidb/infoschema"
+	"github.com/pingcap/tidb/privilege"
+	"github.com/pingcap/tidb/sessionctx"
+	"github.com/pingcap/tidb/types"
+)
+
+type memtableRetriever struct {
+	dummyCloser
+	table       *model.TableInfo
+	columns     []*model.ColumnInfo
+	rows        [][]types.Datum
+	rowIdx      int
+	retrieved   bool
+	initialized bool
+}
+
+// retrieve implements the infoschemaRetriever interface
+func (e *memtableRetriever) retrieve(ctx context.Context, sctx sessionctx.Context) ([][]types.Datum, error) {
+	if e.retrieved {
+		return nil, nil
+	}
+
+	//Cache the ret full rows in schemataRetriever
+	if !e.initialized {
+		is := infoschema.GetInfoSchema(sctx)
+		dbs := is.AllSchemas()
+		sort.Sort(infoschema.SchemasSorter(dbs))
+		var err error
+		switch e.table.Name.O {
+		case infoschema.TableSchemata:
+			e.rows = dataForSchemata(sctx, dbs)
+		case infoschema.TableViews:
+			e.rows, err = dataForViews(sctx, dbs)
+		}
+		if err != nil {
+			return nil, err
+		}
+		e.initialized = true
+	}
+
+	//Adjust the amount of each return
+	maxCount := 1024
+	retCount := maxCount
+	if e.rowIdx+maxCount > len(e.rows) {
+		retCount = len(e.rows) - e.rowIdx
+		e.retrieved = true
+	}
+	ret := make([][]types.Datum, retCount)
+	for i := e.rowIdx; i < e.rowIdx+retCount; i++ {
+		ret[i-e.rowIdx] = e.rows[i]
+	}
+	e.rowIdx += retCount
+	if len(e.columns) == len(e.table.Columns) {
+		return ret, nil
+	}
+	rows := make([][]types.Datum, len(ret))
+	for i, fullRow := range ret {
+		row := make([]types.Datum, len(e.columns))
+		for j, col := range e.columns {
+			row[j] = fullRow[col.Offset]
+		}
+		rows[i] = row
+	}
+	return rows, nil
+}
+
+func dataForSchemata(ctx sessionctx.Context, schemas []*model.DBInfo) [][]types.Datum {
+	checker := privilege.GetPrivilegeManager(ctx)
+	rows := make([][]types.Datum, 0, len(schemas))
+
+	for _, schema := range schemas {
+
+		charset := mysql.DefaultCharset
+		collation := mysql.DefaultCollationName
+
+		if len(schema.Charset) > 0 {
+			charset = schema.Charset // Overwrite default
+		}
+
+		if len(schema.Collate) > 0 {
+			collation = schema.Collate // Overwrite default
+		}
+
+		if checker != nil && !checker.RequestVerification(ctx.GetSessionVars().ActiveRoles, schema.Name.L, "", "", mysql.AllPrivMask) {
+			continue
+		}
+		record := types.MakeDatums(
+			infoschema.CatalogVal, // CATALOG_NAME
+			schema.Name.O,         // SCHEMA_NAME
+			charset,               // DEFAULT_CHARACTER_SET_NAME
+			collation,             // DEFAULT_COLLATION_NAME
+			nil,
+		)
+		rows = append(rows, record)
+	}
+	return rows
+}
+
+func dataForViews(ctx sessionctx.Context, schemas []*model.DBInfo) ([][]types.Datum, error) {
+	checker := privilege.GetPrivilegeManager(ctx)
+	var rows [][]types.Datum
+	for _, schema := range schemas {
+		for _, table := range schema.Tables {
+			if !table.IsView() {
+				continue
+			}
+			collation := table.Collate
+			charset := table.Charset
+			if collation == "" {
+				collation = mysql.DefaultCollationName
+			}
+			if charset == "" {
+				charset = mysql.DefaultCharset
+			}
+			if checker != nil && !checker.RequestVerification(ctx.GetSessionVars().ActiveRoles, schema.Name.L, table.Name.L, "", mysql.AllPrivMask) {
+				continue
+			}
+			record := types.MakeDatums(
+				infoschema.CatalogVal,           // TABLE_CATALOG
+				schema.Name.O,                   // TABLE_SCHEMA
+				table.Name.O,                    // TABLE_NAME
+				table.View.SelectStmt,           // VIEW_DEFINITION
+				table.View.CheckOption.String(), // CHECK_OPTION
+				"NO",                            // IS_UPDATABLE
+				table.View.Definer.String(),     // DEFINER
+				table.View.Security.String(),    // SECURITY_TYPE
+				charset,                         // CHARACTER_SET_CLIENT
+				collation,                       // COLLATION_CONNECTION
+			)
+			rows = append(rows, record)
+		}
+	}
+	return rows, nil
+}

executor/infoschema_reader_test.go

@@ -0,0 +1,85 @@
+// Copyright 2020 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 executor_test
+
+import (
+	. "github.com/pingcap/check"
+	"github.com/pingcap/parser/auth"
+	"github.com/pingcap/tidb/domain"
+	"github.com/pingcap/tidb/kv"
+	"github.com/pingcap/tidb/util/testkit"
+)
+
+var _ = Suite(&testInfoschemaTableSuite{})
+
+type testInfoschemaTableSuite struct {
+	store kv.Storage
+	dom   *domain.Domain
+}
+
+func (s *testInfoschemaTableSuite) SetUpSuite(c *C) {
+	store, dom, err := newStoreWithBootstrap()
+	c.Assert(err, IsNil)
+	s.store = store
+	s.dom = dom
+}
+
+func (s *testInfoschemaTableSuite) TearDownSuite(c *C) {
+	s.dom.Close()
+	s.store.Close()
+}
+func (s *testInfoschemaTableSuite) TestSchemataTables(c *C) {
+	tk := testkit.NewTestKit(c, s.store)
+
+	tk.MustQuery("select * from information_schema.SCHEMATA where schema_name='mysql';").Check(
+		testkit.Rows("def mysql utf8mb4 utf8mb4_bin <nil>"))
+
+	//test the privilege of new user for information_schema.schemata
+	tk.MustExec("create user schemata_tester")
+	schemataTester := testkit.NewTestKit(c, s.store)
+	schemataTester.MustExec("use information_schema")
+	c.Assert(schemataTester.Se.Auth(&auth.UserIdentity{
+		Username: "schemata_tester",
+		Hostname: "127.0.0.1",
+	}, nil, nil), IsTrue)
+	schemataTester.MustQuery("select count(*) from information_schema.SCHEMATA;").Check(testkit.Rows("1"))
+	schemataTester.MustQuery("select * from information_schema.SCHEMATA where schema_name='mysql';").Check(
+		[][]interface{}{})
+	schemataTester.MustQuery("select * from information_schema.SCHEMATA where schema_name='INFORMATION_SCHEMA';").Check(
+		testkit.Rows("def INFORMATION_SCHEMA utf8mb4 utf8mb4_bin <nil>"))
+
+	//test the privilege of user with privilege of mysql for information_schema.schemata
+	tk.MustExec("CREATE ROLE r_mysql_priv;")
+	tk.MustExec("GRANT ALL PRIVILEGES ON mysql.* TO r_mysql_priv;")
+	tk.MustExec("GRANT r_mysql_priv TO schemata_tester;")
+	schemataTester.MustExec("set role r_mysql_priv")
+	schemataTester.MustQuery("select count(*) from information_schema.SCHEMATA;").Check(testkit.Rows("2"))
+	schemataTester.MustQuery("select * from information_schema.SCHEMATA;").Check(
+		testkit.Rows("def INFORMATION_SCHEMA utf8mb4 utf8mb4_bin <nil>", "def mysql utf8mb4 utf8mb4_bin <nil>"))
+}
+
+func (s *testInfoschemaTableSuite) TestSchemataCharacterSet(c *C) {
+	tk := testkit.NewTestKit(c, s.store)
+	tk.MustExec("CREATE DATABASE `foo` DEFAULT CHARACTER SET = 'utf8mb4'")
+	tk.MustQuery("select default_character_set_name, default_collation_name FROM information_schema.SCHEMATA  WHERE schema_name = 'foo'").Check(
+		testkit.Rows("utf8mb4 utf8mb4_bin"))
+	tk.MustExec("drop database `foo`")
+}
+
+func (s *testInfoschemaTableSuite) TestViews(c *C) {
+	tk := testkit.NewTestKit(c, s.store)
+	tk.MustExec("CREATE DEFINER='root'@'localhost' VIEW test.v1 AS SELECT 1")
+	tk.MustQuery("SELECT * FROM information_schema.views WHERE table_schema='test' AND table_name='v1'").Check(testkit.Rows("def test v1 SELECT 1 CASCADED NO root@localhost DEFINER utf8mb4 utf8mb4_bin"))
+	tk.MustQuery("SELECT table_catalog, table_schema, table_name, table_type, engine, version, row_format, table_rows, avg_row_length, data_length, max_data_length, index_length, data_free, auto_increment, update_time, check_time, table_collation, checksum, create_options, table_comment FROM information_schema.tables WHERE table_schema='test' AND table_name='v1'").Check(testkit.Rows("def test v1 VIEW <nil> <nil> <nil> <nil> <nil> <nil> <nil> <nil> <nil> <nil> <nil> <nil> <nil> <nil> <nil> VIEW"))
+}