Rename and fix tablet metadata size columns

Rename active_ssts_size/wals_size to active_sst_sizes/wal_sizes across
proto, pggate, catalog manager, system views, and migration. Use uint64
datums instead of CString to match the bigint[] column type.

Make the migration resilient to OID changes by looking up
yb_get_tablet_metadata by name instead of hardcoded OID.

Move size column validation from C++ mini-test to pg_regress, covering
array alignment, non-negative sizes, and replica-tserver correspondence.

Author: keisku

docs/content/stable/explore/observability/yb-tablet-metadata.md

@@ -37,6 +37,8 @@ The following table describes the columns of the `yb_tablet_metadata` view.
 | end_hash_code | int | Ending hash code (exclusive) for the tablet. (NULL for range-sharded tables.) |
 | leader | text | IP address, port of the leader node for the tablet. |
 | replicas | text[] | A list of replica IP addresses and port (includes leader) associated with the tablet. |
+| active_ssts_size | bigint[] | Per-replica SST files size in bytes, in the same order as replicas. |
+| wals_size | bigint[] | Per-replica WAL files size in bytes, in the same order as replicas. |
 
 ## Examples
 
@@ -268,4 +270,3 @@ SELECT
 | 99ed7472ccde4af787cb0bcfd4fd90bd | yugabyte | test_table       | 0               | 32768         | RocksDB_NewIterator                | TServer              | DiskIO          | 1     |
 +----------------------------------+----------+------------------+-----------------+---------------+------------------------------------+----------------------+-----------------+-------+
 ```
-

src/postgres/src/backend/catalog/yb_system_views.sql

@@ -68,8 +68,8 @@ CREATE VIEW yb_tablet_metadata AS
         t.end_hash_code,
         t.leader,
         t.replicas,
-        t.active_ssts_size,
-        t.wals_size
+        t.active_sst_sizes,
+        t.wal_sizes
     FROM
         yb_get_tablet_metadata() t
     LEFT JOIN

src/postgres/src/backend/utils/misc/pg_yb_utils.c

@@ -8419,8 +8419,8 @@ replica_index_cmp(const void *a, const void *b, void *arg)
  * - end_hash_code: int32
  * - leader: text
  * - replicas: text[]
- * - active_ssts_size: int8[]
- * - wals_size: int8[]
+ * - active_sst_sizes: int8[]
+ * - wal_sizes: int8[]
  *
  * The start_hash_code and end_hash_code are the hash codes of the start and end
  * keys of the tablet for hash sharded tables. Leader is provided as a separate
@@ -8508,7 +8508,7 @@ yb_get_tablet_metadata(PG_FUNCTION_ARGS)
 		if (tablet->replicas_count > 0)
 		{
 			size_t		nreplicas = tablet->replicas_count;
-			int		   *sort_idx;
+			int		   *sort_idxs;
 			Datum	   *text_elems;
 			Datum	   *sst_elems;
 			Datum	   *wal_elems;
@@ -8522,11 +8522,11 @@ yb_get_tablet_metadata(PG_FUNCTION_ARGS)
 			 * Build a sort index so replicas and their sizes stay parallel
 			 * after lexicographic sorting.
 			 */
-			sort_idx = palloc(nreplicas * sizeof(int));
+			sort_idxs = palloc(nreplicas * sizeof(int));
 			for (size_t idx = 0; idx < nreplicas; idx++)
-				sort_idx[idx] = (int) idx;
+				sort_idxs[idx] = (int) idx;
 
-			qsort_arg(sort_idx, nreplicas, sizeof(int),
+			qsort_arg(sort_idxs, nreplicas, sizeof(int),
 					  replica_index_cmp, tablet->replicas);
 
 			text_elems = palloc(nreplicas * sizeof(Datum));
@@ -8535,15 +8535,15 @@ yb_get_tablet_metadata(PG_FUNCTION_ARGS)
 
 			for (size_t idx = 0; idx < nreplicas; idx++)
 			{
-				int			si = sort_idx[idx];
+				int			si = sort_idxs[idx];
 
 				text_elems[idx] = CStringGetTextDatum(tablet->replicas[si]);
-				sst_elems[idx] = Int64GetDatum(
-					tablet->replicas_sst_files_size
-						? (int64) tablet->replicas_sst_files_size[si] : 0);
-				wal_elems[idx] = Int64GetDatum(
-					tablet->replicas_wal_files_size
-						? (int64) tablet->replicas_wal_files_size[si] : 0);
+				sst_elems[idx] = UInt64GetDatum(
+					tablet->replica_sst_sizes
+						? tablet->replica_sst_sizes[si] : 0);
+				wal_elems[idx] = UInt64GetDatum(
+					tablet->replica_wal_sizes
+						? tablet->replica_wal_sizes[si] : 0);
 			}
 
 			values[8] = PointerGetDatum(
@@ -8556,7 +8556,7 @@ yb_get_tablet_metadata(PG_FUNCTION_ARGS)
 				construct_array(wal_elems, (int) nreplicas,
 								INT8OID, 8, FLOAT8PASSBYVAL, TYPALIGN_DOUBLE));
 
-			pfree(sort_idx);
+			pfree(sort_idxs);
 			pfree(text_elems);
 			pfree(sst_elems);
 			pfree(wal_elems);

src/postgres/src/include/catalog/pg_proc.dat

@@ -12235,7 +12235,7 @@
   proretset => 't', provolatile => 'v', proparallel => 'r',
   prorettype => 'record', proargtypes => '',
   proallargtypes => '{text,text,text,text,text,int4,int4,text,_text,_int8,_int8}',
-  proargnames => '{tablet_id,object_uuid,namespace,object_name,type,start_hash_code,end_hash_code,leader,replicas,active_ssts_size,wals_size}',
+  proargnames => '{tablet_id,object_uuid,namespace,object_name,type,start_hash_code,end_hash_code,leader,replicas,active_sst_sizes,wal_sizes}',
   proargmodes => '{o,o,o,o,o,o,o,o,o,o,o}',
   prosrc => 'yb_get_tablet_metadata'},
 

src/postgres/src/test/regress/expected/yb.orig.tablet_metadata.out

@@ -15,6 +15,45 @@ ORDER BY start_hash_code NULLS FIRST;
  test_table_1 | yugabyte |           32768 |         65536
 (3 rows)
 
+-- Test that active_sst_sizes and wal_sizes columns are present and aligned with replicas
+SELECT
+    relname,
+    pg_typeof(active_sst_sizes) AS sst_type,
+    pg_typeof(wal_sizes) AS wal_type,
+    array_length(active_sst_sizes, 1) = array_length(replicas, 1) AS sst_match,
+    array_length(wal_sizes, 1) = array_length(replicas, 1) AS wal_match
+FROM yb_tablet_metadata
+WHERE relname = 'test_table_1'
+ORDER BY start_hash_code NULLS FIRST
+LIMIT 1;
+   relname    | sst_type | wal_type | sst_match | wal_match 
+--------------+----------+----------+-----------+-----------
+ test_table_1 | bigint[] | bigint[] | t         | t
+(1 row)
+
+-- Test that all size values are non-negative for each replica
+SELECT r.val AS replica, s.val AS sst_size, w.val AS wal_size
+FROM yb_tablet_metadata tm,
+     unnest(tm.replicas)         WITH ORDINALITY AS r(val, ord),
+     unnest(tm.active_sst_sizes) WITH ORDINALITY AS s(val, ord),
+     unnest(tm.wal_sizes)        WITH ORDINALITY AS w(val, ord)
+WHERE tm.relname = 'test_table_1'
+  AND r.ord = s.ord AND r.ord = w.ord
+  AND (s.val < 0 OR w.val < 0);
+ replica | sst_size | wal_size 
+---------+----------+----------
+(0 rows)
+
+-- Test that every replica address corresponds to a live tserver
+SELECT unnest(replicas) AS orphan_replica
+FROM yb_tablet_metadata
+WHERE relname = 'test_table_1'
+EXCEPT
+SELECT host || ':' || port FROM yb_servers();
+ orphan_replica 
+----------------
+(0 rows)
+
 -- Test that we are able to join with yb_servers()
 SELECT
     ytm.relname,

src/postgres/src/test/regress/sql/yb.orig.tablet_metadata.sql

@@ -10,6 +10,35 @@ SELECT
 FROM yb_tablet_metadata WHERE relname IN ('test_table_1', 'test_table_2')
 ORDER BY start_hash_code NULLS FIRST;
 
+-- Test that active_sst_sizes and wal_sizes columns are present and aligned with replicas
+SELECT
+    relname,
+    pg_typeof(active_sst_sizes) AS sst_type,
+    pg_typeof(wal_sizes) AS wal_type,
+    array_length(active_sst_sizes, 1) = array_length(replicas, 1) AS sst_match,
+    array_length(wal_sizes, 1) = array_length(replicas, 1) AS wal_match
+FROM yb_tablet_metadata
+WHERE relname = 'test_table_1'
+ORDER BY start_hash_code NULLS FIRST
+LIMIT 1;
+
+-- Test that all size values are non-negative for each replica
+SELECT r.val AS replica, s.val AS sst_size, w.val AS wal_size
+FROM yb_tablet_metadata tm,
+     unnest(tm.replicas)         WITH ORDINALITY AS r(val, ord),
+     unnest(tm.active_sst_sizes) WITH ORDINALITY AS s(val, ord),
+     unnest(tm.wal_sizes)        WITH ORDINALITY AS w(val, ord)
+WHERE tm.relname = 'test_table_1'
+  AND r.ord = s.ord AND r.ord = w.ord
+  AND (s.val < 0 OR w.val < 0);
+
+-- Test that every replica address corresponds to a live tserver
+SELECT unnest(replicas) AS orphan_replica
+FROM yb_tablet_metadata
+WHERE relname = 'test_table_1'
+EXCEPT
+SELECT host || ':' || port FROM yb_servers();
+
 -- Test that we are able to join with yb_servers()
 SELECT
     ytm.relname,

src/yb/master/catalog_manager.cc

@@ -14301,17 +14301,17 @@ Status CatalogManager::GetTabletsMetadata(const GetTabletsMetadataRequestPB* req
             leader_wal_files_size = replica.drive_info.wal_files_size;
           } else {
             tablet_metadata->add_replicas(server_address);
-            tablet_metadata->add_replicas_sst_files_size(replica.drive_info.sst_files_size);
-            tablet_metadata->add_replicas_wal_files_size(replica.drive_info.wal_files_size);
+            tablet_metadata->add_replica_sst_sizes(replica.drive_info.sst_files_size);
+            tablet_metadata->add_replica_wal_sizes(replica.drive_info.wal_files_size);
           }
         }
       }
 
       // Add leader as the last replica
       if (!leader_address.empty()) {
         tablet_metadata->add_replicas(leader_address);
-        tablet_metadata->add_replicas_sst_files_size(leader_sst_files_size);
-        tablet_metadata->add_replicas_wal_files_size(leader_wal_files_size);
+        tablet_metadata->add_replica_sst_sizes(leader_sst_files_size);
+        tablet_metadata->add_replica_wal_sizes(leader_wal_files_size);
       }
 
       // last_status is a required field in the PB

src/yb/tablet/tablet.proto

@@ -77,8 +77,8 @@ message TabletStatusPB {
   repeated string replicas = 24;
   optional bool is_hash_partitioned = 25;
   // Per-replica SST and WAL sizes in bytes, parallel to the replicas array.
-  repeated uint64 replicas_sst_files_size = 26;
-  repeated uint64 replicas_wal_files_size = 27;
+  repeated uint64 replica_sst_sizes = 26;
+  repeated uint64 replica_wal_sizes = 27;
 }
 
 // Used to present the maintenance manager's internal state.

src/yb/yql/pggate/ybc_pg_typedefs.h

@@ -854,8 +854,8 @@ typedef struct {
   const char** replicas;
   size_t replicas_count;
   bool is_hash_partitioned;
-  uint64_t* replicas_sst_files_size;
-  uint64_t* replicas_wal_files_size;
+  const uint64_t* replica_sst_sizes;
+  const uint64_t* replica_wal_sizes;
 } YbcPgGlobalTabletsDescriptor;
 
 typedef struct {

src/yb/yql/pggate/ybc_pggate.cc

@@ -2994,36 +2994,36 @@ YbcStatus YBCTabletsMetadata(YbcPgGlobalTabletsDescriptor** tablets, size_t* cou
       const char** replicas_array = nullptr;
       uint64_t* sst_sizes_array = nullptr;
       uint64_t* wal_sizes_array = nullptr;
-      const auto replicas_size = tablet_metadata.replicas().size();
+      const auto replicas_count = tablet_metadata.replicas().size();
 
-      if (replicas_size > 0) {
+      if (replicas_count > 0) {
         replicas_array = static_cast<const char**>(
-            YBCPAlloc(replicas_size * sizeof(const char*)));
+            YBCPAlloc(replicas_count * sizeof(const char*)));
 
-        for (int i = 0; i < static_cast<int>(replicas_size); ++i) {
+        for (int i = 0; i < static_cast<int>(replicas_count); ++i) {
           replicas_array[i] = YBCPAllocStdString(tablet_metadata.replicas(i));
         }
 
         sst_sizes_array = static_cast<uint64_t*>(
-            YBCPAlloc(replicas_size * sizeof(uint64_t)));
+            YBCPAlloc(replicas_count * sizeof(uint64_t)));
         wal_sizes_array = static_cast<uint64_t*>(
-            YBCPAlloc(replicas_size * sizeof(uint64_t)));
+            YBCPAlloc(replicas_count * sizeof(uint64_t)));
 
-        for (int i = 0; i < static_cast<int>(replicas_size); ++i) {
-          sst_sizes_array[i] = i < tablet_metadata.replicas_sst_files_size_size()
-              ? tablet_metadata.replicas_sst_files_size(i) : 0;
-          wal_sizes_array[i] = i < tablet_metadata.replicas_wal_files_size_size()
-              ? tablet_metadata.replicas_wal_files_size(i) : 0;
+        for (int i = 0; i < static_cast<int>(replicas_count); ++i) {
+          sst_sizes_array[i] = i < tablet_metadata.replica_sst_sizes_size()
+              ? tablet_metadata.replica_sst_sizes(i) : 0;
+          wal_sizes_array[i] = i < tablet_metadata.replica_wal_sizes_size()
+              ? tablet_metadata.replica_wal_sizes(i) : 0;
         }
       }
 
       new (dest) YbcPgGlobalTabletsDescriptor {
         .tablet_descriptor = MakeYbcPgTabletsDescriptor(tablet_metadata),
         .replicas = replicas_array,
-        .replicas_count = static_cast<size_t>(replicas_size),
+        .replicas_count = static_cast<size_t>(replicas_count),
         .is_hash_partitioned = tablet_metadata.is_hash_partitioned(),
-        .replicas_sst_files_size = sst_sizes_array,
-        .replicas_wal_files_size = wal_sizes_array
+        .replica_sst_sizes = sst_sizes_array,
+        .replica_wal_sizes = wal_sizes_array
       };
       ++dest;
     }