YugabyteDB (2.13.1.0-b60, 21121d69985fbf76aa6958d8f04a9bfa936293b5)

// 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");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_PgClientService_InsertSequenceTuple,

  "Bytes sent by yb.tserver.PgClientService.InsertSequenceTuple() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.tserver.PgClientService.InsertSequenceTuple() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_PgClientService_InsertSequenceTuple,

  "Bytes received in response to yb.tserver.PgClientService.InsertSequenceTuple() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.tserver.PgClientService.InsertSequenceTuple() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_PgClientService_UpdateSequenceTuple,

  "Bytes sent by yb.tserver.PgClientService.UpdateSequenceTuple() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.tserver.PgClientService.UpdateSequenceTuple() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_PgClientService_UpdateSequenceTuple,

  "Bytes received in response to yb.tserver.PgClientService.UpdateSequenceTuple() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.tserver.PgClientService.UpdateSequenceTuple() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_PgClientService_ReadSequenceTuple,

  "Bytes sent by yb.tserver.PgClientService.ReadSequenceTuple() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.tserver.PgClientService.ReadSequenceTuple() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_PgClientService_ReadSequenceTuple,

  "Bytes received in response to yb.tserver.PgClientService.ReadSequenceTuple() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.tserver.PgClientService.ReadSequenceTuple() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_PgClientService_DeleteSequenceTuple,

  "Bytes sent by yb.tserver.PgClientService.DeleteSequenceTuple() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.tserver.PgClientService.DeleteSequenceTuple() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_PgClientService_DeleteSequenceTuple,

  "Bytes received in response to yb.tserver.PgClientService.DeleteSequenceTuple() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.tserver.PgClientService.DeleteSequenceTuple() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_PgClientService_DeleteDBSequences,

  "Bytes sent by yb.tserver.PgClientService.DeleteDBSequences() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.tserver.PgClientService.DeleteDBSequences() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_PgClientService_DeleteDBSequences,

  "Bytes received in response to yb.tserver.PgClientService.DeleteDBSequences() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.tserver.PgClientService.DeleteDBSequences() 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<29>>();

  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)

  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kInsertSequenceTuple)] = {

      METRIC_proxy_request_bytes_yb_tserver_PgClientService_InsertSequenceTuple.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_PgClientService_InsertSequenceTuple.Instantiate(entity)

  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kUpdateSequenceTuple)] = {

      METRIC_proxy_request_bytes_yb_tserver_PgClientService_UpdateSequenceTuple.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_PgClientService_UpdateSequenceTuple.Instantiate(entity)

  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kReadSequenceTuple)] = {

      METRIC_proxy_request_bytes_yb_tserver_PgClientService_ReadSequenceTuple.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_PgClientService_ReadSequenceTuple.Instantiate(entity)

  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kDeleteSequenceTuple)] = {

      METRIC_proxy_request_bytes_yb_tserver_PgClientService_DeleteSequenceTuple.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_PgClientService_DeleteSequenceTuple.Instantiate(entity)

  };

  result->value[to_underlying(PgClientServiceRpcMethodIndexes::kDeleteDBSequences)] = {

      METRIC_proxy_request_bytes_yb_tserver_PgClientService_DeleteDBSequences.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_PgClientService_DeleteDBSequences.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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(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<29>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kValidatePlacement)), req, resp, controller, std::move(callback));

}

::yb::Status PgClientServiceProxy::InsertSequenceTuple(

    const ::yb::tserver::PgInsertSequenceTupleRequestPB &req, ::yb::tserver::PgInsertSequenceTupleResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "InsertSequenceTuple");

  return proxy().SyncRequest(

      &method, metrics<29>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kInsertSequenceTuple)), req, resp, controller);

}

void PgClientServiceProxy::InsertSequenceTupleAsync(

    const ::yb::tserver::PgInsertSequenceTupleRequestPB &req, ::yb::tserver::PgInsertSequenceTupleResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "InsertSequenceTuple");

  proxy().AsyncRequest(

      &method, metrics<29>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kInsertSequenceTuple)), req, resp, controller, std::move(callback));

}

::yb::Status PgClientServiceProxy::UpdateSequenceTuple(

    const ::yb::tserver::PgUpdateSequenceTupleRequestPB &req, ::yb::tserver::PgUpdateSequenceTupleResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "UpdateSequenceTuple");

  return proxy().SyncRequest(

      &method, metrics<29>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kUpdateSequenceTuple)), req, resp, controller);

}

void PgClientServiceProxy::UpdateSequenceTupleAsync(

    const ::yb::tserver::PgUpdateSequenceTupleRequestPB &req, ::yb::tserver::PgUpdateSequenceTupleResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "UpdateSequenceTuple");

  proxy().AsyncRequest(

      &method, metrics<29>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kUpdateSequenceTuple)), req, resp, controller, std::move(callback));

}

::yb::Status PgClientServiceProxy::ReadSequenceTuple(

    const ::yb::tserver::PgReadSequenceTupleRequestPB &req, ::yb::tserver::PgReadSequenceTupleResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "ReadSequenceTuple");

  return proxy().SyncRequest(

      &method, metrics<29>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kReadSequenceTuple)), req, resp, controller);

}

void PgClientServiceProxy::ReadSequenceTupleAsync(

    const ::yb::tserver::PgReadSequenceTupleRequestPB &req, ::yb::tserver::PgReadSequenceTupleResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "ReadSequenceTuple");

  proxy().AsyncRequest(

      &method, metrics<29>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kReadSequenceTuple)), req, resp, controller, std::move(callback));

}

::yb::Status PgClientServiceProxy::DeleteSequenceTuple(

    const ::yb::tserver::PgDeleteSequenceTupleRequestPB &req, ::yb::tserver::PgDeleteSequenceTupleResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "DeleteSequenceTuple");

  return proxy().SyncRequest(

      &method, metrics<29>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kDeleteSequenceTuple)), req, resp, controller);

}

void PgClientServiceProxy::DeleteSequenceTupleAsync(

    const ::yb::tserver::PgDeleteSequenceTupleRequestPB &req, ::yb::tserver::PgDeleteSequenceTupleResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "DeleteSequenceTuple");

  proxy().AsyncRequest(

      &method, metrics<29>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kDeleteSequenceTuple)), req, resp, controller, std::move(callback));

}

::yb::Status PgClientServiceProxy::DeleteDBSequences(

    const ::yb::tserver::PgDeleteDBSequencesRequestPB &req, ::yb::tserver::PgDeleteDBSequencesResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "DeleteDBSequences");

  return proxy().SyncRequest(

      &method, metrics<29>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kDeleteDBSequences)), req, resp, controller);

}

void PgClientServiceProxy::DeleteDBSequencesAsync(

    const ::yb::tserver::PgDeleteDBSequencesRequestPB &req, ::yb::tserver::PgDeleteDBSequencesResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

  static ::yb::rpc::RemoteMethod method("yb.tserver.PgClientService", "DeleteDBSequences");

  proxy().AsyncRequest(

      &method, metrics<29>(static_cast<size_t>(PgClientServiceRpcMethodIndexes::kDeleteDBSequences)), req, resp, controller, std::move(callback));

}

} // namespace tserver

} // namespace yb