*: add statement summary for RUv2 and use float64 for calculations (#67223)

disksing · web-flow · commit 820a41f92a01 · 2026-03-23T16:41:58.000Z
ref #67199
diff --git a/pkg/executor/adapter.go b/pkg/executor/adapter.go
@@ -1729,10 +1729,22 @@ func (a *ExecStmt) finalizeStatementRUV2Metrics() {
 		dctx.RUConsumptionReporter.ReportTiKVRUV2Consumption(dctx.ResourceGroupName, tikvRU)
 	}
 	if tidbRU > 0 {
-		dctx.RUConsumptionReporter.ReportTiDBRUV2Consumption(dctx.ResourceGroupName, float64(tidbRU))
+		dctx.RUConsumptionReporter.ReportTiDBRUV2Consumption(dctx.ResourceGroupName, tidbRU)
 	}
 }
 
+func calculateStatementTotalRUV2(metrics *execdetails.RUV2Metrics, weights execdetails.RUV2Weights, ruDetail *util.RUDetails) float64 {
+	var tiKVRU, tiFlashRU float64
+	if ruDetail != nil {
+		tiKVRU = ruDetail.TiKVRUV2()
+		tiFlashRU = ruDetail.TiflashRU()
+	}
+	if metrics == nil {
+		return tiKVRU + tiFlashRU
+	}
+	return metrics.TotalRU(weights, tiKVRU, tiFlashRU)
+}
+
 func (a *ExecStmt) recordLastQueryInfo(err error) {
 	sessVars := a.Ctx.GetSessionVars()
 	// Record diagnostic information for DML statements
@@ -2176,6 +2188,7 @@ func (a *ExecStmt) SummaryStmt(succ bool) {
 	stmtExecInfo.KeyspaceName = keyspaceName
 	stmtExecInfo.KeyspaceID = keyspaceID
 	stmtExecInfo.RUDetail = ruDetail
+	stmtExecInfo.TotalRUV2 = calculateStatementTotalRUV2(sessVars.RUV2Metrics, sessVars.RUV2Weights(), ruDetail)
 	stmtExecInfo.ResourceGroupName = sessVars.StmtCtx.ResourceGroupName
 	stmtExecInfo.CPUUsages = sessVars.SQLCPUUsages.GetCPUUsages()
 	stmtExecInfo.PlanCacheUnqualified = sessVars.StmtCtx.PlanCacheUnqualified()
diff --git a/pkg/executor/adapter_test.go b/pkg/executor/adapter_test.go
@@ -494,7 +494,7 @@ func TestFinishExecuteStmtReportsTiDBRUV2WithoutSyncingRUDetails(t *testing.T) {
 	require.Equal(t, "rg1", reporter.tikvGroup)
 	require.Equal(t, float64(23456), reporter.tikvRUV2)
 	require.Equal(t, "rg1", reporter.tidbGroup)
-	require.Equal(t, float64(expected), reporter.tidbRUV2)
+	require.Equal(t, expected, reporter.tidbRUV2)
 }
 
 func TestSlowLogMaxPerSec(t *testing.T) {
diff --git a/pkg/executor/explain_unit_test.go b/pkg/executor/explain_unit_test.go
@@ -146,7 +146,7 @@ func TestExplainAnalyzeInvokeNextAndClose(t *testing.T) {
 		require.Contains(
 			t,
 			ctx.GetSessionVars().StmtCtx.RuntimeStatsColl.GetRootStats(targetPlan.ID()).String(),
-			fmt.Sprintf("RU:%.2f", float64(metrics.TotalRU(weights, 0, 0))),
+			fmt.Sprintf("RU:%.2f", metrics.TotalRU(weights, 0, 0)),
 		)
 
 		recordInsertRows2Metrics(ctx.GetSessionVars())
diff --git a/pkg/infoschema/tables.go b/pkg/infoschema/tables.go
@@ -1425,6 +1425,8 @@ var tableStatementsSummaryCols = []columnInfo{
 	{name: stmtsummary.AvgRequestUnitWriteStr, tp: mysql.TypeDouble, flag: mysql.NotNullFlag | mysql.UnsignedFlag, size: 22, comment: "Average write request-unit cost of these statements"},
 	{name: stmtsummary.MaxQueuedRcTimeStr, tp: mysql.TypeLonglong, size: 22, flag: mysql.NotNullFlag | mysql.UnsignedFlag, comment: "Max time of waiting for available request-units"},
 	{name: stmtsummary.AvgQueuedRcTimeStr, tp: mysql.TypeLonglong, size: 22, flag: mysql.NotNullFlag | mysql.UnsignedFlag, comment: "Average time of waiting for available request-units"},
+	{name: stmtsummary.MaxRequestUnitV2Str, tp: mysql.TypeDouble, flag: mysql.NotNullFlag | mysql.UnsignedFlag, size: 22, comment: "Max request-unit v2 cost of these statements"},
+	{name: stmtsummary.AvgRequestUnitV2Str, tp: mysql.TypeDouble, flag: mysql.NotNullFlag | mysql.UnsignedFlag, size: 22, comment: "Average request-unit v2 cost of these statements"},
 	{name: stmtsummary.ResourceGroupName, tp: mysql.TypeVarchar, size: 64, comment: "Bind resource group name"},
 	{name: stmtsummary.PlanCacheUnqualifiedStr, tp: mysql.TypeLonglong, size: 20, flag: mysql.NotNullFlag, comment: "The number of times that these statements are not supported by the plan cache"},
 	{name: stmtsummary.PlanCacheUnqualifiedLastReasonStr, tp: mysql.TypeBlob, size: types.UnspecifiedLength, comment: "The last reason why the statement is not supported by the plan cache"},
diff --git a/pkg/server/conn_stmt_test.go b/pkg/server/conn_stmt_test.go
@@ -200,7 +200,7 @@ func TestCursorWithParams(t *testing.T) {
 
 		require.Equal(t, "rg1", reporter.tidbGroup)
 		expectedCursorDelta := ruv2Metrics.CalculateRUValues(weights) - baselineTiDBRU
-		require.Equal(t, float64(expectedCursorDelta), reporter.tidbRUV2)
+		require.Equal(t, expectedCursorDelta, reporter.tidbRUV2)
 		require.Equal(t, 0.0, reporter.tikvRUV2)
 
 		ruDetails.AddTiKVRUV2(7)
diff --git a/pkg/server/internal/resultset/resultset.go b/pkg/server/internal/resultset/resultset.go
@@ -73,7 +73,7 @@ type CursorRUV2Tracker struct {
 	ruDetails         *clientutil.RUDetails
 	resourceGroupName string
 	weights           execdetails.RUV2Weights
-	reportedTiDBRU    int64
+	reportedTiDBRU    float64
 	reportedTiKVRUV2  float64
 	mu                sync.Mutex
 }
@@ -119,7 +119,7 @@ func (t *CursorRUV2Tracker) reportDelta() {
 	t.mu.Lock()
 	defer t.mu.Unlock()
 
-	var currentTiDBRU int64
+	var currentTiDBRU float64
 	if t.metrics != nil {
 		currentTiDBRU = t.metrics.CalculateRUValues(t.weights)
 	}
@@ -133,7 +133,7 @@ func (t *CursorRUV2Tracker) reportDelta() {
 			t.reporter.ReportTiKVRUV2Consumption(t.resourceGroupName, deltaTiKVRUV2)
 		}
 		if deltaTiDBRU := currentTiDBRU - t.reportedTiDBRU; deltaTiDBRU > 0 {
-			t.reporter.ReportTiDBRUV2Consumption(t.resourceGroupName, float64(deltaTiDBRU))
+			t.reporter.ReportTiDBRUV2Consumption(t.resourceGroupName, deltaTiDBRU)
 		}
 	}
 
diff --git a/pkg/sessionctx/variable/slow_log.go b/pkg/sessionctx/variable/slow_log.go
@@ -555,10 +555,10 @@ func (s *SessionVars) SlowLogFormat(logItems *SlowQueryLogItems) string {
 	}
 	writeSlowLogItem(&buf, SlowLogStorageFromKV, strconv.FormatBool(logItems.StorageKV))
 	writeSlowLogItem(&buf, SlowLogStorageFromMPP, strconv.FormatBool(logItems.StorageMPP))
-	var tiKVRU, tiFlashRU int64
+	var tiKVRU, tiFlashRU float64
 	if logItems.RUDetails != nil {
-		tiKVRU = int64(logItems.RUDetails.TiKVRUV2())
-		tiFlashRU = int64(logItems.RUDetails.TiflashRU())
+		tiKVRU = logItems.RUDetails.TiKVRUV2()
+		tiFlashRU = logItems.RUDetails.TiflashRU()
 	}
 	if formatted := execdetails.FormatRUV2Metrics(logItems.RUV2Metrics, s.RUV2Weights(), tiKVRU, tiFlashRU); len(formatted) > 0 {
 		writeSlowLogItem(&buf, SlowLogRUV2Metrics, formatted)
diff --git a/pkg/sessionctx/variable/tests/session_test.go b/pkg/sessionctx/variable/tests/session_test.go
@@ -417,7 +417,7 @@ func TestSlowLogFormatIncludesTiFlashRUInRUV2Metrics(t *testing.T) {
 	logItems.RUDetails.UpdateTiFlash(&rmpb.Consumption{RRU: 20, WRU: 30})
 
 	logString := seVar.SlowLogFormat(logItems)
-	require.Contains(t, logString, "# RUv2_metrics: total_ru:150, tidb_ru:0, tikv_ru:100, tiflash_ru:50")
+	require.Contains(t, logString, "# RUv2_metrics: total_ru:150.00, tidb_ru:0.00, tikv_ru:100.00, tiflash_ru:50.00")
 
 	t.Run("default session weights come from config defaults", func(t *testing.T) {
 		original := config.GetGlobalConfig()
diff --git a/pkg/util/execdetails/execdetails_test.go b/pkg/util/execdetails/execdetails_test.go
@@ -361,13 +361,13 @@ func TestRUV2MetricsSnapshotCalculateRUValues(t *testing.T) {
 	metrics.AddTiKVStorageProcessedKeysGet(79)
 
 	tidbRU := metrics.CalculateRUValues(weights)
-	tikvRU := int64(157258)
-	tiflashRU := int64(24680)
+	tikvRU := float64(157258)
+	tiflashRU := float64(24680)
 	totalRU := metrics.TotalRU(weights, tikvRU, tiflashRU)
-	require.Equal(t, int64(114198), tidbRU)
-	require.Equal(t, int64(157258), tikvRU)
-	require.Equal(t, int64(24680), tiflashRU)
-	require.Equal(t, int64(296136), totalRU)
+	require.InEpsilon(t, 114198.0, tidbRU, 0.01)
+	require.InEpsilon(t, 157258.0, tikvRU, 0.01)
+	require.InEpsilon(t, 24680.0, tiflashRU, 0.01)
+	require.InEpsilon(t, 296136.0, totalRU, 0.01)
 
 	t.Run("zero scale stays zero", func(t *testing.T) {
 		zeroScaleWeights := weights
@@ -408,10 +408,10 @@ func TestFormatRUV2MetricsIncludesRUValuesFirst(t *testing.T) {
 
 	parts := strings.Split(formatted, ", ")
 	require.Len(t, parts, 7)
-	require.Equal(t, "total_ru:19983", parts[0])
-	require.Equal(t, "tidb_ru:8750", parts[1])
-	require.Equal(t, "tikv_ru:10987", parts[2])
-	require.Equal(t, "tiflash_ru:246", parts[3])
+	require.Equal(t, "total_ru:19983.42", parts[0])
+	require.Equal(t, "tidb_ru:8750.42", parts[1])
+	require.Equal(t, "tikv_ru:10987.00", parts[2])
+	require.Equal(t, "tiflash_ru:246.00", parts[3])
 }
 
 func TestRURuntimeStatsStringIncludesTiFlashRU(t *testing.T) {
diff --git a/pkg/util/execdetails/runtime_stats.go b/pkg/util/execdetails/runtime_stats.go
@@ -1000,18 +1000,18 @@ func (e *RURuntimeStats) String() string {
 			return buf.String()
 		}
 	case "v2":
-		var tiKVRU, tiFlashRU int64
+		var tiKVRU, tiFlashRU float64
 		if e.RUDetails != nil {
-			tiKVRU = int64(e.RUDetails.TiKVRUV2())
-			tiFlashRU = int64(e.RUDetails.TiflashRU())
+			tiKVRU = e.RUDetails.TiKVRUV2()
+			tiFlashRU = e.RUDetails.TiflashRU()
 		}
 		totalRU := e.Metrics.TotalRU(e.Weights, tiKVRU, tiFlashRU)
 		if totalRU == 0 {
 			return ""
 		}
 		buf := bytes.NewBuffer(make([]byte, 0, 8))
 		buf.WriteString("RU:")
-		buf.WriteString(strconv.FormatFloat(float64(totalRU), 'f', 2, 64))
+		buf.WriteString(strconv.FormatFloat(totalRU, 'f', 2, 64))
 		return buf.String()
 	}
 	return ""
diff --git a/pkg/util/execdetails/ruv2_metrics.go b/pkg/util/execdetails/ruv2_metrics.go
@@ -434,21 +434,22 @@ func (m *RUV2Metrics) IsZero() bool {
 		len(snapshotRUV2LabelCounter(&m.tikvCoprocessorWorkTotal)) == 0
 }
 
-// CalculateRUValues calculates the current TiDB RU from the metrics.
-// The returned value is a scaled integer.
-func (m *RUV2Metrics) CalculateRUValues(weights RUV2Weights) (tidbRU int64) {
+// CalculateRUValues calculates the current TiDB RU from the metrics using the
+// provided weights. The weights specify how each component is weighted in the
+// RU calculation. Returns the calculated TiDB RU as a float64.
+func (m *RUV2Metrics) CalculateRUValues(weights RUV2Weights) (tidbRU float64) {
 	if m == nil {
 		return 0
 	}
 	return m.calculateRUValuesWithWeights(weights)
 }
 
 // TotalRU returns the statement RU v2 total as TiDB + TiKV + TiFlash.
-func (m *RUV2Metrics) TotalRU(weights RUV2Weights, tiKVRU, tiFlashRU int64) int64 {
+func (m *RUV2Metrics) TotalRU(weights RUV2Weights, tiKVRU, tiFlashRU float64) float64 {
 	return m.CalculateRUValues(weights) + tiKVRU + tiFlashRU
 }
 
-func (m *RUV2Metrics) calculateRUValuesWithWeights(weights RUV2Weights) (tidbRU int64) {
+func (m *RUV2Metrics) calculateRUValuesWithWeights(weights RUV2Weights) (tidbRU float64) {
 	tidbRUFloat :=
 		float64(m.ResultChunkCells())*weights.ResultChunkCells +
 			float64(sumRUV2LabelMap(snapshotRUV2LabelCounter(&m.executorL1)))*weights.ExecutorL1 +
@@ -462,8 +463,7 @@ func (m *RUV2Metrics) calculateRUValuesWithWeights(weights RUV2Weights) (tidbRU
 			float64(m.SessionParserTotal())*weights.SessionParserTotal +
 			float64(m.TxnCnt())*weights.TxnCnt
 
-	tidbRU = int64(tidbRUFloat * weights.RUScale)
-	return
+	return tidbRUFloat * weights.RUScale
 }
 
 func sumRUV2LabelMap(values map[string]int64) int64 {
@@ -478,7 +478,7 @@ func sumRUV2LabelMap(values map[string]int64) int64 {
 }
 
 // FormatRUV2Metrics formats RUv2 metrics into a compact string.
-func FormatRUV2Metrics(metrics *RUV2Metrics, weights RUV2Weights, tiKVRU, tiFlashRU int64) string {
+func FormatRUV2Metrics(metrics *RUV2Metrics, weights RUV2Weights, tiKVRU, tiFlashRU float64) string {
 	if (metrics == nil || metrics.IsZero()) && tiKVRU == 0 && tiFlashRU == 0 {
 		return ""
 	}
@@ -528,8 +528,8 @@ func FormatRUV2Metrics(metrics *RUV2Metrics, weights RUV2Weights, tiKVRU, tiFlas
 			parts = append(parts, fmt.Sprintf("%s:%d", key, value))
 		}
 	}
-	appendIntAlways := func(key string, value int64) {
-		parts = append(parts, fmt.Sprintf("%s:%d", key, value))
+	appendFloat64Always := func(key string, value float64) {
+		parts = append(parts, fmt.Sprintf("%s:%.2f", key, value))
 	}
 	appendMap := func(key string, value map[string]int64) {
 		if len(value) == 0 {
@@ -543,10 +543,10 @@ func FormatRUV2Metrics(metrics *RUV2Metrics, weights RUV2Weights, tiKVRU, tiFlas
 
 	tidbRU := metrics.CalculateRUValues(weights)
 	totalRU := metrics.TotalRU(weights, tiKVRU, tiFlashRU)
-	appendIntAlways("total_ru", totalRU)
-	appendIntAlways("tidb_ru", tidbRU)
-	appendIntAlways("tikv_ru", tiKVRU)
-	appendIntAlways("tiflash_ru", tiFlashRU)
+	appendFloat64Always("total_ru", totalRU)
+	appendFloat64Always("tidb_ru", tidbRU)
+	appendFloat64Always("tikv_ru", tiKVRU)
+	appendFloat64Always("tiflash_ru", tiFlashRU)
 
 	appendInt("result_chunk_cells", resultChunkCells)
 	appendMap("executor_l1", executorL1)
diff --git a/pkg/util/stmtsummary/reader.go b/pkg/util/stmtsummary/reader.go
@@ -366,6 +366,8 @@ const (
 	MaxRequestUnitWriteStr                     = "MAX_REQUEST_UNIT_WRITE"
 	AvgQueuedRcTimeStr                         = "AVG_QUEUED_RC_TIME"
 	MaxQueuedRcTimeStr                         = "MAX_QUEUED_RC_TIME"
+	AvgRequestUnitV2Str                        = "AVG_REQUEST_UNIT_V2"
+	MaxRequestUnitV2Str                        = "MAX_REQUEST_UNIT_V2"
 	ResourceGroupName                          = "RESOURCE_GROUP"
 	SumUnpackedBytesSentTiKVTotalStr           = "SUM_UNPACKED_BYTES_SENT_TIKV_TOTAL"
 	SumUnpackedBytesReceivedTiKVTotalStr       = "SUM_UNPACKED_BYTES_RECEIVED_TIKV_TOTAL"
@@ -917,6 +919,12 @@ var columnValueFactoryMap = map[string]columnValueFactory{
 	MaxQueuedRcTimeStr: func(_ *stmtSummaryReader, _ *stmtSummaryByDigestElement, _ *stmtSummaryByDigest, ssStats *stmtSummaryStats) any {
 		return int64(ssStats.MaxRUWaitDuration)
 	},
+	AvgRequestUnitV2Str: func(_ *stmtSummaryReader, _ *stmtSummaryByDigestElement, _ *stmtSummaryByDigest, ssStats *stmtSummaryStats) any {
+		return avgSumFloat(ssStats.SumRUV2, ssStats.execCount)
+	},
+	MaxRequestUnitV2Str: func(_ *stmtSummaryReader, _ *stmtSummaryByDigestElement, _ *stmtSummaryByDigest, ssStats *stmtSummaryStats) any {
+		return ssStats.MaxRUV2
+	},
 	ResourceGroupName: func(_ *stmtSummaryReader, _ *stmtSummaryByDigestElement, _ *stmtSummaryByDigest, ssStats *stmtSummaryStats) any {
 		return ssStats.resourceGroupName
 	},
diff --git a/pkg/util/stmtsummary/statement_summary.go b/pkg/util/stmtsummary/statement_summary.go
@@ -285,6 +285,7 @@ type StmtExecInfo struct {
 	KeyspaceID        uint32
 	ResourceGroupName string
 	RUDetail          *util.RUDetails
+	TotalRUV2         float64
 	CPUUsages         ppcpuusage.CPUUsages
 
 	PlanCacheUnqualified string
@@ -942,7 +943,7 @@ func (ssStats *stmtSummaryStats) add(sei *StmtExecInfo, warningCount int, affect
 	ssStats.StmtNetworkTrafficSummary.Add(sei.TiKVExecDetails)
 
 	// request-units
-	ssStats.StmtRUSummary.Add(sei.RUDetail)
+	ssStats.StmtRUSummary.Add(sei.RUDetail, sei.TotalRUV2)
 
 	ssStats.storageKV = sei.StmtCtx.IsTiKV.Load()
 	ssStats.storageMPP = sei.StmtCtx.IsTiFlash.Load()
@@ -1038,10 +1039,12 @@ type StmtRUSummary struct {
 	MaxRRU            float64       `json:"max_rru"`
 	MaxWRU            float64       `json:"max_wru"`
 	MaxRUWaitDuration time.Duration `json:"max_ru_wait_duration"`
+	SumRUV2           float64       `json:"sum_ruv2"`
+	MaxRUV2           float64       `json:"max_ruv2"`
 }
 
 // Add add a new sample value to the ru summary record.
-func (s *StmtRUSummary) Add(info *util.RUDetails) {
+func (s *StmtRUSummary) Add(info *util.RUDetails, totalRUV2 float64) {
 	if info != nil {
 		rru := info.RRU()
 		s.SumRRU += rru
@@ -1059,6 +1062,10 @@ func (s *StmtRUSummary) Add(info *util.RUDetails) {
 			s.MaxRUWaitDuration = ruWaitDur
 		}
 	}
+	s.SumRUV2 += totalRUV2
+	if s.MaxRUV2 < totalRUV2 {
+		s.MaxRUV2 = totalRUV2
+	}
 }
 
 // Merge merges the value of 2 ru summary records.
@@ -1075,6 +1082,10 @@ func (s *StmtRUSummary) Merge(other *StmtRUSummary) {
 	if s.MaxRUWaitDuration < other.MaxRUWaitDuration {
 		s.MaxRUWaitDuration = other.MaxRUWaitDuration
 	}
+	s.SumRUV2 += other.SumRUV2
+	if s.MaxRUV2 < other.MaxRUV2 {
+		s.MaxRUV2 = other.MaxRUV2
+	}
 }
 
 // StmtNetworkTrafficSummary is the network traffic summary for each type of statements.
diff --git a/pkg/util/stmtsummary/statement_summary_test.go b/pkg/util/stmtsummary/statement_summary_test.go
@@ -155,6 +155,8 @@ func TestAddStatement(t *testing.T) {
 				MaxWRU:            stmtExecInfo1.RUDetail.WRU(),
 				SumRUWaitDuration: stmtExecInfo1.RUDetail.RUWaitDuration(),
 				MaxRUWaitDuration: stmtExecInfo1.RUDetail.RUWaitDuration(),
+				SumRUV2:           stmtExecInfo1.TotalRUV2,
+				MaxRUV2:           stmtExecInfo1.TotalRUV2,
 			},
 			resourceGroupName: stmtExecInfo1.ResourceGroupName,
 			StmtNetworkTrafficSummary: StmtNetworkTrafficSummary{
@@ -262,6 +264,7 @@ func TestAddStatement(t *testing.T) {
 		StartTime: time.Date(2019, 1, 1, 10, 10, 20, 10, time.UTC),
 		Succeed:   true,
 		RUDetail:  util.NewRUDetailsWith(123.0, 45.6, 2*time.Second),
+		TotalRUV2: 34567,
 		TiKVExecDetails: &util.ExecDetails{
 			TrafficDetails: util.TrafficDetails{
 				UnpackedBytesSentKVTotal:     100,
@@ -343,6 +346,8 @@ func TestAddStatement(t *testing.T) {
 	expectedSummaryElement.MaxWRU = stmtExecInfo2.RUDetail.WRU()
 	expectedSummaryElement.SumRUWaitDuration += stmtExecInfo2.RUDetail.RUWaitDuration()
 	expectedSummaryElement.MaxRUWaitDuration = stmtExecInfo2.RUDetail.RUWaitDuration()
+	expectedSummaryElement.SumRUV2 += stmtExecInfo2.TotalRUV2
+	expectedSummaryElement.MaxRUV2 = stmtExecInfo2.TotalRUV2
 	expectedSummaryElement.StmtNetworkTrafficSummary.Add(stmtExecInfo2.TiKVExecDetails)
 	expectedSummaryElement.storageKV = stmtExecInfo2.StmtCtx.IsTiKV.Load()
 	expectedSummaryElement.storageMPP = stmtExecInfo2.StmtCtx.IsTiFlash.Load()
@@ -425,6 +430,7 @@ func TestAddStatement(t *testing.T) {
 		StartTime:         time.Date(2019, 1, 1, 10, 10, 0, 10, time.UTC),
 		Succeed:           true,
 		RUDetail:          util.NewRUDetailsWith(0.12, 0.34, 5*time.Microsecond),
+		TotalRUV2:         123,
 		ResourceGroupName: "rg1",
 		TiKVExecDetails: &util.ExecDetails{
 			TrafficDetails: util.TrafficDetails{
@@ -481,6 +487,7 @@ func TestAddStatement(t *testing.T) {
 	expectedSummaryElement.SumRRU += stmtExecInfo3.RUDetail.RRU()
 	expectedSummaryElement.SumWRU += stmtExecInfo3.RUDetail.WRU()
 	expectedSummaryElement.SumRUWaitDuration += stmtExecInfo3.RUDetail.RUWaitDuration()
+	expectedSummaryElement.SumRUV2 += stmtExecInfo3.TotalRUV2
 	expectedSummaryElement.StmtNetworkTrafficSummary.Add(stmtExecInfo3.TiKVExecDetails)
 	expectedSummaryElement.storageKV = stmtExecInfo3.StmtCtx.IsTiKV.Load()
 	expectedSummaryElement.storageMPP = stmtExecInfo3.StmtCtx.IsTiFlash.Load()
@@ -753,6 +760,7 @@ func generateAnyExecInfo() *StmtExecInfo {
 		Succeed:           true,
 		ResourceGroupName: "rg1",
 		RUDetail:          util.NewRUDetailsWith(1.1, 2.5, 2*time.Millisecond),
+		TotalRUV2:         23456,
 		CPUUsages:         ppcpuusage.CPUUsages{TidbCPUTime: time.Duration(20), TikvCPUTime: time.Duration(100)},
 		TiKVExecDetails: &util.ExecDetails{
 			TrafficDetails: util.TrafficDetails{
@@ -910,6 +918,8 @@ func newStmtSummaryReaderForTest(ssMap *stmtSummaryByDigestMap) *stmtSummaryRead
 		MaxRequestUnitWriteStr,
 		AvgQueuedRcTimeStr,
 		MaxQueuedRcTimeStr,
+		AvgRequestUnitV2Str,
+		MaxRequestUnitV2Str,
 		ResourceGroupName,
 		AvgTidbCPUTimeStr,
 		AvgTikvCPUTimeStr,
@@ -983,6 +993,7 @@ func TestToDatum(t *testing.T) {
 		0, 0, 0, 0, 0, 0, 0, 0, stmtExecInfo1.StmtCtx.AffectedRows(),
 		f, f, 0, 0, 0, stmtExecInfo1.LazyInfo.GetOriginalSQL(), stmtExecInfo1.PrevSQL, "plan_digest", "", stmtExecInfo1.RUDetail.RRU(), stmtExecInfo1.RUDetail.RRU(),
 		stmtExecInfo1.RUDetail.WRU(), stmtExecInfo1.RUDetail.WRU(), int64(stmtExecInfo1.RUDetail.RUWaitDuration()), int64(stmtExecInfo1.RUDetail.RUWaitDuration()),
+		stmtExecInfo1.TotalRUV2, stmtExecInfo1.TotalRUV2,
 		stmtExecInfo1.ResourceGroupName, int64(stmtExecInfo1.CPUUsages.TidbCPUTime), int64(stmtExecInfo1.CPUUsages.TikvCPUTime),
 		isTiKV, isTiFlash}
 	stmtExecInfo1.ExecDetail.CommitDetail.Mu.Unlock()
@@ -1034,6 +1045,7 @@ func TestToDatum(t *testing.T) {
 		0, 0, 0, 0, 0, 0, 0, 0, stmtExecInfo1.StmtCtx.AffectedRows(),
 		f, f, 0, 0, 0, "", "", "", "", stmtExecInfo1.RUDetail.RRU(), stmtExecInfo1.RUDetail.RRU(),
 		stmtExecInfo1.RUDetail.WRU(), stmtExecInfo1.RUDetail.WRU(), int64(stmtExecInfo1.RUDetail.RUWaitDuration()), int64(stmtExecInfo1.RUDetail.RUWaitDuration()),
+		stmtExecInfo1.TotalRUV2, stmtExecInfo1.TotalRUV2,
 		stmtExecInfo1.ResourceGroupName, int64(stmtExecInfo1.CPUUsages.TidbCPUTime), int64(stmtExecInfo1.CPUUsages.TikvCPUTime),
 		0, 0}
 	expectedDatum[4] = stmtExecInfo2.Digest
diff --git a/pkg/util/stmtsummary/v2/column.go b/pkg/util/stmtsummary/v2/column.go
diff --git a/pkg/util/stmtsummary/v2/record.go b/pkg/util/stmtsummary/v2/record.go
diff --git a/pkg/util/stmtsummary/v2/record_test.go b/pkg/util/stmtsummary/v2/record_test.go

Original file line number	Diff line number	Diff line change
`@@ -494,7 +494,7 @@ func TestFinishExecuteStmtReportsTiDBRUV2WithoutSyncingRUDetails(t *testing.T) {`
`494`	`494`	`require.Equal(t, "rg1", reporter.tikvGroup)`
`495`	`495`	`require.Equal(t, float64(23456), reporter.tikvRUV2)`
`496`	`496`	`require.Equal(t, "rg1", reporter.tidbGroup)`
`497`		`- require.Equal(t, float64(expected), reporter.tidbRUV2)`
	`497`	`+ require.Equal(t, expected, reporter.tidbRUV2)`
`498`	`498`	`}`
`499`	`499`
`500`	`500`	`func TestSlowLogMaxPerSec(t *testing.T) {`
Original file line number	Diff line number	Diff line change
`@@ -146,7 +146,7 @@ func TestExplainAnalyzeInvokeNextAndClose(t *testing.T) {`
`146`	`146`	`require.Contains(`
`147`	`147`	`t,`
`148`	`148`	`ctx.GetSessionVars().StmtCtx.RuntimeStatsColl.GetRootStats(targetPlan.ID()).String(),`
`149`		`- fmt.Sprintf("RU:%.2f", float64(metrics.TotalRU(weights, 0, 0))),`
	`149`	`+ fmt.Sprintf("RU:%.2f", metrics.TotalRU(weights, 0, 0)),`
`150`	`150`	`)`
`151`	`151`
`152`	`152`	`recordInsertRows2Metrics(ctx.GetSessionVars())`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ type CursorRUV2Tracker struct {`
`73`	`73`	`ruDetails *clientutil.RUDetails`
`74`	`74`	`resourceGroupName string`
`75`	`75`	`weights execdetails.RUV2Weights`
`76`		`- reportedTiDBRU int64`
	`76`	`+ reportedTiDBRU float64`
`77`	`77`	`reportedTiKVRUV2 float64`
`78`	`78`	`mu sync.Mutex`
`79`	`79`	`}`
`@@ -119,7 +119,7 @@ func (t *CursorRUV2Tracker) reportDelta() {`
`119`	`119`	`t.mu.Lock()`
`120`	`120`	`defer t.mu.Unlock()`
`121`	`121`
`122`		`- var currentTiDBRU int64`
	`122`	`+ var currentTiDBRU float64`
`123`	`123`	`if t.metrics != nil {`
`124`	`124`	`currentTiDBRU = t.metrics.CalculateRUValues(t.weights)`
`125`	`125`	`}`
`@@ -133,7 +133,7 @@ func (t *CursorRUV2Tracker) reportDelta() {`
`133`	`133`	`t.reporter.ReportTiKVRUV2Consumption(t.resourceGroupName, deltaTiKVRUV2)`
`134`	`134`	`}`
`135`	`135`	`if deltaTiDBRU := currentTiDBRU - t.reportedTiDBRU; deltaTiDBRU > 0 {`
`136`		`- t.reporter.ReportTiDBRUV2Consumption(t.resourceGroupName, float64(deltaTiDBRU))`
	`136`	`+ t.reporter.ReportTiDBRUV2Consumption(t.resourceGroupName, deltaTiDBRU)`
`137`	`137`	`}`
`138`	`138`	`}`
`139`	`139`
Original file line number	Diff line number	Diff line change
`@@ -555,10 +555,10 @@ func (s SessionVars) SlowLogFormat(logItems SlowQueryLogItems) string {`
`555`	`555`	`}`
`556`	`556`	`writeSlowLogItem(&buf, SlowLogStorageFromKV, strconv.FormatBool(logItems.StorageKV))`
`557`	`557`	`writeSlowLogItem(&buf, SlowLogStorageFromMPP, strconv.FormatBool(logItems.StorageMPP))`
`558`		`- var tiKVRU, tiFlashRU int64`
	`558`	`+ var tiKVRU, tiFlashRU float64`
`559`	`559`	`if logItems.RUDetails != nil {`
`560`		`- tiKVRU = int64(logItems.RUDetails.TiKVRUV2())`
`561`		`- tiFlashRU = int64(logItems.RUDetails.TiflashRU())`
	`560`	`+ tiKVRU = logItems.RUDetails.TiKVRUV2()`
	`561`	`+ tiFlashRU = logItems.RUDetails.TiflashRU()`
`562`	`562`	`}`
`563`	`563`	`if formatted := execdetails.FormatRUV2Metrics(logItems.RUV2Metrics, s.RUV2Weights(), tiKVRU, tiFlashRU); len(formatted) > 0 {`
`564`	`564`	`writeSlowLogItem(&buf, SlowLogRUV2Metrics, formatted)`
Original file line number	Diff line number	Diff line change
`@@ -1000,18 +1000,18 @@ func (e *RURuntimeStats) String() string {`
`1000`	`1000`	`return buf.String()`
`1001`	`1001`	`}`
`1002`	`1002`	`case "v2":`
`1003`		`- var tiKVRU, tiFlashRU int64`
	`1003`	`+ var tiKVRU, tiFlashRU float64`
`1004`	`1004`	`if e.RUDetails != nil {`
`1005`		`- tiKVRU = int64(e.RUDetails.TiKVRUV2())`
`1006`		`- tiFlashRU = int64(e.RUDetails.TiflashRU())`
	`1005`	`+ tiKVRU = e.RUDetails.TiKVRUV2()`
	`1006`	`+ tiFlashRU = e.RUDetails.TiflashRU()`
`1007`	`1007`	`}`
`1008`	`1008`	`totalRU := e.Metrics.TotalRU(e.Weights, tiKVRU, tiFlashRU)`
`1009`	`1009`	`if totalRU == 0 {`
`1010`	`1010`	`return ""`
`1011`	`1011`	`}`
`1012`	`1012`	`buf := bytes.NewBuffer(make([]byte, 0, 8))`
`1013`	`1013`	`buf.WriteString("RU:")`
`1014`		`- buf.WriteString(strconv.FormatFloat(float64(totalRU), 'f', 2, 64))`
	`1014`	`+ buf.WriteString(strconv.FormatFloat(totalRU, 'f', 2, 64))`
`1015`	`1015`	`return buf.String()`
`1016`	`1016`	`}`
`1017`	`1017`	`return ""`