Feat: cache infoschema

pkg/scdb/executor/ddl.go

@@ -113,6 +113,8 @@ func (e *DDLExec) executeCreateDatabase(s *ast.CreateDatabaseStmt) (err error) {
 	if result.Error != nil {
 		return fmt.Errorf("ddl.executeCreateDatabase: %v", result.Error)
 	}
+	// Invalidate cache after successful DDL operation
+	storage.InvalidateInfoSchemaCache(dbName)
 	return nil
 }
 
@@ -212,6 +214,8 @@ func (e *DDLExec) executeCreateTable(s *ast.CreateTableStmt) (err error) {
 		}
 	}
 
+	// Invalidate cache after successful DDL operation
+	storage.InvalidateInfoSchemaCache(dbName)
 	return nil
 }
 
@@ -321,6 +325,8 @@ func (e *DDLExec) executeCreateView(s *ast.CreateViewStmt) (err error) {
 			return fmt.Errorf("ddl.executeCreateView: %v", result.Error)
 		}
 	}
+	// Invalidate cache after successful DDL operation
+	storage.InvalidateInfoSchemaCache(dbName)
 	return nil
 }
 
@@ -346,6 +352,10 @@ func (e *DDLExec) executeDropDatabase(s *ast.DropDatabaseStmt) (err error) {
 		return fmt.Errorf("database %v not exists", dbName)
 	}
 	err = storage.NewDDLHandler(tx).DropSchema(model.NewCIStr(dbName))
+	if err == nil {
+		// Invalidate cache after successful DDL operation (in case not done in DropSchema)
+		storage.InvalidateInfoSchemaCache(dbName)
+	}
 	return err
 }
 
@@ -404,5 +414,9 @@ func (e *DDLExec) executeDropTableOrView(s *ast.DropTableStmt) (err error) {
 		return err
 	}
 	err = storage.NewDDLHandler(tx).DropTable(model.NewCIStr(dbName), model.NewCIStr(tblName))
+	if err == nil {
+		// Invalidate cache after successful DDL operation (in case not done in DropTable)
+		storage.InvalidateInfoSchemaCache(dbName)
+	}
 	return err
 }

pkg/scdb/storage/schema_tables.go

@@ -92,6 +92,8 @@ func (h *DDLHandler) DropSchema(schema model.CIStr) error {
 	if err := h.store.Transaction(callFc); err != nil {
 		return fmt.Errorf("dropSchema: %v", err)
 	}
+	// Invalidate cache after successful DDL operation
+	InvalidateInfoSchemaCache(schema.String())
 	return nil
 }
 
@@ -102,6 +104,8 @@ func (h *DDLHandler) DropTable(schema, tblName model.CIStr) error {
 	if err := h.store.Transaction(callFc); err != nil {
 		return fmt.Errorf("dropTable: %v", err)
 	}
+	// Invalidate cache after successful DDL operation
+	InvalidateInfoSchemaCache(schema.String())
 	return nil
 }
 

pkg/scdb/storage/storage.go

@@ -21,6 +21,7 @@
 	"reflect"
 	"sort"
 	"strings"
+	"sync"
 
 	"github.com/sethvargo/go-password/password"
 	"gorm.io/gorm"
@@ -53,6 +54,14 @@
 // keep creating order
 var allTables = []interface{}{&User{}, &Database{}, &Table{}, &Column{}, &DatabasePriv{}, &TablePriv{}, &ColumnPriv{}}
 
+// InfoSchema cache to avoid frequent database queries
+var (
+	infoSchemaCache     sync.Map // map[string]infoschema.InfoSchema, key is database name
+	infoCacheHitCount   int64
+	infoCacheMissCount  int64
+	infoCacheMutex      sync.RWMutex
+)
+
 // NeedBootstrap checks if the store is empty
 func NeedBootstrap(store *gorm.DB) bool {
 	for _, tn := range allTables {
@@ -173,6 +182,33 @@
 	return &user, nil
 }
 
+// InvalidateInfoSchemaCache invalidates the InfoSchema cache for a specific database
+// If dbName is empty, it invalidates all cached InfoSchemas
+func InvalidateInfoSchemaCache(dbName string) {
+	if dbName == "" {
+		// Clear all cache
+		infoSchemaCache = sync.Map{}
+	} else {
+		// Clear specific database cache
+		infoSchemaCache.Delete(dbName)
+	}
+}
+
+// ResetInfoSchemaCacheStats resets cache statistics (for testing)
+func ResetInfoSchemaCacheStats() {
+	infoCacheMutex.Lock()
+	defer infoCacheMutex.Unlock()
+	infoCacheHitCount = 0
+	infoCacheMissCount = 0
+}
+
+// GetInfoSchemaCacheStats returns cache hit and miss statistics
+func GetInfoSchemaCacheStats() (hits, misses int64) {
+	infoCacheMutex.RLock()
+	defer infoCacheMutex.RUnlock()
+	return infoCacheHitCount, infoCacheMissCount
+}
+
 func QueryInfoSchema(store *gorm.DB) (result infoschema.InfoSchema, err error) {
 	callFc := func(tx *gorm.DB) error {
 		result, err = queryInfoSchema(tx)
@@ -244,13 +280,32 @@
 }
 
 func QueryDBInfoSchema(store *gorm.DB, dbName string) (result infoschema.InfoSchema, err error) {
+	// Try to get from cache first
+	if cached, ok := infoSchemaCache.Load(dbName); ok {
+		infoCacheMutex.Lock()
+		infoCacheHitCount++
+		infoCacheMutex.Unlock()
+		return cached.(infoschema.InfoSchema), nil
+	}
+
+	// Cache miss, query from database
+	infoCacheMutex.Lock()
+	infoCacheMissCount++
+	infoCacheMutex.Unlock()
+
 	callFc := func(tx *gorm.DB) error {
 		result, err = queryDBInfoSchema(tx, dbName)
 		return err
 	}
 	if err := store.Transaction(callFc, &sql.TxOptions{ReadOnly: true}); err != nil {
 		return nil, fmt.Errorf("queryDBInfoSchema: %v", err)
 	}
+
+	// Store in cache
+	if result != nil {
+		infoSchemaCache.Store(dbName, result)
+	}
+
 	return result, nil
 }