YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

// THIS FILE IS AUTOGENERATED FROM yb/tserver/pg_client.proto

#include "yb/tserver/pg_client.pb.h"

#include "yb/tserver/pg_client.service.h"

#include <glog/logging.h>

#include "yb/rpc/inbound_call.h"

#include "yb/rpc/local_call.h"

#include "yb/rpc/remote_method.h"

#include "yb/rpc/rpc_context.h"

#include "yb/rpc/rpc_service.h"

#include "yb/rpc/service_if.h"

#include "yb/util/metrics.h"

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_Heartbeat,

  "Bytes received by yb.tserver.PgClientService.Heartbeat() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.Heartbeat() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_Heartbeat,

  "Bytes sent in response to yb.tserver.PgClientService.Heartbeat() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.Heartbeat() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_Heartbeat,

  "Microseconds spent handling yb.tserver.PgClientService.Heartbeat() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.Heartbeat() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_AlterDatabase,

  "Bytes received by yb.tserver.PgClientService.AlterDatabase() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.AlterDatabase() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_AlterDatabase,

  "Bytes sent in response to yb.tserver.PgClientService.AlterDatabase() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.AlterDatabase() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_AlterDatabase,

  "Microseconds spent handling yb.tserver.PgClientService.AlterDatabase() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.AlterDatabase() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_AlterTable,

  "Bytes received by yb.tserver.PgClientService.AlterTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.AlterTable() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_AlterTable,

  "Bytes sent in response to yb.tserver.PgClientService.AlterTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.AlterTable() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_AlterTable,

  "Microseconds spent handling yb.tserver.PgClientService.AlterTable() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.AlterTable() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_BackfillIndex,

  "Bytes received by yb.tserver.PgClientService.BackfillIndex() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.BackfillIndex() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_BackfillIndex,

  "Bytes sent in response to yb.tserver.PgClientService.BackfillIndex() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.BackfillIndex() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_BackfillIndex,

  "Microseconds spent handling yb.tserver.PgClientService.BackfillIndex() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.BackfillIndex() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_CreateDatabase,

  "Bytes received by yb.tserver.PgClientService.CreateDatabase() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.CreateDatabase() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_CreateDatabase,

  "Bytes sent in response to yb.tserver.PgClientService.CreateDatabase() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.CreateDatabase() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_CreateDatabase,

  "Microseconds spent handling yb.tserver.PgClientService.CreateDatabase() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.CreateDatabase() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_CreateSequencesDataTable,

  "Bytes received by yb.tserver.PgClientService.CreateSequencesDataTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.CreateSequencesDataTable() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_CreateSequencesDataTable,

  "Bytes sent in response to yb.tserver.PgClientService.CreateSequencesDataTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.CreateSequencesDataTable() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_CreateSequencesDataTable,

  "Microseconds spent handling yb.tserver.PgClientService.CreateSequencesDataTable() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.CreateSequencesDataTable() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_CreateTable,

  "Bytes received by yb.tserver.PgClientService.CreateTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.CreateTable() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_CreateTable,

  "Bytes sent in response to yb.tserver.PgClientService.CreateTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.CreateTable() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_CreateTable,

  "Microseconds spent handling yb.tserver.PgClientService.CreateTable() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.CreateTable() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_CreateTablegroup,

  "Bytes received by yb.tserver.PgClientService.CreateTablegroup() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.CreateTablegroup() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_CreateTablegroup,

  "Bytes sent in response to yb.tserver.PgClientService.CreateTablegroup() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.CreateTablegroup() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_CreateTablegroup,

  "Microseconds spent handling yb.tserver.PgClientService.CreateTablegroup() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.CreateTablegroup() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_DropDatabase,

  "Bytes received by yb.tserver.PgClientService.DropDatabase() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.DropDatabase() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_DropDatabase,

  "Bytes sent in response to yb.tserver.PgClientService.DropDatabase() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.DropDatabase() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_DropDatabase,

  "Microseconds spent handling yb.tserver.PgClientService.DropDatabase() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.DropDatabase() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_DropTable,

  "Bytes received by yb.tserver.PgClientService.DropTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.DropTable() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_DropTable,

  "Bytes sent in response to yb.tserver.PgClientService.DropTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.DropTable() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_DropTable,

  "Microseconds spent handling yb.tserver.PgClientService.DropTable() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.DropTable() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_DropTablegroup,

  "Bytes received by yb.tserver.PgClientService.DropTablegroup() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.DropTablegroup() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_DropTablegroup,

  "Bytes sent in response to yb.tserver.PgClientService.DropTablegroup() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.DropTablegroup() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_DropTablegroup,

  "Microseconds spent handling yb.tserver.PgClientService.DropTablegroup() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.DropTablegroup() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_FinishTransaction,

  "Bytes received by yb.tserver.PgClientService.FinishTransaction() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.FinishTransaction() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_FinishTransaction,

  "Bytes sent in response to yb.tserver.PgClientService.FinishTransaction() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.FinishTransaction() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_FinishTransaction,

  "Microseconds spent handling yb.tserver.PgClientService.FinishTransaction() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.FinishTransaction() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_GetCatalogMasterVersion,

  "Bytes received by yb.tserver.PgClientService.GetCatalogMasterVersion() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.GetCatalogMasterVersion() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_GetCatalogMasterVersion,

  "Bytes sent in response to yb.tserver.PgClientService.GetCatalogMasterVersion() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.GetCatalogMasterVersion() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_GetCatalogMasterVersion,

  "Microseconds spent handling yb.tserver.PgClientService.GetCatalogMasterVersion() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.GetCatalogMasterVersion() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_GetDatabaseInfo,

  "Bytes received by yb.tserver.PgClientService.GetDatabaseInfo() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.GetDatabaseInfo() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_GetDatabaseInfo,

  "Bytes sent in response to yb.tserver.PgClientService.GetDatabaseInfo() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.GetDatabaseInfo() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_GetDatabaseInfo,

  "Microseconds spent handling yb.tserver.PgClientService.GetDatabaseInfo() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.GetDatabaseInfo() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_IsInitDbDone,

  "Bytes received by yb.tserver.PgClientService.IsInitDbDone() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.IsInitDbDone() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_IsInitDbDone,

  "Bytes sent in response to yb.tserver.PgClientService.IsInitDbDone() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.IsInitDbDone() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_IsInitDbDone,

  "Microseconds spent handling yb.tserver.PgClientService.IsInitDbDone() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.IsInitDbDone() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_ListLiveTabletServers,

  "Bytes received by yb.tserver.PgClientService.ListLiveTabletServers() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.ListLiveTabletServers() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_ListLiveTabletServers,

  "Bytes sent in response to yb.tserver.PgClientService.ListLiveTabletServers() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.ListLiveTabletServers() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_ListLiveTabletServers,

  "Microseconds spent handling yb.tserver.PgClientService.ListLiveTabletServers() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.ListLiveTabletServers() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_OpenTable,

  "Bytes received by yb.tserver.PgClientService.OpenTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.OpenTable() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_OpenTable,

  "Bytes sent in response to yb.tserver.PgClientService.OpenTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.OpenTable() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_OpenTable,

  "Microseconds spent handling yb.tserver.PgClientService.OpenTable() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.OpenTable() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_Perform,

  "Bytes received by yb.tserver.PgClientService.Perform() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.Perform() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_Perform,

  "Bytes sent in response to yb.tserver.PgClientService.Perform() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.Perform() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_Perform,

  "Microseconds spent handling yb.tserver.PgClientService.Perform() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.Perform() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_ReserveOids,

  "Bytes received by yb.tserver.PgClientService.ReserveOids() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.ReserveOids() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_ReserveOids,

  "Bytes sent in response to yb.tserver.PgClientService.ReserveOids() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.ReserveOids() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_ReserveOids,

  "Microseconds spent handling yb.tserver.PgClientService.ReserveOids() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.ReserveOids() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_RollbackSubTransaction,

  "Bytes received by yb.tserver.PgClientService.RollbackSubTransaction() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.RollbackSubTransaction() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_RollbackSubTransaction,

  "Bytes sent in response to yb.tserver.PgClientService.RollbackSubTransaction() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.RollbackSubTransaction() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_RollbackSubTransaction,

  "Microseconds spent handling yb.tserver.PgClientService.RollbackSubTransaction() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.RollbackSubTransaction() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_SetActiveSubTransaction,

  "Bytes received by yb.tserver.PgClientService.SetActiveSubTransaction() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.SetActiveSubTransaction() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_SetActiveSubTransaction,

  "Bytes sent in response to yb.tserver.PgClientService.SetActiveSubTransaction() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.SetActiveSubTransaction() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_SetActiveSubTransaction,

  "Microseconds spent handling yb.tserver.PgClientService.SetActiveSubTransaction() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.SetActiveSubTransaction() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_TabletServerCount,

  "Bytes received by yb.tserver.PgClientService.TabletServerCount() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.TabletServerCount() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_TabletServerCount,

  "Bytes sent in response to yb.tserver.PgClientService.TabletServerCount() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.TabletServerCount() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_TabletServerCount,

  "Microseconds spent handling yb.tserver.PgClientService.TabletServerCount() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.TabletServerCount() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_TruncateTable,

  "Bytes received by yb.tserver.PgClientService.TruncateTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.TruncateTable() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_TruncateTable,

  "Bytes sent in response to yb.tserver.PgClientService.TruncateTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.TruncateTable() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_TruncateTable,

  "Microseconds spent handling yb.tserver.PgClientService.TruncateTable() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.TruncateTable() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_PgClientService_ValidatePlacement,

  "Bytes received by yb.tserver.PgClientService.ValidatePlacement() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.PgClientService.ValidatePlacement() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_PgClientService_ValidatePlacement,

  "Bytes sent in response to yb.tserver.PgClientService.ValidatePlacement() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.PgClientService.ValidatePlacement() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_PgClientService_ValidatePlacement,

  "Microseconds spent handling yb.tserver.PgClientService.ValidatePlacement() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.PgClientService.ValidatePlacement() RPC requests",

  60000000LU, 2);

namespace yb {

namespace tserver {

PgClientServiceIf::PgClientServiceIf(const scoped_refptr<MetricEntity>& entity) {

  InitMethods(entity);

}

PgClientServiceIf::~PgClientServiceIf() {

}

void PgClientServiceIf::FillEndpoints(const ::yb::rpc::RpcServicePtr& service, ::yb::rpc::RpcEndpointMap* map) {

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kHeartbeat)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kHeartbeat)));

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kAlterDatabase)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kAlterDatabase)));

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kAlterTable)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kAlterTable)));

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kBackfillIndex)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kBackfillIndex)));

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateDatabase)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateDatabase)));

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateSequencesDataTable)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateSequencesDataTable)));

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateTable)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateTable)));

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateTablegroup)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateTablegroup)));

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kDropDatabase)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kDropDatabase)));

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kDropTable)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kDropTable)));

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kDropTablegroup)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kDropTablegroup)));

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kFinishTransaction)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kFinishTransaction)));

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kGetCatalogMasterVersion)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kGetCatalogMasterVersion)));

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kGetDatabaseInfo)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kGetDatabaseInfo)));

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kIsInitDbDone)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kIsInitDbDone)));

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kListLiveTabletServers)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kListLiveTabletServers)));

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kOpenTable)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kOpenTable)));

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kPerform)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kPerform)));

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kReserveOids)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kReserveOids)));

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kRollbackSubTransaction)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kRollbackSubTransaction)));

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kSetActiveSubTransaction)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kSetActiveSubTransaction)));

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kTabletServerCount)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kTabletServerCount)));

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kTruncateTable)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kTruncateTable)));

  map->emplace(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kValidatePlacement)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(PgClientServiceRpcMethodIndexes::kValidatePlacement)));

}

void PgClientServiceIf::Handle(::yb::rpc::InboundCallPtr call) {

  auto index = call->method_index();

  methods_[index].handler(std::move(call));

}

std::string PgClientServiceIf::service_name() const {

  return "yb.tserver.PgClientService";

}

std::string PgClientServiceIf::static_service_name() {

  return "yb.tserver.PgClientService";

}

void PgClientServiceIf::InitMethods(const scoped_refptr<MetricEntity>& entity) {

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kHeartbeat)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "Heartbeat"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kHeartbeat)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgHeartbeatRequestPB, ::yb::tserver::PgHeartbeatResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgHeartbeatRequestPB* req, ::yb::tserver::PgHeartbeatResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        Heartbeat(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_Heartbeat.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_Heartbeat.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_Heartbeat.Instantiate(entity))

  };

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kAlterDatabase)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "AlterDatabase"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kAlterDatabase)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgAlterDatabaseRequestPB, ::yb::tserver::PgAlterDatabaseResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgAlterDatabaseRequestPB* req, ::yb::tserver::PgAlterDatabaseResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        AlterDatabase(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_AlterDatabase.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_AlterDatabase.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_AlterDatabase.Instantiate(entity))

  };

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kAlterTable)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "AlterTable"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kAlterTable)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgAlterTableRequestPB, ::yb::tserver::PgAlterTableResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgAlterTableRequestPB* req, ::yb::tserver::PgAlterTableResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        AlterTable(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_AlterTable.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_AlterTable.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_AlterTable.Instantiate(entity))

  };

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kBackfillIndex)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "BackfillIndex"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kBackfillIndex)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgBackfillIndexRequestPB, ::yb::tserver::PgBackfillIndexResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgBackfillIndexRequestPB* req, ::yb::tserver::PgBackfillIndexResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        BackfillIndex(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_BackfillIndex.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_BackfillIndex.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_BackfillIndex.Instantiate(entity))

  };

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateDatabase)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "CreateDatabase"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateDatabase)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgCreateDatabaseRequestPB, ::yb::tserver::PgCreateDatabaseResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgCreateDatabaseRequestPB* req, ::yb::tserver::PgCreateDatabaseResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        CreateDatabase(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_CreateDatabase.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_CreateDatabase.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_CreateDatabase.Instantiate(entity))

  };

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateSequencesDataTable)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "CreateSequencesDataTable"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateSequencesDataTable)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgCreateSequencesDataTableRequestPB, ::yb::tserver::PgCreateSequencesDataTableResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgCreateSequencesDataTableRequestPB* req, ::yb::tserver::PgCreateSequencesDataTableResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        CreateSequencesDataTable(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_CreateSequencesDataTable.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_CreateSequencesDataTable.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_CreateSequencesDataTable.Instantiate(entity))

  };

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateTable)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "CreateTable"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateTable)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgCreateTableRequestPB, ::yb::tserver::PgCreateTableResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgCreateTableRequestPB* req, ::yb::tserver::PgCreateTableResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        CreateTable(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_CreateTable.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_CreateTable.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_CreateTable.Instantiate(entity))

  };

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateTablegroup)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "CreateTablegroup"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateTablegroup)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgCreateTablegroupRequestPB, ::yb::tserver::PgCreateTablegroupResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgCreateTablegroupRequestPB* req, ::yb::tserver::PgCreateTablegroupResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        CreateTablegroup(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_CreateTablegroup.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_CreateTablegroup.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_CreateTablegroup.Instantiate(entity))

  };

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kDropDatabase)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "DropDatabase"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kDropDatabase)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgDropDatabaseRequestPB, ::yb::tserver::PgDropDatabaseResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgDropDatabaseRequestPB* req, ::yb::tserver::PgDropDatabaseResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        DropDatabase(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_DropDatabase.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_DropDatabase.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_DropDatabase.Instantiate(entity))

  };

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kDropTable)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "DropTable"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kDropTable)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgDropTableRequestPB, ::yb::tserver::PgDropTableResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgDropTableRequestPB* req, ::yb::tserver::PgDropTableResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        DropTable(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_DropTable.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_DropTable.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_DropTable.Instantiate(entity))

  };

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kDropTablegroup)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "DropTablegroup"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kDropTablegroup)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgDropTablegroupRequestPB, ::yb::tserver::PgDropTablegroupResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgDropTablegroupRequestPB* req, ::yb::tserver::PgDropTablegroupResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        DropTablegroup(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_DropTablegroup.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_DropTablegroup.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_DropTablegroup.Instantiate(entity))

  };

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kFinishTransaction)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "FinishTransaction"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kFinishTransaction)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgFinishTransactionRequestPB, ::yb::tserver::PgFinishTransactionResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgFinishTransactionRequestPB* req, ::yb::tserver::PgFinishTransactionResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        FinishTransaction(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_FinishTransaction.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_FinishTransaction.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_FinishTransaction.Instantiate(entity))

  };

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kGetCatalogMasterVersion)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "GetCatalogMasterVersion"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kGetCatalogMasterVersion)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgGetCatalogMasterVersionRequestPB, ::yb::tserver::PgGetCatalogMasterVersionResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgGetCatalogMasterVersionRequestPB* req, ::yb::tserver::PgGetCatalogMasterVersionResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        GetCatalogMasterVersion(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_GetCatalogMasterVersion.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_GetCatalogMasterVersion.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_GetCatalogMasterVersion.Instantiate(entity))

  };

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kGetDatabaseInfo)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "GetDatabaseInfo"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kGetDatabaseInfo)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgGetDatabaseInfoRequestPB, ::yb::tserver::PgGetDatabaseInfoResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgGetDatabaseInfoRequestPB* req, ::yb::tserver::PgGetDatabaseInfoResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        GetDatabaseInfo(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_GetDatabaseInfo.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_GetDatabaseInfo.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_GetDatabaseInfo.Instantiate(entity))

  };

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kIsInitDbDone)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "IsInitDbDone"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kIsInitDbDone)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgIsInitDbDoneRequestPB, ::yb::tserver::PgIsInitDbDoneResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgIsInitDbDoneRequestPB* req, ::yb::tserver::PgIsInitDbDoneResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        IsInitDbDone(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_IsInitDbDone.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_IsInitDbDone.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_IsInitDbDone.Instantiate(entity))

  };

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kListLiveTabletServers)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "ListLiveTabletServers"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kListLiveTabletServers)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgListLiveTabletServersRequestPB, ::yb::tserver::PgListLiveTabletServersResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgListLiveTabletServersRequestPB* req, ::yb::tserver::PgListLiveTabletServersResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        ListLiveTabletServers(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_ListLiveTabletServers.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_ListLiveTabletServers.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_ListLiveTabletServers.Instantiate(entity))

  };

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kOpenTable)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "OpenTable"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kOpenTable)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgOpenTableRequestPB, ::yb::tserver::PgOpenTableResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgOpenTableRequestPB* req, ::yb::tserver::PgOpenTableResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        OpenTable(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_OpenTable.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_OpenTable.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_OpenTable.Instantiate(entity))

  };

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kPerform)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "Perform"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kPerform)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgPerformRequestPB, ::yb::tserver::PgPerformResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgPerformRequestPB* req, ::yb::tserver::PgPerformResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        Perform(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_Perform.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_Perform.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_Perform.Instantiate(entity))

  };

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kReserveOids)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "ReserveOids"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kReserveOids)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgReserveOidsRequestPB, ::yb::tserver::PgReserveOidsResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgReserveOidsRequestPB* req, ::yb::tserver::PgReserveOidsResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        ReserveOids(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_ReserveOids.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_ReserveOids.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_ReserveOids.Instantiate(entity))

  };

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kRollbackSubTransaction)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "RollbackSubTransaction"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kRollbackSubTransaction)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgRollbackSubTransactionRequestPB, ::yb::tserver::PgRollbackSubTransactionResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgRollbackSubTransactionRequestPB* req, ::yb::tserver::PgRollbackSubTransactionResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        RollbackSubTransaction(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_RollbackSubTransaction.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_RollbackSubTransaction.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_RollbackSubTransaction.Instantiate(entity))

  };

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kSetActiveSubTransaction)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "SetActiveSubTransaction"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kSetActiveSubTransaction)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgSetActiveSubTransactionRequestPB, ::yb::tserver::PgSetActiveSubTransactionResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgSetActiveSubTransactionRequestPB* req, ::yb::tserver::PgSetActiveSubTransactionResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        SetActiveSubTransaction(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_SetActiveSubTransaction.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_SetActiveSubTransaction.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_SetActiveSubTransaction.Instantiate(entity))

  };

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kTabletServerCount)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "TabletServerCount"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kTabletServerCount)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgTabletServerCountRequestPB, ::yb::tserver::PgTabletServerCountResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgTabletServerCountRequestPB* req, ::yb::tserver::PgTabletServerCountResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        TabletServerCount(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_TabletServerCount.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_TabletServerCount.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_TabletServerCount.Instantiate(entity))

  };

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kTruncateTable)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "TruncateTable"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kTruncateTable)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgTruncateTableRequestPB, ::yb::tserver::PgTruncateTableResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgTruncateTableRequestPB* req, ::yb::tserver::PgTruncateTableResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        TruncateTable(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_TruncateTable.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_TruncateTable.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_TruncateTable.Instantiate(entity))

  };

  methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kValidatePlacement)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.PgClientService", "ValidatePlacement"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(PgClientServiceRpcMethodIndexes::kValidatePlacement)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PgValidatePlacementRequestPB, ::yb::tserver::PgValidatePlacementResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PgValidatePlacementRequestPB* req, ::yb::tserver::PgValidatePlacementResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        ValidatePlacement(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_tserver_PgClientService_ValidatePlacement.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_PgClientService_ValidatePlacement.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_PgClientService_ValidatePlacement.Instantiate(entity))

  };

}

} // namespace tserver

} // namespace yb