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

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

#include "yb/master/master_ddl.proxy.h"

#include "yb/master/master_ddl.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_master_MasterDdl_CreateTable,
  "Bytes sent by yb.master.MasterDdl.CreateTable() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.CreateTable() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_CreateTable,
  "Bytes received in response to yb.master.MasterDdl.CreateTable() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.CreateTable() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_IsCreateTableDone,
  "Bytes sent by yb.master.MasterDdl.IsCreateTableDone() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.IsCreateTableDone() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_IsCreateTableDone,
  "Bytes received in response to yb.master.MasterDdl.IsCreateTableDone() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.IsCreateTableDone() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_ListTables,
  "Bytes sent by yb.master.MasterDdl.ListTables() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.ListTables() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_ListTables,
  "Bytes received in response to yb.master.MasterDdl.ListTables() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.ListTables() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_GetTableSchema,
  "Bytes sent by yb.master.MasterDdl.GetTableSchema() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.GetTableSchema() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_GetTableSchema,
  "Bytes received in response to yb.master.MasterDdl.GetTableSchema() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.GetTableSchema() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_GetTablegroupSchema,
  "Bytes sent by yb.master.MasterDdl.GetTablegroupSchema() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.GetTablegroupSchema() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_GetTablegroupSchema,
  "Bytes received in response to yb.master.MasterDdl.GetTablegroupSchema() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.GetTablegroupSchema() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_GetColocatedTabletSchema,
  "Bytes sent by yb.master.MasterDdl.GetColocatedTabletSchema() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.GetColocatedTabletSchema() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_GetColocatedTabletSchema,
  "Bytes received in response to yb.master.MasterDdl.GetColocatedTabletSchema() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.GetColocatedTabletSchema() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_TruncateTable,
  "Bytes sent by yb.master.MasterDdl.TruncateTable() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.TruncateTable() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_TruncateTable,
  "Bytes received in response to yb.master.MasterDdl.TruncateTable() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.TruncateTable() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_IsTruncateTableDone,
  "Bytes sent by yb.master.MasterDdl.IsTruncateTableDone() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.IsTruncateTableDone() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_IsTruncateTableDone,
  "Bytes received in response to yb.master.MasterDdl.IsTruncateTableDone() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.IsTruncateTableDone() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_BackfillIndex,
  "Bytes sent by yb.master.MasterDdl.BackfillIndex() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.BackfillIndex() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_BackfillIndex,
  "Bytes received in response to yb.master.MasterDdl.BackfillIndex() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.BackfillIndex() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_LaunchBackfillIndexForTable,
  "Bytes sent by yb.master.MasterDdl.LaunchBackfillIndexForTable() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.LaunchBackfillIndexForTable() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_LaunchBackfillIndexForTable,
  "Bytes received in response to yb.master.MasterDdl.LaunchBackfillIndexForTable() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.LaunchBackfillIndexForTable() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_GetBackfillJobs,
  "Bytes sent by yb.master.MasterDdl.GetBackfillJobs() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.GetBackfillJobs() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_GetBackfillJobs,
  "Bytes received in response to yb.master.MasterDdl.GetBackfillJobs() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.GetBackfillJobs() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_DeleteTable,
  "Bytes sent by yb.master.MasterDdl.DeleteTable() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.DeleteTable() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_DeleteTable,
  "Bytes received in response to yb.master.MasterDdl.DeleteTable() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.DeleteTable() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_IsDeleteTableDone,
  "Bytes sent by yb.master.MasterDdl.IsDeleteTableDone() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.IsDeleteTableDone() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_IsDeleteTableDone,
  "Bytes received in response to yb.master.MasterDdl.IsDeleteTableDone() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.IsDeleteTableDone() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_AlterTable,
  "Bytes sent by yb.master.MasterDdl.AlterTable() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.AlterTable() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_AlterTable,
  "Bytes received in response to yb.master.MasterDdl.AlterTable() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.AlterTable() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_IsAlterTableDone,
  "Bytes sent by yb.master.MasterDdl.IsAlterTableDone() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.IsAlterTableDone() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_IsAlterTableDone,
  "Bytes received in response to yb.master.MasterDdl.IsAlterTableDone() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.IsAlterTableDone() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_CreateNamespace,
  "Bytes sent by yb.master.MasterDdl.CreateNamespace() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.CreateNamespace() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_CreateNamespace,
  "Bytes received in response to yb.master.MasterDdl.CreateNamespace() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.CreateNamespace() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_IsCreateNamespaceDone,
  "Bytes sent by yb.master.MasterDdl.IsCreateNamespaceDone() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.IsCreateNamespaceDone() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_IsCreateNamespaceDone,
  "Bytes received in response to yb.master.MasterDdl.IsCreateNamespaceDone() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.IsCreateNamespaceDone() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_DeleteNamespace,
  "Bytes sent by yb.master.MasterDdl.DeleteNamespace() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.DeleteNamespace() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_DeleteNamespace,
  "Bytes received in response to yb.master.MasterDdl.DeleteNamespace() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.DeleteNamespace() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_IsDeleteNamespaceDone,
  "Bytes sent by yb.master.MasterDdl.IsDeleteNamespaceDone() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.IsDeleteNamespaceDone() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_IsDeleteNamespaceDone,
  "Bytes received in response to yb.master.MasterDdl.IsDeleteNamespaceDone() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.IsDeleteNamespaceDone() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_AlterNamespace,
  "Bytes sent by yb.master.MasterDdl.AlterNamespace() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.AlterNamespace() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_AlterNamespace,
  "Bytes received in response to yb.master.MasterDdl.AlterNamespace() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.AlterNamespace() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_ListNamespaces,
  "Bytes sent by yb.master.MasterDdl.ListNamespaces() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.ListNamespaces() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_ListNamespaces,
  "Bytes received in response to yb.master.MasterDdl.ListNamespaces() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.ListNamespaces() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_GetNamespaceInfo,
  "Bytes sent by yb.master.MasterDdl.GetNamespaceInfo() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.GetNamespaceInfo() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_GetNamespaceInfo,
  "Bytes received in response to yb.master.MasterDdl.GetNamespaceInfo() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.GetNamespaceInfo() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_CreateTablegroup,
  "Bytes sent by yb.master.MasterDdl.CreateTablegroup() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.CreateTablegroup() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_CreateTablegroup,
  "Bytes received in response to yb.master.MasterDdl.CreateTablegroup() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.CreateTablegroup() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_DeleteTablegroup,
  "Bytes sent by yb.master.MasterDdl.DeleteTablegroup() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.DeleteTablegroup() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_DeleteTablegroup,
  "Bytes received in response to yb.master.MasterDdl.DeleteTablegroup() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.DeleteTablegroup() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_ListTablegroups,
  "Bytes sent by yb.master.MasterDdl.ListTablegroups() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.ListTablegroups() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_ListTablegroups,
  "Bytes received in response to yb.master.MasterDdl.ListTablegroups() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.ListTablegroups() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_CreateUDType,
  "Bytes sent by yb.master.MasterDdl.CreateUDType() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.CreateUDType() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_CreateUDType,
  "Bytes received in response to yb.master.MasterDdl.CreateUDType() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.CreateUDType() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_DeleteUDType,
  "Bytes sent by yb.master.MasterDdl.DeleteUDType() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.DeleteUDType() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_DeleteUDType,
  "Bytes received in response to yb.master.MasterDdl.DeleteUDType() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.DeleteUDType() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_ListUDTypes,
  "Bytes sent by yb.master.MasterDdl.ListUDTypes() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.ListUDTypes() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_ListUDTypes,
  "Bytes received in response to yb.master.MasterDdl.ListUDTypes() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.ListUDTypes() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_master_MasterDdl_GetUDTypeInfo,
  "Bytes sent by yb.master.MasterDdl.GetUDTypeInfo() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.master.MasterDdl.GetUDTypeInfo() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_master_MasterDdl_GetUDTypeInfo,
  "Bytes received in response to yb.master.MasterDdl.GetUDTypeInfo() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.master.MasterDdl.GetUDTypeInfo() RPC requests");

namespace yb {
namespace master {


namespace {

const std::string kFullMasterDdlName = "yb.master.MasterDdl";

::yb::rpc::ProxyMetricsPtr CreateMasterDdlMetrics(const scoped_refptr<MetricEntity>& entity) {
  auto result = std::make_shared<::yb::rpc::ProxyMetricsImpl<29>>();
  result->value[to_underlying(MasterDdlRpcMethodIndexes::kCreateTable)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_CreateTable.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_CreateTable.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kIsCreateTableDone)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_IsCreateTableDone.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_IsCreateTableDone.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kListTables)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_ListTables.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_ListTables.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kGetTableSchema)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_GetTableSchema.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_GetTableSchema.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kGetTablegroupSchema)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_GetTablegroupSchema.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_GetTablegroupSchema.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kGetColocatedTabletSchema)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_GetColocatedTabletSchema.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_GetColocatedTabletSchema.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kTruncateTable)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_TruncateTable.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_TruncateTable.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kIsTruncateTableDone)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_IsTruncateTableDone.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_IsTruncateTableDone.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kBackfillIndex)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_BackfillIndex.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_BackfillIndex.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kLaunchBackfillIndexForTable)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_LaunchBackfillIndexForTable.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_LaunchBackfillIndexForTable.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kGetBackfillJobs)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_GetBackfillJobs.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_GetBackfillJobs.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kDeleteTable)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_DeleteTable.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_DeleteTable.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kIsDeleteTableDone)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_IsDeleteTableDone.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_IsDeleteTableDone.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kAlterTable)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_AlterTable.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_AlterTable.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kIsAlterTableDone)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_IsAlterTableDone.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_IsAlterTableDone.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kCreateNamespace)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_CreateNamespace.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_CreateNamespace.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kIsCreateNamespaceDone)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_IsCreateNamespaceDone.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_IsCreateNamespaceDone.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kDeleteNamespace)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_DeleteNamespace.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_DeleteNamespace.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kIsDeleteNamespaceDone)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_IsDeleteNamespaceDone.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_IsDeleteNamespaceDone.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kAlterNamespace)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_AlterNamespace.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_AlterNamespace.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kListNamespaces)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_ListNamespaces.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_ListNamespaces.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kGetNamespaceInfo)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_GetNamespaceInfo.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_GetNamespaceInfo.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kCreateTablegroup)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_CreateTablegroup.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_CreateTablegroup.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kDeleteTablegroup)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_DeleteTablegroup.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_DeleteTablegroup.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kListTablegroups)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_ListTablegroups.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_ListTablegroups.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kCreateUDType)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_CreateUDType.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_CreateUDType.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kDeleteUDType)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_DeleteUDType.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_DeleteUDType.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kListUDTypes)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_ListUDTypes.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_ListUDTypes.Instantiate(entity)
  };

  result->value[to_underlying(MasterDdlRpcMethodIndexes::kGetUDTypeInfo)] = {
      METRIC_proxy_request_bytes_yb_master_MasterDdl_GetUDTypeInfo.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_master_MasterDdl_GetUDTypeInfo.Instantiate(entity)
  };

  return result;
}


} // namespace

MasterDdlProxy::MasterDdlProxy(
    ::yb::rpc::ProxyCache* cache, const ::yb::HostPort& remote,
    const ::yb::rpc::Protocol* protocol,
    const ::yb::MonoDelta& resolve_cache_timeout)
    : ProxyBase(kFullMasterDdlName, &CreateMasterDdlMetrics,
                cache, remote, protocol, resolve_cache_timeout) {}

::yb::Status MasterDdlProxy::CreateTable(
    const ::yb::master::CreateTableRequestPB &req, ::yb::master::CreateTableResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "CreateTable");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateTable)), req, resp, controller);
}

void MasterDdlProxy::CreateTableAsync(
    const ::yb::master::CreateTableRequestPB &req, ::yb::master::CreateTableResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "CreateTable");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateTable)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::IsCreateTableDone(
    const ::yb::master::IsCreateTableDoneRequestPB &req, ::yb::master::IsCreateTableDoneResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "IsCreateTableDone");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsCreateTableDone)), req, resp, controller);
}

void MasterDdlProxy::IsCreateTableDoneAsync(
    const ::yb::master::IsCreateTableDoneRequestPB &req, ::yb::master::IsCreateTableDoneResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "IsCreateTableDone");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsCreateTableDone)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::ListTables(
    const ::yb::master::ListTablesRequestPB &req, ::yb::master::ListTablesResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "ListTables");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kListTables)), req, resp, controller);
}

void MasterDdlProxy::ListTablesAsync(
    const ::yb::master::ListTablesRequestPB &req, ::yb::master::ListTablesResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "ListTables");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kListTables)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::GetTableSchema(
    const ::yb::master::GetTableSchemaRequestPB &req, ::yb::master::GetTableSchemaResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "GetTableSchema");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetTableSchema)), req, resp, controller);
}

void MasterDdlProxy::GetTableSchemaAsync(
    const ::yb::master::GetTableSchemaRequestPB &req, ::yb::master::GetTableSchemaResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "GetTableSchema");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetTableSchema)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::GetTablegroupSchema(
    const ::yb::master::GetTablegroupSchemaRequestPB &req, ::yb::master::GetTablegroupSchemaResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "GetTablegroupSchema");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetTablegroupSchema)), req, resp, controller);
}

void MasterDdlProxy::GetTablegroupSchemaAsync(
    const ::yb::master::GetTablegroupSchemaRequestPB &req, ::yb::master::GetTablegroupSchemaResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "GetTablegroupSchema");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetTablegroupSchema)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::GetColocatedTabletSchema(
    const ::yb::master::GetColocatedTabletSchemaRequestPB &req, ::yb::master::GetColocatedTabletSchemaResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "GetColocatedTabletSchema");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetColocatedTabletSchema)), req, resp, controller);
}

void MasterDdlProxy::GetColocatedTabletSchemaAsync(
    const ::yb::master::GetColocatedTabletSchemaRequestPB &req, ::yb::master::GetColocatedTabletSchemaResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "GetColocatedTabletSchema");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetColocatedTabletSchema)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::TruncateTable(
    const ::yb::master::TruncateTableRequestPB &req, ::yb::master::TruncateTableResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "TruncateTable");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kTruncateTable)), req, resp, controller);
}

void MasterDdlProxy::TruncateTableAsync(
    const ::yb::master::TruncateTableRequestPB &req, ::yb::master::TruncateTableResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "TruncateTable");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kTruncateTable)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::IsTruncateTableDone(
    const ::yb::master::IsTruncateTableDoneRequestPB &req, ::yb::master::IsTruncateTableDoneResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "IsTruncateTableDone");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsTruncateTableDone)), req, resp, controller);
}

void MasterDdlProxy::IsTruncateTableDoneAsync(
    const ::yb::master::IsTruncateTableDoneRequestPB &req, ::yb::master::IsTruncateTableDoneResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "IsTruncateTableDone");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsTruncateTableDone)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::BackfillIndex(
    const ::yb::master::BackfillIndexRequestPB &req, ::yb::master::BackfillIndexResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "BackfillIndex");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kBackfillIndex)), req, resp, controller);
}

void MasterDdlProxy::BackfillIndexAsync(
    const ::yb::master::BackfillIndexRequestPB &req, ::yb::master::BackfillIndexResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "BackfillIndex");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kBackfillIndex)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::LaunchBackfillIndexForTable(
    const ::yb::master::LaunchBackfillIndexForTableRequestPB &req, ::yb::master::LaunchBackfillIndexForTableResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "LaunchBackfillIndexForTable");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kLaunchBackfillIndexForTable)), req, resp, controller);
}

void MasterDdlProxy::LaunchBackfillIndexForTableAsync(
    const ::yb::master::LaunchBackfillIndexForTableRequestPB &req, ::yb::master::LaunchBackfillIndexForTableResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "LaunchBackfillIndexForTable");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kLaunchBackfillIndexForTable)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::GetBackfillJobs(
    const ::yb::master::GetBackfillJobsRequestPB &req, ::yb::master::GetBackfillJobsResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "GetBackfillJobs");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetBackfillJobs)), req, resp, controller);
}

void MasterDdlProxy::GetBackfillJobsAsync(
    const ::yb::master::GetBackfillJobsRequestPB &req, ::yb::master::GetBackfillJobsResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "GetBackfillJobs");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetBackfillJobs)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::DeleteTable(
    const ::yb::master::DeleteTableRequestPB &req, ::yb::master::DeleteTableResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "DeleteTable");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteTable)), req, resp, controller);
}

void MasterDdlProxy::DeleteTableAsync(
    const ::yb::master::DeleteTableRequestPB &req, ::yb::master::DeleteTableResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "DeleteTable");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteTable)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::IsDeleteTableDone(
    const ::yb::master::IsDeleteTableDoneRequestPB &req, ::yb::master::IsDeleteTableDoneResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "IsDeleteTableDone");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsDeleteTableDone)), req, resp, controller);
}

void MasterDdlProxy::IsDeleteTableDoneAsync(
    const ::yb::master::IsDeleteTableDoneRequestPB &req, ::yb::master::IsDeleteTableDoneResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "IsDeleteTableDone");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsDeleteTableDone)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::AlterTable(
    const ::yb::master::AlterTableRequestPB &req, ::yb::master::AlterTableResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "AlterTable");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kAlterTable)), req, resp, controller);
}

void MasterDdlProxy::AlterTableAsync(
    const ::yb::master::AlterTableRequestPB &req, ::yb::master::AlterTableResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "AlterTable");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kAlterTable)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::IsAlterTableDone(
    const ::yb::master::IsAlterTableDoneRequestPB &req, ::yb::master::IsAlterTableDoneResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "IsAlterTableDone");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsAlterTableDone)), req, resp, controller);
}

void MasterDdlProxy::IsAlterTableDoneAsync(
    const ::yb::master::IsAlterTableDoneRequestPB &req, ::yb::master::IsAlterTableDoneResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "IsAlterTableDone");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsAlterTableDone)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::CreateNamespace(
    const ::yb::master::CreateNamespaceRequestPB &req, ::yb::master::CreateNamespaceResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "CreateNamespace");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateNamespace)), req, resp, controller);
}

void MasterDdlProxy::CreateNamespaceAsync(
    const ::yb::master::CreateNamespaceRequestPB &req, ::yb::master::CreateNamespaceResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "CreateNamespace");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateNamespace)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::IsCreateNamespaceDone(
    const ::yb::master::IsCreateNamespaceDoneRequestPB &req, ::yb::master::IsCreateNamespaceDoneResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "IsCreateNamespaceDone");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsCreateNamespaceDone)), req, resp, controller);
}

void MasterDdlProxy::IsCreateNamespaceDoneAsync(
    const ::yb::master::IsCreateNamespaceDoneRequestPB &req, ::yb::master::IsCreateNamespaceDoneResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "IsCreateNamespaceDone");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsCreateNamespaceDone)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::DeleteNamespace(
    const ::yb::master::DeleteNamespaceRequestPB &req, ::yb::master::DeleteNamespaceResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "DeleteNamespace");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteNamespace)), req, resp, controller);
}

void MasterDdlProxy::DeleteNamespaceAsync(
    const ::yb::master::DeleteNamespaceRequestPB &req, ::yb::master::DeleteNamespaceResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "DeleteNamespace");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteNamespace)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::IsDeleteNamespaceDone(
    const ::yb::master::IsDeleteNamespaceDoneRequestPB &req, ::yb::master::IsDeleteNamespaceDoneResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "IsDeleteNamespaceDone");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsDeleteNamespaceDone)), req, resp, controller);
}

void MasterDdlProxy::IsDeleteNamespaceDoneAsync(
    const ::yb::master::IsDeleteNamespaceDoneRequestPB &req, ::yb::master::IsDeleteNamespaceDoneResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "IsDeleteNamespaceDone");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kIsDeleteNamespaceDone)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::AlterNamespace(
    const ::yb::master::AlterNamespaceRequestPB &req, ::yb::master::AlterNamespaceResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "AlterNamespace");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kAlterNamespace)), req, resp, controller);
}

void MasterDdlProxy::AlterNamespaceAsync(
    const ::yb::master::AlterNamespaceRequestPB &req, ::yb::master::AlterNamespaceResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "AlterNamespace");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kAlterNamespace)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::ListNamespaces(
    const ::yb::master::ListNamespacesRequestPB &req, ::yb::master::ListNamespacesResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "ListNamespaces");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kListNamespaces)), req, resp, controller);
}

void MasterDdlProxy::ListNamespacesAsync(
    const ::yb::master::ListNamespacesRequestPB &req, ::yb::master::ListNamespacesResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "ListNamespaces");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kListNamespaces)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::GetNamespaceInfo(
    const ::yb::master::GetNamespaceInfoRequestPB &req, ::yb::master::GetNamespaceInfoResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "GetNamespaceInfo");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetNamespaceInfo)), req, resp, controller);
}

void MasterDdlProxy::GetNamespaceInfoAsync(
    const ::yb::master::GetNamespaceInfoRequestPB &req, ::yb::master::GetNamespaceInfoResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "GetNamespaceInfo");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetNamespaceInfo)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::CreateTablegroup(
    const ::yb::master::CreateTablegroupRequestPB &req, ::yb::master::CreateTablegroupResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "CreateTablegroup");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateTablegroup)), req, resp, controller);
}

void MasterDdlProxy::CreateTablegroupAsync(
    const ::yb::master::CreateTablegroupRequestPB &req, ::yb::master::CreateTablegroupResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "CreateTablegroup");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateTablegroup)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::DeleteTablegroup(
    const ::yb::master::DeleteTablegroupRequestPB &req, ::yb::master::DeleteTablegroupResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "DeleteTablegroup");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteTablegroup)), req, resp, controller);
}

void MasterDdlProxy::DeleteTablegroupAsync(
    const ::yb::master::DeleteTablegroupRequestPB &req, ::yb::master::DeleteTablegroupResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "DeleteTablegroup");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteTablegroup)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::ListTablegroups(
    const ::yb::master::ListTablegroupsRequestPB &req, ::yb::master::ListTablegroupsResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "ListTablegroups");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kListTablegroups)), req, resp, controller);
}

void MasterDdlProxy::ListTablegroupsAsync(
    const ::yb::master::ListTablegroupsRequestPB &req, ::yb::master::ListTablegroupsResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "ListTablegroups");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kListTablegroups)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::CreateUDType(
    const ::yb::master::CreateUDTypeRequestPB &req, ::yb::master::CreateUDTypeResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "CreateUDType");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateUDType)), req, resp, controller);
}

void MasterDdlProxy::CreateUDTypeAsync(
    const ::yb::master::CreateUDTypeRequestPB &req, ::yb::master::CreateUDTypeResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "CreateUDType");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kCreateUDType)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::DeleteUDType(
    const ::yb::master::DeleteUDTypeRequestPB &req, ::yb::master::DeleteUDTypeResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "DeleteUDType");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteUDType)), req, resp, controller);
}

void MasterDdlProxy::DeleteUDTypeAsync(
    const ::yb::master::DeleteUDTypeRequestPB &req, ::yb::master::DeleteUDTypeResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "DeleteUDType");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kDeleteUDType)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::ListUDTypes(
    const ::yb::master::ListUDTypesRequestPB &req, ::yb::master::ListUDTypesResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "ListUDTypes");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kListUDTypes)), req, resp, controller);
}

void MasterDdlProxy::ListUDTypesAsync(
    const ::yb::master::ListUDTypesRequestPB &req, ::yb::master::ListUDTypesResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "ListUDTypes");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kListUDTypes)), req, resp, controller, std::move(callback));
}

::yb::Status MasterDdlProxy::GetUDTypeInfo(
    const ::yb::master::GetUDTypeInfoRequestPB &req, ::yb::master::GetUDTypeInfoResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "GetUDTypeInfo");
  return proxy().SyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetUDTypeInfo)), req, resp, controller);
}

void MasterDdlProxy::GetUDTypeInfoAsync(
    const ::yb::master::GetUDTypeInfoRequestPB &req, ::yb::master::GetUDTypeInfoResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.master.MasterService", "GetUDTypeInfo");
  proxy().AsyncRequest(
      &method, metrics<29>(static_cast<size_t>(MasterDdlRpcMethodIndexes::kGetUDTypeInfo)), req, resp, controller, std::move(callback));
}

} // namespace master
} // namespace yb

YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

Coverage Report

Created: 2022-03-09 17:30