/Users/deen/code/yugabyte-db/build/debugcov-clang-dynamic-arm64-ninja/src/yb/tserver/pg_client.proxy.cc

Source (jump to first uncovered line)
// THIS FILE IS AUTOGENERATED FROM yb/tserver/pg_client.proto

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

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

#include "yb/rpc/proxy.h"
#include "yb/rpc/outbound_call.h"
#include "yb/util/metrics.h"
#include "yb/util/net/sockaddr.h"

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_Heartbeat,
  "Bytes sent by yb.tserver.PgClientService.Heartbeat() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.Heartbeat() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_Heartbeat,
  "Bytes received in response to yb.tserver.PgClientService.Heartbeat() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.Heartbeat() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_AlterDatabase,
  "Bytes sent by yb.tserver.PgClientService.AlterDatabase() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.AlterDatabase() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_AlterDatabase,
  "Bytes received in response to yb.tserver.PgClientService.AlterDatabase() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.AlterDatabase() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_AlterTable,
  "Bytes sent by yb.tserver.PgClientService.AlterTable() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.AlterTable() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_AlterTable,
  "Bytes received in response to yb.tserver.PgClientService.AlterTable() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.AlterTable() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_BackfillIndex,
  "Bytes sent by yb.tserver.PgClientService.BackfillIndex() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.BackfillIndex() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_BackfillIndex,
  "Bytes received in response to yb.tserver.PgClientService.BackfillIndex() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.BackfillIndex() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_CreateDatabase,
  "Bytes sent by yb.tserver.PgClientService.CreateDatabase() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.CreateDatabase() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_CreateDatabase,
  "Bytes received in response to yb.tserver.PgClientService.CreateDatabase() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.CreateDatabase() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_CreateSequencesDataTable,
  "Bytes sent by yb.tserver.PgClientService.CreateSequencesDataTable() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.CreateSequencesDataTable() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_CreateSequencesDataTable,
  "Bytes received in response to yb.tserver.PgClientService.CreateSequencesDataTable() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.CreateSequencesDataTable() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_CreateTable,
  "Bytes sent by yb.tserver.PgClientService.CreateTable() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.CreateTable() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_CreateTable,
  "Bytes received in response to yb.tserver.PgClientService.CreateTable() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.CreateTable() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_CreateTablegroup,
  "Bytes sent by yb.tserver.PgClientService.CreateTablegroup() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.CreateTablegroup() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_CreateTablegroup,
  "Bytes received in response to yb.tserver.PgClientService.CreateTablegroup() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.CreateTablegroup() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_DropDatabase,
  "Bytes sent by yb.tserver.PgClientService.DropDatabase() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.DropDatabase() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_DropDatabase,
  "Bytes received in response to yb.tserver.PgClientService.DropDatabase() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.DropDatabase() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_DropTable,
  "Bytes sent by yb.tserver.PgClientService.DropTable() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.DropTable() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_DropTable,
  "Bytes received in response to yb.tserver.PgClientService.DropTable() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.DropTable() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_DropTablegroup,
  "Bytes sent by yb.tserver.PgClientService.DropTablegroup() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.DropTablegroup() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_DropTablegroup,
  "Bytes received in response to yb.tserver.PgClientService.DropTablegroup() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.DropTablegroup() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_FinishTransaction,
  "Bytes sent by yb.tserver.PgClientService.FinishTransaction() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.FinishTransaction() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_FinishTransaction,
  "Bytes received in response to yb.tserver.PgClientService.FinishTransaction() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.FinishTransaction() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_GetCatalogMasterVersion,
  "Bytes sent by yb.tserver.PgClientService.GetCatalogMasterVersion() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.GetCatalogMasterVersion() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_GetCatalogMasterVersion,
  "Bytes received in response to yb.tserver.PgClientService.GetCatalogMasterVersion() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.GetCatalogMasterVersion() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_GetDatabaseInfo,
  "Bytes sent by yb.tserver.PgClientService.GetDatabaseInfo() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.GetDatabaseInfo() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_GetDatabaseInfo,
  "Bytes received in response to yb.tserver.PgClientService.GetDatabaseInfo() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.GetDatabaseInfo() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_IsInitDbDone,
  "Bytes sent by yb.tserver.PgClientService.IsInitDbDone() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.IsInitDbDone() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_IsInitDbDone,
  "Bytes received in response to yb.tserver.PgClientService.IsInitDbDone() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.IsInitDbDone() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_ListLiveTabletServers,
  "Bytes sent by yb.tserver.PgClientService.ListLiveTabletServers() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.ListLiveTabletServers() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_ListLiveTabletServers,
  "Bytes received in response to yb.tserver.PgClientService.ListLiveTabletServers() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.ListLiveTabletServers() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_OpenTable,
  "Bytes sent by yb.tserver.PgClientService.OpenTable() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.OpenTable() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_OpenTable,
  "Bytes received in response to yb.tserver.PgClientService.OpenTable() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.OpenTable() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_Perform,
  "Bytes sent by yb.tserver.PgClientService.Perform() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.Perform() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_Perform,
  "Bytes received in response to yb.tserver.PgClientService.Perform() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.Perform() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_ReserveOids,
  "Bytes sent by yb.tserver.PgClientService.ReserveOids() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.ReserveOids() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_ReserveOids,
  "Bytes received in response to yb.tserver.PgClientService.ReserveOids() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.ReserveOids() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_RollbackSubTransaction,
  "Bytes sent by yb.tserver.PgClientService.RollbackSubTransaction() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.RollbackSubTransaction() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_RollbackSubTransaction,
  "Bytes received in response to yb.tserver.PgClientService.RollbackSubTransaction() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.RollbackSubTransaction() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_SetActiveSubTransaction,
  "Bytes sent by yb.tserver.PgClientService.SetActiveSubTransaction() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.SetActiveSubTransaction() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_SetActiveSubTransaction,
  "Bytes received in response to yb.tserver.PgClientService.SetActiveSubTransaction() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.SetActiveSubTransaction() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_TabletServerCount,
  "Bytes sent by yb.tserver.PgClientService.TabletServerCount() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.TabletServerCount() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_TabletServerCount,
  "Bytes received in response to yb.tserver.PgClientService.TabletServerCount() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.TabletServerCount() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_TruncateTable,
  "Bytes sent by yb.tserver.PgClientService.TruncateTable() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.TruncateTable() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_TruncateTable,
  "Bytes received in response to yb.tserver.PgClientService.TruncateTable() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.TruncateTable() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_tserver_PgClientService_ValidatePlacement,
  "Bytes sent by yb.tserver.PgClientService.ValidatePlacement() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.tserver.PgClientService.ValidatePlacement() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_tserver_PgClientService_ValidatePlacement,
  "Bytes received in response to yb.tserver.PgClientService.ValidatePlacement() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.tserver.PgClientService.ValidatePlacement() RPC requests");

namespace yb {
namespace tserver {


namespace {

const std::string kFullPgClientServiceName = "yb.tserver.PgClientService";

::yb::rpc::ProxyMetricsPtr CreatePgClientServiceMetrics(const scoped_refptr<MetricEntity>& entity) {
  auto result = std::make_shared<::yb::rpc::ProxyMetricsImpl<24>>();
  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kHeartbeat)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_Heartbeat.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_Heartbeat.Instantiate(entity)
  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kAlterDatabase)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_AlterDatabase.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_AlterDatabase.Instantiate(entity)
  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kAlterTable)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_AlterTable.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_AlterTable.Instantiate(entity)
  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kBackfillIndex)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_BackfillIndex.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_BackfillIndex.Instantiate(entity)
  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kCreateDatabase)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_CreateDatabase.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_CreateDatabase.Instantiate(entity)
  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kCreateSequencesDataTable)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_CreateSequencesDataTable.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_CreateSequencesDataTable.Instantiate(entity)
  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kCreateTable)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_CreateTable.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_CreateTable.Instantiate(entity)
  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kCreateTablegroup)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_CreateTablegroup.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_CreateTablegroup.Instantiate(entity)
  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kDropDatabase)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_DropDatabase.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_DropDatabase.Instantiate(entity)
  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kDropTable)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_DropTable.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_DropTable.Instantiate(entity)
  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kDropTablegroup)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_DropTablegroup.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_DropTablegroup.Instantiate(entity)
  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kFinishTransaction)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_FinishTransaction.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_FinishTransaction.Instantiate(entity)
  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kGetCatalogMasterVersion)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_GetCatalogMasterVersion.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_GetCatalogMasterVersion.Instantiate(entity)
  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kGetDatabaseInfo)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_GetDatabaseInfo.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_GetDatabaseInfo.Instantiate(entity)
  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kIsInitDbDone)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_IsInitDbDone.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_IsInitDbDone.Instantiate(entity)
  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kListLiveTabletServers)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_ListLiveTabletServers.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_ListLiveTabletServers.Instantiate(entity)
  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kOpenTable)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_OpenTable.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_OpenTable.Instantiate(entity)
  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kPerform)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_Perform.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_Perform.Instantiate(entity)
  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kReserveOids)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_ReserveOids.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_ReserveOids.Instantiate(entity)
  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kRollbackSubTransaction)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_RollbackSubTransaction.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_RollbackSubTransaction.Instantiate(entity)
  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kSetActiveSubTransaction)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_SetActiveSubTransaction.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_SetActiveSubTransaction.Instantiate(entity)
  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kTabletServerCount)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_TabletServerCount.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_TabletServerCount.Instantiate(entity)
  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kTruncateTable)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_TruncateTable.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_TruncateTable.Instantiate(entity)
  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kValidatePlacement)] = {
      METRIC_proxy_request_bytes_yb_tserver_PgClientService_ValidatePlacement.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_tserver_PgClientService_ValidatePlacement.Instantiate(entity)
  };

  return result;
}


} // namespace

PgClientServiceProxy::PgClientServiceProxy(
    ::yb::rpc::ProxyCache* cache, const ::yb::HostPort& remote,
    const ::yb::rpc::Protocol* protocol,
    const ::yb::MonoDelta& resolve_cache_timeout)
    : ProxyBase(kFullPgClientServiceName, &CreatePgClientServiceMetrics,
                cache, remote, protocol, resolve_cache_timeout) {}

::yb::Status PgClientServiceProxy::Heartbeat(
    const ::yb::tserver::PgHeartbeatRequestPB &req, ::yb::tserver::PgHeartbeatResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "Heartbeat");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kHeartbeat)), req, resp, controller);
}

void PgClientServiceProxy::HeartbeatAsync(
    const ::yb::tserver::PgHeartbeatRequestPB &req, ::yb::tserver::PgHeartbeatResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "Heartbeat");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kHeartbeat)), req, resp, controller, std::move(callback));
}

::yb::Status PgClientServiceProxy::AlterDatabase(
    const ::yb::tserver::PgAlterDatabaseRequestPB &req, ::yb::tserver::PgAlterDatabaseResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "AlterDatabase");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kAlterDatabase)), req, resp, controller);
}

void PgClientServiceProxy::AlterDatabaseAsync(
    const ::yb::tserver::PgAlterDatabaseRequestPB &req, ::yb::tserver::PgAlterDatabaseResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "AlterDatabase");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kAlterDatabase)), req, resp, controller, std::move(callback));
}

::yb::Status PgClientServiceProxy::AlterTable(
    const ::yb::tserver::PgAlterTableRequestPB &req, ::yb::tserver::PgAlterTableResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "AlterTable");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kAlterTable)), req, resp, controller);
}

void PgClientServiceProxy::AlterTableAsync(
    const ::yb::tserver::PgAlterTableRequestPB &req, ::yb::tserver::PgAlterTableResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "AlterTable");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kAlterTable)), req, resp, controller, std::move(callback));
}

::yb::Status PgClientServiceProxy::BackfillIndex(
    const ::yb::tserver::PgBackfillIndexRequestPB &req, ::yb::tserver::PgBackfillIndexResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "BackfillIndex");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kBackfillIndex)), req, resp, controller);
}

void PgClientServiceProxy::BackfillIndexAsync(
    const ::yb::tserver::PgBackfillIndexRequestPB &req, ::yb::tserver::PgBackfillIndexResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "BackfillIndex");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kBackfillIndex)), req, resp, controller, std::move(callback));
}

::yb::Status PgClientServiceProxy::CreateDatabase(
    const ::yb::tserver::PgCreateDatabaseRequestPB &req, ::yb::tserver::PgCreateDatabaseResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "CreateDatabase");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateDatabase)), req, resp, controller);
}

void PgClientServiceProxy::CreateDatabaseAsync(
    const ::yb::tserver::PgCreateDatabaseRequestPB &req, ::yb::tserver::PgCreateDatabaseResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "CreateDatabase");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateDatabase)), req, resp, controller, std::move(callback));
}

::yb::Status PgClientServiceProxy::CreateSequencesDataTable(
    const ::yb::tserver::PgCreateSequencesDataTableRequestPB &req, ::yb::tserver::PgCreateSequencesDataTableResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "CreateSequencesDataTable");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateSequencesDataTable)), req, resp, controller);
}

void PgClientServiceProxy::CreateSequencesDataTableAsync(
    const ::yb::tserver::PgCreateSequencesDataTableRequestPB &req, ::yb::tserver::PgCreateSequencesDataTableResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "CreateSequencesDataTable");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateSequencesDataTable)), req, resp, controller, std::move(callback));
}

::yb::Status PgClientServiceProxy::CreateTable(
    const ::yb::tserver::PgCreateTableRequestPB &req, ::yb::tserver::PgCreateTableResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "CreateTable");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateTable)), req, resp, controller);
}

void PgClientServiceProxy::CreateTableAsync(
    const ::yb::tserver::PgCreateTableRequestPB &req, ::yb::tserver::PgCreateTableResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "CreateTable");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateTable)), req, resp, controller, std::move(callback));
}

::yb::Status PgClientServiceProxy::CreateTablegroup(
    const ::yb::tserver::PgCreateTablegroupRequestPB &req, ::yb::tserver::PgCreateTablegroupResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "CreateTablegroup");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateTablegroup)), req, resp, controller);
}

void PgClientServiceProxy::CreateTablegroupAsync(
    const ::yb::tserver::PgCreateTablegroupRequestPB &req, ::yb::tserver::PgCreateTablegroupResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "CreateTablegroup");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kCreateTablegroup)), req, resp, controller, std::move(callback));
}

::yb::Status PgClientServiceProxy::DropDatabase(
    const ::yb::tserver::PgDropDatabaseRequestPB &req, ::yb::tserver::PgDropDatabaseResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "DropDatabase");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kDropDatabase)), req, resp, controller);
}

void PgClientServiceProxy::DropDatabaseAsync(
    const ::yb::tserver::PgDropDatabaseRequestPB &req, ::yb::tserver::PgDropDatabaseResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "DropDatabase");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kDropDatabase)), req, resp, controller, std::move(callback));
}

::yb::Status PgClientServiceProxy::DropTable(
    const ::yb::tserver::PgDropTableRequestPB &req, ::yb::tserver::PgDropTableResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "DropTable");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kDropTable)), req, resp, controller);
}

void PgClientServiceProxy::DropTableAsync(
    const ::yb::tserver::PgDropTableRequestPB &req, ::yb::tserver::PgDropTableResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "DropTable");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kDropTable)), req, resp, controller, std::move(callback));
}

::yb::Status PgClientServiceProxy::DropTablegroup(
    const ::yb::tserver::PgDropTablegroupRequestPB &req, ::yb::tserver::PgDropTablegroupResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "DropTablegroup");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kDropTablegroup)), req, resp, controller);
}

void PgClientServiceProxy::DropTablegroupAsync(
    const ::yb::tserver::PgDropTablegroupRequestPB &req, ::yb::tserver::PgDropTablegroupResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "DropTablegroup");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kDropTablegroup)), req, resp, controller, std::move(callback));
}

::yb::Status PgClientServiceProxy::FinishTransaction(
    const ::yb::tserver::PgFinishTransactionRequestPB &req, ::yb::tserver::PgFinishTransactionResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "FinishTransaction");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kFinishTransaction)), req, resp, controller);
}

void PgClientServiceProxy::FinishTransactionAsync(
    const ::yb::tserver::PgFinishTransactionRequestPB &req, ::yb::tserver::PgFinishTransactionResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "FinishTransaction");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kFinishTransaction)), req, resp, controller, std::move(callback));
}

::yb::Status PgClientServiceProxy::GetCatalogMasterVersion(
    const ::yb::tserver::PgGetCatalogMasterVersionRequestPB &req, ::yb::tserver::PgGetCatalogMasterVersionResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "GetCatalogMasterVersion");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kGetCatalogMasterVersion)), req, resp, controller);
}

void PgClientServiceProxy::GetCatalogMasterVersionAsync(
    const ::yb::tserver::PgGetCatalogMasterVersionRequestPB &req, ::yb::tserver::PgGetCatalogMasterVersionResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "GetCatalogMasterVersion");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kGetCatalogMasterVersion)), req, resp, controller, std::move(callback));
}

::yb::Status PgClientServiceProxy::GetDatabaseInfo(
    const ::yb::tserver::PgGetDatabaseInfoRequestPB &req, ::yb::tserver::PgGetDatabaseInfoResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "GetDatabaseInfo");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kGetDatabaseInfo)), req, resp, controller);
}

void PgClientServiceProxy::GetDatabaseInfoAsync(
    const ::yb::tserver::PgGetDatabaseInfoRequestPB &req, ::yb::tserver::PgGetDatabaseInfoResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "GetDatabaseInfo");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kGetDatabaseInfo)), req, resp, controller, std::move(callback));
}

::yb::Status PgClientServiceProxy::IsInitDbDone(
    const ::yb::tserver::PgIsInitDbDoneRequestPB &req, ::yb::tserver::PgIsInitDbDoneResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "IsInitDbDone");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kIsInitDbDone)), req, resp, controller);
}

void PgClientServiceProxy::IsInitDbDoneAsync(
    const ::yb::tserver::PgIsInitDbDoneRequestPB &req, ::yb::tserver::PgIsInitDbDoneResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "IsInitDbDone");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kIsInitDbDone)), req, resp, controller, std::move(callback));
}

::yb::Status PgClientServiceProxy::ListLiveTabletServers(
    const ::yb::tserver::PgListLiveTabletServersRequestPB &req, ::yb::tserver::PgListLiveTabletServersResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "ListLiveTabletServers");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kListLiveTabletServers)), req, resp, controller);
}

void PgClientServiceProxy::ListLiveTabletServersAsync(
    const ::yb::tserver::PgListLiveTabletServersRequestPB &req, ::yb::tserver::PgListLiveTabletServersResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "ListLiveTabletServers");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kListLiveTabletServers)), req, resp, controller, std::move(callback));
}

::yb::Status PgClientServiceProxy::OpenTable(
    const ::yb::tserver::PgOpenTableRequestPB &req, ::yb::tserver::PgOpenTableResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "OpenTable");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kOpenTable)), req, resp, controller);
}

void PgClientServiceProxy::OpenTableAsync(
    const ::yb::tserver::PgOpenTableRequestPB &req, ::yb::tserver::PgOpenTableResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "OpenTable");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kOpenTable)), req, resp, controller, std::move(callback));
}

::yb::Status PgClientServiceProxy::Perform(
    const ::yb::tserver::PgPerformRequestPB &req, ::yb::tserver::PgPerformResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "Perform");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kPerform)), req, resp, controller);
}

void PgClientServiceProxy::PerformAsync(
    const ::yb::tserver::PgPerformRequestPB &req, ::yb::tserver::PgPerformResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "Perform");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kPerform)), req, resp, controller, std::move(callback));
}

::yb::Status PgClientServiceProxy::ReserveOids(
    const ::yb::tserver::PgReserveOidsRequestPB &req, ::yb::tserver::PgReserveOidsResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "ReserveOids");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kReserveOids)), req, resp, controller);
}

void PgClientServiceProxy::ReserveOidsAsync(
    const ::yb::tserver::PgReserveOidsRequestPB &req, ::yb::tserver::PgReserveOidsResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "ReserveOids");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kReserveOids)), req, resp, controller, std::move(callback));
}

::yb::Status PgClientServiceProxy::RollbackSubTransaction(
    const ::yb::tserver::PgRollbackSubTransactionRequestPB &req, ::yb::tserver::PgRollbackSubTransactionResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "RollbackSubTransaction");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kRollbackSubTransaction)), req, resp, controller);
}

void PgClientServiceProxy::RollbackSubTransactionAsync(
    const ::yb::tserver::PgRollbackSubTransactionRequestPB &req, ::yb::tserver::PgRollbackSubTransactionResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "RollbackSubTransaction");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kRollbackSubTransaction)), req, resp, controller, std::move(callback));
}

::yb::Status PgClientServiceProxy::SetActiveSubTransaction(
    const ::yb::tserver::PgSetActiveSubTransactionRequestPB &req, ::yb::tserver::PgSetActiveSubTransactionResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "SetActiveSubTransaction");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kSetActiveSubTransaction)), req, resp, controller);
}

void PgClientServiceProxy::SetActiveSubTransactionAsync(
    const ::yb::tserver::PgSetActiveSubTransactionRequestPB &req, ::yb::tserver::PgSetActiveSubTransactionResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "SetActiveSubTransaction");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kSetActiveSubTransaction)), req, resp, controller, std::move(callback));
}

::yb::Status PgClientServiceProxy::TabletServerCount(
    const ::yb::tserver::PgTabletServerCountRequestPB &req, ::yb::tserver::PgTabletServerCountResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "TabletServerCount");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kTabletServerCount)), req, resp, controller);
}

void PgClientServiceProxy::TabletServerCountAsync(
    const ::yb::tserver::PgTabletServerCountRequestPB &req, ::yb::tserver::PgTabletServerCountResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "TabletServerCount");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kTabletServerCount)), req, resp, controller, std::move(callback));
}

::yb::Status PgClientServiceProxy::TruncateTable(
    const ::yb::tserver::PgTruncateTableRequestPB &req, ::yb::tserver::PgTruncateTableResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "TruncateTable");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kTruncateTable)), req, resp, controller);
}

void PgClientServiceProxy::TruncateTableAsync(
    const ::yb::tserver::PgTruncateTableRequestPB &req, ::yb::tserver::PgTruncateTableResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "TruncateTable");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kTruncateTable)), req, resp, controller, std::move(callback));
}

::yb::Status PgClientServiceProxy::ValidatePlacement(
    const ::yb::tserver::PgValidatePlacementRequestPB &req, ::yb::tserver::PgValidatePlacementResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "ValidatePlacement");
  return proxy().SyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kValidatePlacement)), req, resp, controller);
}

void PgClientServiceProxy::ValidatePlacementAsync(
    const ::yb::tserver::PgValidatePlacementRequestPB &req, ::yb::tserver::PgValidatePlacementResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "ValidatePlacement");
  proxy().AsyncRequest(
      &method, metrics<24>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kValidatePlacement)), req, resp, controller, std::move(callback));
}

} // namespace tserver
} // namespace yb

YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

Coverage Report

Created: 2022-03-09 17:30